Merge #19760: test: Remove confusing mininode terminology

d5800da5199527a366024bc80cad7fcca17d5c4a [test] Remove final references to mininode (John Newbery) 5e8df3312e47a73e747ee892face55ed9ababeea test: resort imports (John Newbery) 85165d4332b0f72d30e0c584b476249b542338e6 scripted-diff: Rename mininode to p2p (John Newbery) 9e2897d020b114a10c860f90c5405be029afddba scripted-diff: Rename mininode_lock to p2p_lock (John Newbery) Pull request description: New contributors are often confused by the terminology in the test framework, and what the difference between a _node_ and a _peer_ is. To summarize: - a 'node' is a bitcoind instance. This is the thing whose behavior is being tested. Each bitcoind node is managed by a python `TestNode` object which is used to start/stop the node, manage the node's data directory, read state about the node (eg process status, log file), and interact with the node over different interfaces. - one of the interfaces that we can use to interact with the node is the p2p interface. Each connection to a node using this interface is managed by a python `P2PInterface` or derived object (which is owned by the `TestNode` object). We can open zero, one or many p2p connections to each bitcoind node. The node sees these connections as 'peers'. For historic reasons, the word 'mininode' has been used to refer to those p2p interface objects that we use to connect to the bitcoind node (the code was originally taken from the 'mini-node' branch of https://github.com/jgarzik/pynode/tree/mini-node). However that name has proved to be confusing for new contributors, so rename the remaining references. ACKs for top commit: amitiuttarwar: ACK d5800da519 MarcoFalke: ACK d5800da5199527a366024bc80cad7fcca17d5c4a 🚞 Tree-SHA512: 2c46c2ac3c4278b6e3c647cfd8108428a41e80788fc4f0e386e5b0c47675bc687d94779496c09a3e5ea1319617295be10c422adeeff2d2bd68378e00e0eeb5de
2024-12-25 12:02:48 +01:00 · 2024-01-16 02:35:29 +07:00 · 2024-01-16 02:35:29 +07:00 · f34889dcf4
commit f34889dcf4
parent 9d33b30a87
55 changed files with 180 additions and 180 deletions
--- a/test/functional/README.md
+++ b/test/functional/README.md
@ -130,8 +130,8 @@ Base class for functional tests.
 #### [util.py](test_framework/util.py)
 Generally useful functions.

-#### [mininode.py](test_framework/mininode.py)
-Basic code to support P2P connectivity to a dashd.
+#### [p2p.py](test_framework/p2p.py)
+Test objects for interacting with a dashd node over the p2p interface.

 #### [script.py](test_framework/script.py)
 Utilities for manipulating transaction scripts (originally from python-bitcoinlib)
--- a/test/functional/example_test.py
+++ b/test/functional/example_test.py
@ -16,11 +16,11 @@ from collections import defaultdict
 # Avoid wildcard * imports
 from test_framework.blocktools import (create_block, create_coinbase)
 from test_framework.messages import CInv, MSG_BLOCK
-from test_framework.mininode import (
+from test_framework.p2p import (
    P2PInterface,
-    mininode_lock,
    msg_block,
    msg_getdata,
+    p2p_lock,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
@ -169,7 +169,7 @@ class ExampleTest(BitcoinTestFramework):
        height = self.nodes[0].getblockcount()

        for _ in range(10):
-            # Use the mininode and blocktools functionality to manually build a block
+            # Use the blocktools functionality to manually build a block.
            # Calling the generate() rpc is easier, but this allows us to exactly
            # control the blocks and transactions.
            block = create_block(self.tip, create_coinbase(height+1), self.block_time)
@ -205,13 +205,13 @@ class ExampleTest(BitcoinTestFramework):

        # wait_until() will loop until a predicate condition is met. Use it to test properties of the
        # P2PInterface objects.
-        wait_until(lambda: sorted(blocks) == sorted(list(self.nodes[2].p2p.block_receive_map.keys())), timeout=5, lock=mininode_lock)
+        wait_until(lambda: sorted(blocks) == sorted(list(self.nodes[2].p2p.block_receive_map.keys())), timeout=5, lock=p2p_lock)

        self.log.info("Check that each block was received only once")
        # The network thread uses a global lock on data access to the P2PConnection objects when sending and receiving
        # messages. The test thread should acquire the global lock before accessing any P2PConnection data to avoid locking
        # and synchronization issues. Note wait_until() acquires this global lock when testing the predicate.
-        with mininode_lock:
+        with p2p_lock:
            for block in self.nodes[2].p2p.block_receive_map.values():
                assert_equal(block, 1)

--- a/test/functional/feature_assumevalid.py
+++ b/test/functional/feature_assumevalid.py
@ -45,7 +45,7 @@ from test_framework.messages import (
    msg_block,
    msg_headers,
 )
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.script import (CScript, OP_TRUE)
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (assert_equal, set_node_times, wait_until)
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@ -26,7 +26,7 @@ from test_framework.messages import (
    uint256_from_compact,
    uint256_from_str,
 )
-from test_framework.mininode import P2PDataStore
+from test_framework.p2p import P2PDataStore
 from test_framework.script import (
    CScript,
    MAX_SCRIPT_ELEMENT_SIZE,
@ -53,7 +53,7 @@ from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 from data import invalid_txs

-#  Use this class for tests that require behavior other than normal "mininode" behavior.
+#  Use this class for tests that require behavior other than normal p2p behavior.
 #  For now, it is used to serialize a bloated varint (b64).
 class CBrokenBlock(CBlock):
    def initialize(self, base_block):
--- a/test/functional/feature_cltv.py
+++ b/test/functional/feature_cltv.py
@ -10,7 +10,7 @@ Test that the CHECKLOCKTIMEVERIFY soft-fork activates at (regtest) block height

 from test_framework.blocktools import create_coinbase, create_block, create_transaction
 from test_framework.messages import CTransaction, msg_block, ToHex
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP, CScriptNum
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
--- a/test/functional/feature_csv_activation.py
+++ b/test/functional/feature_csv_activation.py
@ -43,7 +43,7 @@ from io import BytesIO

 from test_framework.blocktools import create_coinbase, create_block, create_transaction, TIME_GENESIS_BLOCK
 from test_framework.messages import ToHex, CTransaction
-from test_framework.mininode import P2PDataStore
+from test_framework.p2p import P2PDataStore
 from test_framework.script import (
    CScript,
    OP_CHECKSEQUENCEVERIFY,
--- a/test/functional/feature_dersig.py
+++ b/test/functional/feature_dersig.py
@ -9,7 +9,7 @@ Test that the DERSIG soft-fork activates at (regtest) height 1251.

 from test_framework.blocktools import create_coinbase, create_block, create_transaction
 from test_framework.messages import msg_block
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.script import CScript
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
--- a/test/functional/feature_dip3_v19.py
+++ b/test/functional/feature_dip3_v19.py
@ -11,7 +11,7 @@ Checks DIP3 for v19
 '''
 from io import BytesIO

-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, \
    QuorumId, ser_uint256
 from test_framework.test_framework import DashTestFramework
--- a/test/functional/feature_dip4_coinbasemerkleroots.py
+++ b/test/functional/feature_dip4_coinbasemerkleroots.py
@ -13,7 +13,7 @@ Checks DIP4 merkle roots in coinbases
 from io import BytesIO

 from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, QuorumId, ser_uint256
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import assert_equal, wait_until

--- a/test/functional/feature_llmq_data_recovery.py
+++ b/test/functional/feature_llmq_data_recovery.py
@ -4,7 +4,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.

 import time
-from test_framework.mininode import logger
+from test_framework.p2p import logger
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import force_finish_mnsync, wait_until

--- a/test/functional/feature_llmq_evo.py
+++ b/test/functional/feature_llmq_evo.py
@ -12,7 +12,7 @@ Checks EvoNodes
 from _decimal import Decimal
 from io import BytesIO

-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, \
    QuorumId, ser_uint256
 from test_framework.test_framework import DashTestFramework
--- a/test/functional/feature_llmq_is_cl_conflicts.py
+++ b/test/functional/feature_llmq_is_cl_conflicts.py
@ -14,7 +14,7 @@ import struct

 from test_framework.blocktools import create_block_with_mnpayments
 from test_framework.messages import CInv, CTransaction, FromHex, hash256, msg_clsig, msg_inv, ser_string, ToHex, uint256_from_str
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes, wait_until

--- a/test/functional/feature_llmq_rotation.py
+++ b/test/functional/feature_llmq_rotation.py
@ -14,7 +14,7 @@ from io import BytesIO

 from test_framework.test_framework import DashTestFramework
 from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, QuorumId, ser_uint256, sha256
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.util import (
    assert_equal,
    assert_greater_than_or_equal,
--- a/test/functional/feature_llmq_signing.py
+++ b/test/functional/feature_llmq_signing.py
@ -11,7 +11,7 @@ Checks LLMQs signing sessions
 '''

 from test_framework.messages import CSigShare, msg_qsigshare, uint256_to_string
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error, force_finish_mnsync, hex_str_to_bytes, wait_until

--- a/test/functional/feature_maxuploadtarget.py
+++ b/test/functional/feature_maxuploadtarget.py
@ -13,7 +13,7 @@ if uploadtarget has been reached.
 from collections import defaultdict

 from test_framework.messages import CInv, MAX_BLOCK_SIZE, MSG_BLOCK, msg_getdata
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, mine_large_block, set_node_times

--- a/test/functional/feature_versionbits_warning.py
+++ b/test/functional/feature_versionbits_warning.py
@ -12,7 +12,7 @@ import re

 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.messages import msg_block
-from test_framework.mininode import P2PInterface, mininode_lock
+from test_framework.p2p import p2p_lock, P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import wait_until

@ -91,7 +91,7 @@ class VersionBitsWarningTest(BitcoinTestFramework):

        # Generating one block guarantees that we'll get out of IBD
        node.generatetoaddress(1, node_deterministic_address)
-        wait_until(lambda: not node.getblockchaininfo()['initialblockdownload'], timeout=10, lock=mininode_lock)
+        wait_until(lambda: not node.getblockchaininfo()['initialblockdownload'], timeout=10, lock=p2p_lock)
        # Generating one more block will be enough to generate an error.
        node.generatetoaddress(1, node_deterministic_address)
        # Check that get*info() shows the versionbits unknown rules warning
--- a/test/functional/interface_zmq_dash.py
+++ b/test/functional/interface_zmq_dash.py
@ -13,7 +13,7 @@ import struct
 import time

 from test_framework.test_framework import DashTestFramework
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.util import assert_equal, assert_raises_rpc_error
 from test_framework.messages import (
    CBlock,
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@ -8,7 +8,7 @@ from decimal import Decimal

 from test_framework.blocktools import COINBASE_MATURITY
 from test_framework.messages import COIN
-from test_framework.mininode import P2PTxInvStore
+from test_framework.p2p import P2PTxInvStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
--- a/test/functional/mempool_persist.py
+++ b/test/functional/mempool_persist.py
@ -38,8 +38,8 @@ Test is as follows:
 from decimal import Decimal
 import os

+# from test_framework.p2p import P2PTxInvStore
 from test_framework.test_framework import BitcoinTestFramework
-# from test_framework.mininode import P2PTxInvStore
 from test_framework.util import (
    assert_equal,
    assert_greater_than_or_equal, assert_raises_rpc_error,
--- a/test/functional/mempool_unbroadcast.py
+++ b/test/functional/mempool_unbroadcast.py
@ -7,7 +7,7 @@ to peers until a GETDATA is received."""

 import time

-from test_framework.mininode import P2PTxInvStore
+from test_framework.p2p import P2PTxInvStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
--- a/test/functional/mining_basic.py
+++ b/test/functional/mining_basic.py
@ -19,7 +19,7 @@ from test_framework.messages import (
    CBlockHeader,
    BLOCK_HEADER_SIZE,
 )
-from test_framework.mininode import P2PDataStore
+from test_framework.p2p import P2PDataStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
--- a/test/functional/p2p_addr_relay.py
+++ b/test/functional/p2p_addr_relay.py
@ -11,9 +11,7 @@ from test_framework.messages import (
    NODE_NETWORK,
    msg_addr,
 )
-from test_framework.mininode import (
-    P2PInterface,
-)
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
--- a/test/functional/p2p_addrv2_relay.py
+++ b/test/functional/p2p_addrv2_relay.py
@ -11,7 +11,7 @@ from test_framework.messages import (
    msg_addrv2,
    NODE_NETWORK,
 )
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, wait_until

--- a/test/functional/p2p_blockfilters.py
+++ b/test/functional/p2p_blockfilters.py
@ -18,7 +18,7 @@ from test_framework.messages import (
    ser_uint256,
    uint256_from_str,
 )
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
--- a/test/functional/p2p_blocksonly.py
+++ b/test/functional/p2p_blocksonly.py
@ -5,7 +5,7 @@
 """Test p2p blocksonly"""

 from test_framework.messages import msg_tx, CTransaction, FromHex
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal

--- a/test/functional/p2p_compactblocks.py
+++ b/test/functional/p2p_compactblocks.py
@ -9,7 +9,7 @@ import random

 from test_framework.blocktools import COINBASE_MATURITY, create_block, create_coinbase
 from test_framework.messages import BlockTransactions, BlockTransactionsRequest, calculate_shortid, CBlock, CBlockHeader, CInv, COutPoint, CTransaction, CTxIn, CTxOut, FromHex, HeaderAndShortIDs, msg_block, msg_blocktxn, msg_cmpctblock, msg_getblocktxn, msg_getdata, msg_getheaders, msg_headers, msg_inv, msg_sendcmpct, msg_sendheaders, msg_tx, MSG_BLOCK, MSG_CMPCT_BLOCK, NODE_NETWORK, P2PHeaderAndShortIDs, PrefilledTransaction, ToHex, NODE_HEADERS_COMPRESSED
-from test_framework.mininode import mininode_lock, P2PInterface
+from test_framework.p2p import p2p_lock, P2PInterface
 from test_framework.script import CScript, OP_TRUE, OP_DROP
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, wait_until
@ -46,12 +46,12 @@ class TestP2PConn(P2PInterface):
                self.block_announced = True
                self.announced_blockhashes.add(x.hash)

-    # Requires caller to hold mininode_lock
+    # Requires caller to hold p2p_lock
    def received_block_announcement(self):
        return self.block_announced

    def clear_block_announcement(self):
-        with mininode_lock:
+        with p2p_lock:
            self.block_announced = False
            self.last_message.pop("inv", None)
            self.last_message.pop("headers", None)
@ -71,7 +71,7 @@ class TestP2PConn(P2PInterface):
    def request_headers_and_sync(self, locator, hashstop=0):
        self.clear_block_announcement()
        self.get_headers(locator, hashstop)
-        wait_until(self.received_block_announcement, timeout=30, lock=mininode_lock)
+        wait_until(self.received_block_announcement, timeout=30, lock=p2p_lock)
        self.clear_block_announcement()

    # Block until a block announcement for a particular block hash is
@ -79,7 +79,7 @@ class TestP2PConn(P2PInterface):
    def wait_for_block_announcement(self, block_hash, timeout=30):
        def received_hash():
            return (block_hash in self.announced_blockhashes)
-        wait_until(received_hash, timeout=timeout, lock=mininode_lock)
+        wait_until(received_hash, timeout=timeout, lock=p2p_lock)

    def send_await_disconnect(self, message, timeout=30):
        """Sends a message to the node and wait for disconnect.
@ -87,7 +87,7 @@ class TestP2PConn(P2PInterface):
        This is used when we want to send a message into the node that we expect
        will get us disconnected, eg an invalid block."""
        self.send_message(message)
-        wait_until(lambda: not self.is_connected, timeout=timeout, lock=mininode_lock)
+        wait_until(lambda: not self.is_connected, timeout=timeout, lock=p2p_lock)

 class CompactBlocksTest(BitcoinTestFramework):
    def set_test_params(self):
@ -149,8 +149,8 @@ class CompactBlocksTest(BitcoinTestFramework):
        # Make sure we get a SENDCMPCT message from our peer
        def received_sendcmpct():
            return (len(test_node.last_sendcmpct) > 0)
-        wait_until(received_sendcmpct, timeout=30, lock=mininode_lock)
-        with mininode_lock:
+        wait_until(received_sendcmpct, timeout=30, lock=p2p_lock)
+        with p2p_lock:
            # Check that the first version received is the preferred one
            assert_equal(test_node.last_sendcmpct[0].version, preferred_version)
            # And that we receive versions down to 1.
@ -165,7 +165,7 @@ class CompactBlocksTest(BitcoinTestFramework):
            peer.wait_for_block_announcement(block_hash, timeout=30)
            assert peer.block_announced

-            with mininode_lock:
+            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)))
@ -272,11 +272,11 @@ class CompactBlocksTest(BitcoinTestFramework):
        block.rehash()

        # Wait until the block was announced (via compact blocks)
-        wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=mininode_lock)
+        wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock)

        # Now fetch and check the compact block
        header_and_shortids = None
-        with mininode_lock:
+        with p2p_lock:
            assert "cmpctblock" in test_node.last_message
            # Convert the on-the-wire representation to absolute indexes
            header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
@ -287,11 +287,11 @@ class CompactBlocksTest(BitcoinTestFramework):
        inv = CInv(MSG_CMPCT_BLOCK, block_hash)  # 20 == "CompactBlock"
        test_node.send_message(msg_getdata([inv]))

-        wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=mininode_lock)
+        wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock)

        # Now fetch and check the compact block
        header_and_shortids = None
-        with mininode_lock:
+        with p2p_lock:
            assert "cmpctblock" in test_node.last_message
            # Convert the on-the-wire representation to absolute indexes
            header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
@ -345,7 +345,7 @@ class CompactBlocksTest(BitcoinTestFramework):
            if announce == "inv":
                test_node.send_message(msg_inv([CInv(MSG_BLOCK, block.sha256)]))
                getheaders_key = "getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders"
-                wait_until(lambda: getheaders_key in test_node.last_message, timeout=30, lock=mininode_lock)
+                wait_until(lambda: getheaders_key in test_node.last_message, timeout=30, lock=p2p_lock)
                test_node.send_header_for_blocks([block])
            else:
                test_node.send_header_for_blocks([block])
@ -362,7 +362,7 @@ class CompactBlocksTest(BitcoinTestFramework):
            test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
            assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
            # Expect a getblocktxn message.
-            with mininode_lock:
+            with p2p_lock:
                assert "getblocktxn" in test_node.last_message
                absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute()
            assert_equal(absolute_indexes, [0])  # should be a coinbase request
@ -399,7 +399,7 @@ class CompactBlocksTest(BitcoinTestFramework):
        def test_getblocktxn_response(compact_block, peer, expected_result):
            msg = msg_cmpctblock(compact_block.to_p2p())
            peer.send_and_ping(msg)
-            with mininode_lock:
+            with p2p_lock:
                assert "getblocktxn" in peer.last_message
                absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute()
            assert_equal(absolute_indexes, expected_result)
@ -462,13 +462,13 @@ class CompactBlocksTest(BitcoinTestFramework):
            assert tx.hash in mempool

        # Clear out last request.
-        with mininode_lock:
+        with p2p_lock:
            test_node.last_message.pop("getblocktxn", None)

        # Send compact block
        comp_block.initialize_from_block(block, prefill_list=[0])
        test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
-        with mininode_lock:
+        with p2p_lock:
            # Shouldn't have gotten a request for any transaction
            assert "getblocktxn" not in test_node.last_message

@ -494,7 +494,7 @@ class CompactBlocksTest(BitcoinTestFramework):
        comp_block.initialize_from_block(block, prefill_list=[0])
        test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
        absolute_indexes = []
-        with mininode_lock:
+        with p2p_lock:
            assert "getblocktxn" in test_node.last_message
            absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute()
        assert_equal(absolute_indexes, [6, 7, 8, 9, 10])
@ -538,10 +538,10 @@ class CompactBlocksTest(BitcoinTestFramework):
            num_to_request = random.randint(1, len(block.vtx))
            msg.block_txn_request.from_absolute(sorted(random.sample(range(len(block.vtx)), num_to_request)))
            test_node.send_message(msg)
-            wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10, lock=mininode_lock)
+            wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10, lock=p2p_lock)

            [tx.calc_sha256() for tx in block.vtx]
-            with mininode_lock:
+            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:
@ -555,11 +555,11 @@ class CompactBlocksTest(BitcoinTestFramework):
        # allowed depth for a blocktxn response.
        block_hash = node.getblockhash(current_height)
        msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [0])
-        with mininode_lock:
+        with p2p_lock:
            test_node.last_message.pop("block", None)
            test_node.last_message.pop("blocktxn", None)
        test_node.send_and_ping(msg)
-        with mininode_lock:
+        with p2p_lock:
            test_node.last_message["block"].block.calc_sha256()
            assert_equal(test_node.last_message["block"].block.sha256, int(block_hash, 16))
            assert "blocktxn" not in test_node.last_message
@ -572,21 +572,21 @@ class CompactBlocksTest(BitcoinTestFramework):
        for _ in range(MAX_CMPCTBLOCK_DEPTH + 1):
            test_node.clear_block_announcement()
            new_blocks.append(node.generate(1)[0])
-            wait_until(test_node.received_block_announcement, timeout=30, lock=mininode_lock)
+            wait_until(test_node.received_block_announcement, timeout=30, lock=p2p_lock)

        test_node.clear_block_announcement()
        test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
-        wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=mininode_lock)
+        wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock)

        test_node.clear_block_announcement()
        node.generate(1)
-        wait_until(test_node.received_block_announcement, timeout=30, lock=mininode_lock)
+        wait_until(test_node.received_block_announcement, timeout=30, lock=p2p_lock)
        test_node.clear_block_announcement()
-        with mininode_lock:
+        with p2p_lock:
            test_node.last_message.pop("block", None)
        test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
-        wait_until(lambda: "block" in test_node.last_message, timeout=30, lock=mininode_lock)
-        with mininode_lock:
+        wait_until(lambda: "block" in test_node.last_message, timeout=30, lock=p2p_lock)
+        with p2p_lock:
            test_node.last_message["block"].block.calc_sha256()
            assert_equal(test_node.last_message["block"].block.sha256, int(new_blocks[0], 16))

@ -614,10 +614,10 @@ class CompactBlocksTest(BitcoinTestFramework):
        # (to avoid fingerprinting attacks).
        msg = msg_getblocktxn()
        msg.block_txn_request = BlockTransactionsRequest(block.sha256, [0])
-        with mininode_lock:
+        with p2p_lock:
            test_node.last_message.pop("blocktxn", None)
        test_node.send_and_ping(msg)
-        with mininode_lock:
+        with p2p_lock:
            assert "blocktxn" not in test_node.last_message

    def test_end_to_end_block_relay(self, listeners):
@ -631,8 +631,8 @@ class CompactBlocksTest(BitcoinTestFramework):
        node.submitblock(ToHex(block))

        for l in listeners:
-            wait_until(lambda: "cmpctblock" in l.last_message, timeout=30, lock=mininode_lock)
-        with mininode_lock:
+            wait_until(lambda: "cmpctblock" in l.last_message, timeout=30, lock=p2p_lock)
+        with p2p_lock:
            for l in listeners:
                assert "cmpctblock" in l.last_message
                l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256()
@ -681,7 +681,7 @@ class CompactBlocksTest(BitcoinTestFramework):
            cmpct_block.initialize_from_block(block)
            msg = msg_cmpctblock(cmpct_block.to_p2p())
            peer.send_and_ping(msg)
-            with mininode_lock:
+            with p2p_lock:
                assert "getblocktxn" in peer.last_message
            return block, cmpct_block

--- a/test/functional/p2p_connect_to_devnet.py
+++ b/test/functional/p2p_connect_to_devnet.py
@ -4,7 +4,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test being able to connect to the same devnet"""

-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal

--- a/test/functional/p2p_eviction.py
+++ b/test/functional/p2p_eviction.py
@ -15,11 +15,11 @@ Therefore, this test is limited to the remaining protection criteria.

 import time

-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.mininode import P2PInterface, P2PDataStore
-from test_framework.util import assert_equal, wait_until
 from test_framework.blocktools import COINBASE_MATURITY, create_block, create_coinbase
 from test_framework.messages import CTransaction, FromHex, msg_pong, msg_tx
+from test_framework.p2p import P2PDataStore, P2PInterface
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, wait_until


 class SlowP2PDataStore(P2PDataStore):
--- a/test/functional/p2p_filter.py
+++ b/test/functional/p2p_filter.py
@ -19,7 +19,7 @@ from test_framework.messages import (
    msg_mempool,
    msg_version,
 )
-from test_framework.mininode import P2PInterface, mininode_lock
+from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.script import MAX_SCRIPT_ELEMENT_SIZE
 from test_framework.test_framework import BitcoinTestFramework

@ -60,22 +60,22 @@ class P2PBloomFilter(P2PInterface):

    @property
    def tx_received(self):
-        with mininode_lock:
+        with p2p_lock:
            return self._tx_received

    @tx_received.setter
    def tx_received(self, value):
-        with mininode_lock:
+        with p2p_lock:
            self._tx_received = value

    @property
    def merkleblock_received(self):
-        with mininode_lock:
+        with p2p_lock:
            return self._merkleblock_received

    @merkleblock_received.setter
    def merkleblock_received(self, value):
-        with mininode_lock:
+        with p2p_lock:
            self._merkleblock_received = value


--- a/test/functional/p2p_fingerprint.py
+++ b/test/functional/p2p_fingerprint.py
@ -11,7 +11,7 @@ import time

 from test_framework.blocktools import (create_block, create_coinbase)
 from test_framework.messages import CInv, MSG_BLOCK
-from test_framework.mininode import (
+from test_framework.p2p import (
    P2PInterface,
    msg_headers,
    msg_block,
--- a/test/functional/p2p_getaddr_caching.py
+++ b/test/functional/p2p_getaddr_caching.py
@ -5,9 +5,9 @@
 """Test addr response caching"""

 from test_framework.messages import msg_getaddr
-from test_framework.mininode import (
+from test_framework.p2p import (
    P2PInterface,
-    mininode_lock
+    p2p_lock
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
@ -27,7 +27,7 @@ class AddrReceiver(P2PInterface):
        self.received_addrs = None

    def get_received_addrs(self):
-        with mininode_lock:
+        with p2p_lock:
            return self.received_addrs

    def on_addr(self, message):
--- a/test/functional/p2p_getdata.py
+++ b/test/functional/p2p_getdata.py
@ -9,7 +9,7 @@ from test_framework.messages import (
    CInv,
    msg_getdata,
 )
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework


--- a/test/functional/p2p_invalid_block.py
+++ b/test/functional/p2p_invalid_block.py
@ -14,7 +14,7 @@ import copy

 from test_framework.blocktools import create_block, create_coinbase, create_tx_with_script
 from test_framework.messages import COIN
-from test_framework.mininode import P2PDataStore
+from test_framework.p2p import P2PDataStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal

--- a/test/functional/p2p_invalid_locator.py
+++ b/test/functional/p2p_invalid_locator.py
@ -6,7 +6,7 @@
 """

 from test_framework.messages import msg_getheaders, msg_getblocks, MAX_LOCATOR_SZ
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework


--- a/test/functional/p2p_invalid_messages.py
+++ b/test/functional/p2p_invalid_messages.py
@ -15,7 +15,7 @@ from test_framework.messages import (
    msg_inv,
    MSG_TX,
 )
-from test_framework.mininode import (
+from test_framework.p2p import (
    P2PDataStore, P2PInterface
 )
 from test_framework.test_framework import BitcoinTestFramework
--- a/test/functional/p2p_invalid_tx.py
+++ b/test/functional/p2p_invalid_tx.py
@ -14,7 +14,7 @@ from test_framework.messages import (
    CTxIn,
    CTxOut,
 )
-from test_framework.mininode import P2PDataStore
+from test_framework.p2p import P2PDataStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
--- a/test/functional/p2p_leak.py
+++ b/test/functional/p2p_leak.py
@ -19,7 +19,7 @@ from test_framework.messages import (
    msg_verack,
    msg_version,
 )
-from test_framework.mininode import mininode_lock, P2PInterface
+from test_framework.p2p import p2p_lock, P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
@ -121,9 +121,9 @@ class P2PLeakTest(BitcoinTestFramework):
        # verack, since we never sent one
        no_verack_idlenode.wait_for_verack()

-        wait_until(lambda: no_version_bannode.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)
+        wait_until(lambda: no_version_bannode.ever_connected, timeout=10, lock=p2p_lock)
+        wait_until(lambda: no_version_idlenode.ever_connected, timeout=10, lock=p2p_lock)
+        wait_until(lambda: no_verack_idlenode.version_received, timeout=10, lock=p2p_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)
--- a/test/functional/p2p_leak_tx.py
+++ b/test/functional/p2p_leak_tx.py
@ -5,7 +5,7 @@
 """Test that we don't leak txs to inbound peers that we haven't yet announced to"""

 from test_framework.messages import msg_getdata, CInv, MSG_TX
-from test_framework.mininode import P2PDataStore
+from test_framework.p2p import P2PDataStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
    assert_equal,
--- a/test/functional/p2p_nobloomfilter_messages.py
+++ b/test/functional/p2p_nobloomfilter_messages.py
@ -12,7 +12,7 @@ Test that, when bloom filters are not enabled, peers are disconnected if:
 """

 from test_framework.messages import msg_mempool, msg_filteradd, msg_filterload, msg_filterclear
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal

--- a/test/functional/p2p_node_network_limited.py
+++ b/test/functional/p2p_node_network_limited.py
@ -9,7 +9,7 @@ and that it responds to getdata requests for blocks correctly:
    - send a block within 288 + 2 of the tip
    - disconnect peers who request blocks older than that."""
 from test_framework.messages import CInv, MSG_BLOCK, msg_getdata, NODE_BLOOM, NODE_NETWORK_LIMITED, NODE_HEADERS_COMPRESSED, msg_verack
-from test_framework.mininode import P2PInterface, mininode_lock
+from test_framework.p2p import P2PInterface, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, wait_until

@ -22,7 +22,7 @@ class P2PIgnoreInv(P2PInterface):
        self.firstAddrnServices = message.addrs[0].nServices
    def wait_for_addr(self, timeout=5):
        test_function = lambda: self.last_message.get("addr")
-        wait_until(test_function, timeout=timeout, lock=mininode_lock)
+        wait_until(test_function, timeout=timeout, lock=p2p_lock)
    def send_getdata_for_block(self, blockhash):
        getdata_request = msg_getdata()
        getdata_request.inv.append(CInv(MSG_BLOCK, int(blockhash, 16)))
--- a/test/functional/p2p_permissions.py
+++ b/test/functional/p2p_permissions.py
@ -12,7 +12,7 @@ from test_framework.messages import (
    CTransaction,
    FromHex,
 )
-from test_framework.mininode import P2PDataStore
+from test_framework.p2p import P2PDataStore
 from test_framework.script import (
    CScript,
    OP_TRUE,
@ -107,7 +107,7 @@ class P2PPermissionsTests(BitcoinTestFramework):
        self.sync_all()

        self.log.debug("Create a connection from a forcerelay peer that rebroadcasts raw txs")
-        # A python mininode is needed to send the raw transaction directly. If a full node was used, it could only
+        # A test framework p2p connection is needed to send the raw transaction directly. If a full node was used, it could only
        # rebroadcast via the inv-getdata mechanism. However, even for forcerelay connections, a full node would
        # currently not request a txid that is already in the mempool.
        self.restart_node(1, extra_args=["-whitelist=forcerelay@127.0.0.1"])
--- a/test/functional/p2p_quorum_data.py
+++ b/test/functional/p2p_quorum_data.py
@ -6,8 +6,8 @@
 import time

 from test_framework.messages import msg_qgetdata, msg_qwatch
-from test_framework.mininode import (
-    mininode_lock,
+from test_framework.p2p import (
+    p2p_lock,
    P2PInterface,
 )
 from test_framework.test_framework import DashTestFramework
@ -106,7 +106,7 @@ class QuorumDataInterface(P2PInterface):
            assert_qdata(self.get_qdata(), qgetdata, expected_error, len_vvec, len_contributions)

    def wait_for_qmessage(self, message=None, timeout=3, message_expected=True):
-        wait_until(lambda: self.message_count[message] > 0, timeout=timeout, lock=mininode_lock, do_assert=message_expected)
+        wait_until(lambda: self.message_count[message] > 0, timeout=timeout, lock=p2p_lock, do_assert=message_expected)
        if not message_expected:
            assert self.message_count[message] == 0
        self.message_count[message] = 0
--- a/test/functional/p2p_sendheaders.py
+++ b/test/functional/p2p_sendheaders.py
@ -87,10 +87,10 @@ e. Announce one more that doesn't connect.
 """
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.messages import CInv, NODE_HEADERS_COMPRESSED
-from test_framework.mininode import (
+from test_framework.p2p import (
    CBlockHeader,
    P2PInterface,
-    mininode_lock,
+    p2p_lock,
    MSG_BLOCK,
    msg_block,
    msg_getblocks,
@ -146,7 +146,7 @@ class BaseNode(P2PInterface):

    def wait_for_block_announcement(self, block_hash, timeout=60):
        test_function = lambda: self.last_blockhash_announced == block_hash
-        wait_until(test_function, timeout=timeout, lock=mininode_lock)
+        wait_until(test_function, timeout=timeout, lock=p2p_lock)

    def on_inv(self, message):
        self.block_announced = True
@ -162,7 +162,7 @@ class BaseNode(P2PInterface):
            self.last_blockhash_announced = message.headers[-1].sha256

    def clear_block_announcements(self):
-        with mininode_lock:
+        with p2p_lock:
            self.block_announced = False
            self.last_message.pop("inv", None)
            self.last_message.pop("headers", None)
@ -173,8 +173,8 @@ class BaseNode(P2PInterface):
        """Test whether the last headers announcements received are right.
           Headers may be announced across more than one message."""
        test_function = lambda: (len(self.recent_headers_announced) >= len(headers))
-        wait_until(test_function, timeout=60, lock=mininode_lock)
-        with mininode_lock:
+        wait_until(test_function, timeout=60, lock=p2p_lock)
+        with p2p_lock:
            assert_equal(self.recent_headers_announced, headers)
            self.block_announced = False
            self.last_message.pop("headers", None)
@ -185,9 +185,9 @@ class BaseNode(P2PInterface):
        inv should be a list of block hashes."""

        test_function = lambda: self.block_announced
-        wait_until(test_function, timeout=60, lock=mininode_lock)
+        wait_until(test_function, timeout=60, lock=p2p_lock)

-        with mininode_lock:
+        with p2p_lock:
            compare_inv = []
            if "inv" in self.last_message:
                compare_inv = [x.hash for x in self.last_message["inv"].inv]
@ -297,7 +297,7 @@ class SendHeadersTest(BitcoinTestFramework):
                test_node.send_header_for_blocks([new_block])
                test_node.wait_for_getdata([new_block.sha256])
                test_node.send_and_ping(msg_block(new_block))  # make sure this block is processed
-                wait_until(lambda: inv_node.block_announced, timeout=60, lock=mininode_lock)
+                wait_until(lambda: inv_node.block_announced, timeout=60, lock=p2p_lock)
                inv_node.clear_block_announcements()
                test_node.clear_block_announcements()

@ -455,7 +455,7 @@ class SendHeadersTest(BitcoinTestFramework):
        test_node.send_header_for_blocks(blocks)
        test_node.sync_with_ping()
        # should not have received any getdata messages
-        with mininode_lock:
+        with p2p_lock:
            assert "getdata" not in test_node.last_message

        # This time, direct fetch should work
@ -493,7 +493,7 @@ class SendHeadersTest(BitcoinTestFramework):
        test_node.last_message.pop("getdata", None)
        test_node.send_header_for_blocks(blocks[0:1])
        test_node.sync_with_ping()
-        with mininode_lock:
+        with p2p_lock:
            assert "getdata" not in test_node.last_message

        # Announcing one more block on fork should trigger direct fetch for
@ -512,7 +512,7 @@ class SendHeadersTest(BitcoinTestFramework):
        test_node.last_message.pop("getdata", None)
        test_node.send_header_for_blocks(blocks[18:19])
        test_node.sync_with_ping()
-        with mininode_lock:
+        with p2p_lock:
            assert "getdata" not in test_node.last_message

        self.log.info("Part 4: success!")
@ -535,7 +535,7 @@ class SendHeadersTest(BitcoinTestFramework):
                block_time += 1
                height += 1
            # Send the header of the second block -> this won't connect.
-            with mininode_lock:
+            with p2p_lock:
                test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None)
            test_node.send_header_for_blocks([blocks[1]])
            test_node.wait_for_getheaders()
@ -558,7 +558,7 @@ class SendHeadersTest(BitcoinTestFramework):

        for i in range(1, MAX_UNCONNECTING_HEADERS):
            # Send a header that doesn't connect, check that we get a getheaders.
-            with mininode_lock:
+            with p2p_lock:
                test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None)
            test_node.send_header_for_blocks([blocks[i]])
            test_node.wait_for_getheaders()
@ -573,7 +573,7 @@ class SendHeadersTest(BitcoinTestFramework):
        # before we get disconnected.  Should be 5*MAX_UNCONNECTING_HEADERS
        for i in range(5 * MAX_UNCONNECTING_HEADERS - 1):
            # Send a header that doesn't connect, check that we get a getheaders.
-            with mininode_lock:
+            with p2p_lock:
                test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None)
            test_node.send_header_for_blocks([blocks[i % len(blocks)]])
            test_node.wait_for_getheaders()
--- a/test/functional/p2p_sendheaders_compressed.py
+++ b/test/functional/p2p_sendheaders_compressed.py
@ -14,10 +14,10 @@ Setup:
 """
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.messages import CInv, NODE_HEADERS_COMPRESSED
-from test_framework.mininode import (
+from test_framework.p2p import (
    CompressibleBlockHeader,
    P2PInterface,
-    mininode_lock,
+    p2p_lock,
    msg_block,
    msg_getblocks,
    msg_getdata,
@ -77,11 +77,11 @@ class BaseNode(P2PInterface):
            return

        test_function = lambda: "getdata" in self.last_message and [inv.hash for inv in self.last_message["getdata"].inv] == hash_list
-        wait_until(test_function, timeout=timeout, lock=mininode_lock)
+        wait_until(test_function, timeout=timeout, lock=p2p_lock)

    def wait_for_block_announcement(self, block_hash, timeout=60):
        test_function = lambda: self.last_blockhash_announced == block_hash
-        wait_until(test_function, timeout=timeout, lock=mininode_lock)
+        wait_until(test_function, timeout=timeout, lock=p2p_lock)

    def on_inv(self, message):
        self.block_announced = True
@ -97,7 +97,7 @@ class BaseNode(P2PInterface):
            self.last_blockhash_announced = message.headers[-1].sha256

    def clear_block_announcements(self):
-        with mininode_lock:
+        with p2p_lock:
            self.block_announced = False
            self.last_message.pop("inv", None)
            self.last_message.pop("headers2", None)
@ -107,8 +107,8 @@ class BaseNode(P2PInterface):
        """Test whether the last headers announcements received are right.
           Headers may be announced across more than one message."""
        test_function = lambda: (len(self.recent_headers_announced) >= len(headers))
-        wait_until(test_function, timeout=60, lock=mininode_lock)
-        with mininode_lock:
+        wait_until(test_function, timeout=60, lock=p2p_lock)
+        with p2p_lock:
            assert_equal(self.recent_headers_announced, headers)
            self.block_announced = False
            self.last_message.pop("headers2", None)
@ -119,9 +119,9 @@ class BaseNode(P2PInterface):
        inv should be a list of block hashes."""

        test_function = lambda: self.block_announced
-        wait_until(test_function, timeout=60, lock=mininode_lock)
+        wait_until(test_function, timeout=60, lock=p2p_lock)

-        with mininode_lock:
+        with p2p_lock:
            compare_inv = []
            if "inv" in self.last_message:
                compare_inv = [inv.hash for inv in self.last_message["inv"].inv]
@ -304,7 +304,7 @@ class SendHeadersTest(BitcoinTestFramework):
                test_node.send_header_for_blocks([new_block])
                test_node.wait_for_getdata([new_block.sha256])
                test_node.send_and_ping(msg_block(new_block))  # make sure this block is processed
-                wait_until(lambda: inv_node.block_announced, timeout=60, lock=mininode_lock)
+                wait_until(lambda: inv_node.block_announced, timeout=60, lock=p2p_lock)
                inv_node.clear_block_announcements()
                test_node.clear_block_announcements()

@ -462,7 +462,7 @@ class SendHeadersTest(BitcoinTestFramework):
        test_node.send_header_for_blocks(blocks)
        test_node.sync_with_ping()
        # should not have received any getdata messages
-        with mininode_lock:
+        with p2p_lock:
            assert "getdata" not in test_node.last_message

        # This time, direct fetch should work
@ -500,7 +500,7 @@ class SendHeadersTest(BitcoinTestFramework):
        test_node.last_message.pop("getdata", None)
        test_node.send_header_for_blocks(blocks[0:1])
        test_node.sync_with_ping()
-        with mininode_lock:
+        with p2p_lock:
            assert "getdata" not in test_node.last_message

        # Announcing one more block on fork should trigger direct fetch for
@ -519,7 +519,7 @@ class SendHeadersTest(BitcoinTestFramework):
        test_node.last_message.pop("getdata", None)
        test_node.send_header_for_blocks(blocks[18:19])
        test_node.sync_with_ping()
-        with mininode_lock:
+        with p2p_lock:
            assert "getdata" not in test_node.last_message

        self.log.info("Part 4: success!")
@ -542,7 +542,7 @@ class SendHeadersTest(BitcoinTestFramework):
                block_time += 1
                height += 1
            # Send the header of the second block -> this won't connect.
-            with mininode_lock:
+            with p2p_lock:
                test_node.last_message.pop("getheaders2", None)
            test_node.send_header_for_blocks([blocks[1]])
            test_node.wait_for_getheaders()
@ -565,7 +565,7 @@ class SendHeadersTest(BitcoinTestFramework):

        for i in range(1, MAX_UNCONNECTING_HEADERS):
            # Send a header that doesn't connect, check that we get a getheaders.
-            with mininode_lock:
+            with p2p_lock:
                test_node.last_message.pop("getheaders2", None)
            test_node.send_header_for_blocks([blocks[i]])
            test_node.wait_for_getheaders()
@ -580,7 +580,7 @@ class SendHeadersTest(BitcoinTestFramework):
        # before we get disconnected.  Should be 5*MAX_UNCONNECTING_HEADERS
        for i in range(5 * MAX_UNCONNECTING_HEADERS - 1):
            # Send a header that doesn't connect, check that we get a getheaders.
-            with mininode_lock:
+            with p2p_lock:
                test_node.last_message.pop("getheaders2", None)
            test_node.send_header_for_blocks([blocks[i % len(blocks)]])
            test_node.wait_for_getheaders()
--- a/test/functional/p2p_timeouts.py
+++ b/test/functional/p2p_timeouts.py
@ -24,7 +24,7 @@
 from time import sleep

 from test_framework.messages import msg_ping
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework


--- a/test/functional/p2p_tx_download.py
+++ b/test/functional/p2p_tx_download.py
@ -15,9 +15,9 @@ from test_framework.messages import (
    msg_inv,
    msg_notfound,
 )
-from test_framework.mininode import (
+from test_framework.p2p import (
    P2PInterface,
-    mininode_lock,
+    p2p_lock,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
@ -68,7 +68,7 @@ class TxDownloadTest(BitcoinTestFramework):

        def getdata_found(peer_index):
            p = self.nodes[0].p2ps[peer_index]
-            with mininode_lock:
+            with p2p_lock:
                return p.last_message.get("getdata") and p.last_message["getdata"].inv[-1].hash == txid

        while outstanding_peer_index:
@ -127,7 +127,7 @@ class TxDownloadTest(BitcoinTestFramework):

        p = self.nodes[0].p2ps[0]

-        with mininode_lock:
+        with p2p_lock:
            p.tx_getdata_count = 0

        p.send_message(msg_inv([CInv(t=1, h=i) for i in txids]))
@ -136,15 +136,15 @@ class TxDownloadTest(BitcoinTestFramework):
            self.bump_mocktime(1)
            return p.tx_getdata_count >= target

-        wait_until(lambda: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT), lock=mininode_lock)
+        wait_until(lambda: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT), lock=p2p_lock)

-        with mininode_lock:
+        with p2p_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: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT + 1), timeout=10, lock=mininode_lock)
-        with mininode_lock:
+        wait_until(lambda: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT + 1), timeout=10, lock=p2p_lock)
+        with p2p_lock:
            assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT + 1)

        WAIT_TIME = TX_EXPIRY_INTERVAL // 2 + TX_EXPIRY_INTERVAL
--- a/test/functional/p2p_unrequested_blocks.py
+++ b/test/functional/p2p_unrequested_blocks.py
@ -54,7 +54,7 @@ Node1 is unused in tests 3-7:

 from test_framework.blocktools import create_block, create_coinbase, create_tx_with_script
 from test_framework.messages import CBlockHeader, CInv, MSG_BLOCK, msg_block, msg_headers, msg_inv
-from test_framework.mininode import mininode_lock, P2PInterface
+from test_framework.p2p import p2p_lock, P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error

@ -194,13 +194,13 @@ class AcceptBlockTest(BitcoinTestFramework):
        # 6. Try to get node to request the missing block.
        # Poke the node with an inv for block at height 3 and see if that
        # triggers a getdata on block 2 (it should if block 2 is missing).
-        with mininode_lock:
+        with p2p_lock:
            # Clear state so we can check the getdata request
            test_node.last_message.pop("getdata", None)
            test_node.send_message(msg_inv([CInv(MSG_BLOCK, block_h3.sha256)]))

        test_node.sync_with_ping()
-        with mininode_lock:
+        with p2p_lock:
            getdata = test_node.last_message["getdata"]

        # Check that the getdata includes the right block
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@ -22,17 +22,6 @@ from decimal import Decimal
 import http.client
 import subprocess

-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (
-    assert_equal,
-    assert_greater_than,
-    assert_greater_than_or_equal,
-    assert_raises,
-    assert_raises_rpc_error,
-    assert_is_hex_string,
-    assert_is_hash_string,
-    set_node_times,
-)
 from test_framework.blocktools import (
    create_block,
    create_coinbase,
@ -43,8 +32,17 @@ from test_framework.messages import (
    FromHex,
    msg_block,
 )
-from test_framework.mininode import (
-    P2PInterface,
+from test_framework.p2p import P2PInterface
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_greater_than_or_equal,
+    assert_raises,
+    assert_raises_rpc_error,
+    assert_is_hex_string,
+    assert_is_hash_string,
+    set_node_times,
 )


--- a/test/functional/rpc_mnauth.py
+++ b/test/functional/rpc_mnauth.py
@ -4,7 +4,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.

 from test_framework.messages import hash256
-from test_framework.mininode import P2PInterface
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes

--- a/test/functional/rpc_net.py
+++ b/test/functional/rpc_net.py
@ -7,6 +7,11 @@
 Tests correspond to code in rpc/net.cpp.
 """

+from test_framework.p2p import P2PInterface
+import test_framework.messages
+from test_framework.messages import (
+    NODE_NETWORK,
+)
 from test_framework.test_framework import DashTestFramework
 from test_framework.util import (
    assert_equal,
@ -16,11 +21,6 @@ from test_framework.util import (
    p2p_port,
    wait_until,
 )
-from test_framework.mininode import P2PInterface
-import test_framework.messages
-from test_framework.messages import (
-    NODE_NETWORK,
-)


 def assert_net_servicesnames(servicesflag, servicenames):
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@ -33,7 +33,7 @@ import dash_hash

 MIN_VERSION_SUPPORTED = 60001
 MY_VERSION = 70230  # MNLISTDIFF_CHAINLOCKS_PROTO_VERSION
-MY_SUBVERSION = b"/python-mininode-tester:0.0.3%s/"
+MY_SUBVERSION = b"/python-p2p-tester:0.0.3%s/"
 MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37)

 MAX_LOCATOR_SZ = 101
--- a/test/functional/test_framework/mininode.py
+++ b/test/functional/test_framework/mininode.py
@ -4,10 +4,14 @@
 # Copyright (c) 2010-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.
-"""Dash P2P network half-a-node.
+"""Test objects for interacting with a dashd node over the p2p protocol.

-This python code was modified from ArtForz' public domain half-a-node, as
-found in the mini-node branch of http://github.com/jgarzik/pynode.
+The P2PInterface objects interact with the dashd nodes under test using the
+node's p2p interface. They can be used to send messages to the node, and
+callbacks can be registered that execute when messages are received from the
+node. Messages are sent to/received from the node on an asyncio event loop.
+State held inside the objects must be guarded by the p2p_lock to avoid data
+races between the main testing thread and the event loop.

 P2PConnection: A low-level connection object to a node's P2P interface
 P2PInterface: A high-level interface object for communicating to a node over P2P
@ -79,7 +83,7 @@ from test_framework.messages import (
 )
 from test_framework.util import wait_until

-logger = logging.getLogger("TestFramework.mininode")
+logger = logging.getLogger("TestFramework.p2p")

 MESSAGEMAP = {
    b"addr": msg_addr,
@ -321,7 +325,7 @@ class P2PConnection(asyncio.Protocol):


 class P2PInterface(P2PConnection):
-    """A high-level P2P interface class for communicating with a Bitcoin node.
+    """A high-level P2P interface class for communicating with a Dash node.

    This class provides high-level callbacks for processing P2P message
    payloads, as well as convenience methods for interacting with the
@ -372,7 +376,7 @@ class P2PInterface(P2PConnection):

        We keep a count of how many of each message type has been received
        and the most recent message of each type."""
-        with mininode_lock:
+        with p2p_lock:
            try:
                msgtype = message.msgtype.decode('ascii')
                self.message_count[msgtype] += 1
@ -453,7 +457,7 @@ class P2PInterface(P2PConnection):
    # Connection helper methods

    def wait_until(self, test_function, timeout=60):
-        wait_until(test_function, timeout=timeout, lock=mininode_lock, timeout_factor=self.timeout_factor)
+        wait_until(test_function, timeout=timeout, lock=p2p_lock, timeout_factor=self.timeout_factor)

    def wait_for_disconnect(self, timeout=60):
        test_function = lambda: not self.is_connected
@ -495,7 +499,7 @@ class P2PInterface(P2PConnection):
                return False
            return last_filtered_block.merkleblock.header.rehash() == int(blockhash, 16)

-        wait_until(test_function, timeout=timeout, lock=mininode_lock)
+        wait_until(test_function, timeout=timeout, lock=p2p_lock)


    def wait_for_getdata(self, hash_list, timeout=60):
@ -569,7 +573,7 @@ class P2PInterface(P2PConnection):
 # P2PConnection acquires this lock whenever delivering a message to a P2PInterface.
 # This lock should be acquired in the thread running the test logic to synchronize
 # access to any data shared with the P2PInterface or P2PConnection.
-mininode_lock = threading.Lock()
+p2p_lock = threading.Lock()


 class NetworkThread(threading.Thread):
@ -677,7 +681,7 @@ class P2PDataStore(P2PInterface):
         - if success is False: assert that the node's tip doesn't advance
         - if reject_reason is set: assert that the correct reject message is logged"""

-        with mininode_lock:
+        with p2p_lock:
            for block in blocks:
                self.block_store[block.sha256] = block
                self.last_block_hash = block.sha256
@ -710,7 +714,7 @@ class P2PDataStore(P2PInterface):
         - if expect_disconnect is True: Skip the sync with ping
         - if reject_reason is set: assert that the correct reject message is logged."""

-        with mininode_lock:
+        with p2p_lock:
            for tx in txs:
                self.tx_store[tx.sha256] = tx

@ -749,7 +753,7 @@ class P2PTxInvStore(P2PInterface):
                self.tx_invs_received[i.hash] += 1

    def get_invs(self):
-        with mininode_lock:
+        with p2p_lock:
            return list(self.tx_invs_received.keys())

    def wait_for_broadcast(self, txns, timeout=60):
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@ -35,8 +35,8 @@ from .messages import (
    ser_string,
 )
 from .script import hash160
+from .p2p import NetworkThread
 from .test_node import TestNode
-from .mininode import NetworkThread
 from .util import (
    PortSeed,
    MAX_NODES,
--- a/test/functional/test_framework/test_node.py
+++ b/test/functional/test_framework/test_node.py
@ -572,7 +572,7 @@ class TestNode():
        assert self.p2ps, self._node_msg("No p2p connection")
        return self.p2ps[0]

-    def num_connected_mininodes(self):
+    def num_test_p2p_connections(self):
        """Return number of test framework p2p connections to the node."""
        return len([peer for peer in self.getpeerinfo() if peer['subver'] == MY_SUBVERSION.decode("utf-8")])

@ -591,7 +591,7 @@ class TestNode():
        wait_until(check_peers, timeout=5)

        del self.p2ps[:]
-        wait_until(lambda: self.num_connected_mininodes() == 0)
+        wait_until(lambda: self.num_test_p2p_connections() == 0)


 class TestNodeCLIAttr:
--- a/test/functional/wallet_resendwallettransactions.py
+++ b/test/functional/wallet_resendwallettransactions.py
@ -7,7 +7,7 @@ import time

 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.messages import ToHex
-from test_framework.mininode import P2PTxInvStore, mininode_lock
+from test_framework.p2p import P2PTxInvStore, p2p_lock
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, wait_until

@ -36,7 +36,7 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):
        def wait_p2p():
            self.bump_mocktime(1)
            return node.p2p.tx_invs_received[txid] >= 1
-        wait_until(wait_p2p, lock=mininode_lock)
+        wait_until(wait_p2p, lock=p2p_lock)

        # Add a second peer since txs aren't rebroadcast to the same peer (see filterInventoryKnown)
        node.add_p2p_connection(P2PTxInvStore())
@ -74,7 +74,7 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):
        def wait_p2p_1():
            self.bump_mocktime(1)
            return node.p2ps[1].tx_invs_received[txid] >= 1
-        wait_until(wait_p2p_1, lock=mininode_lock)
+        wait_until(wait_p2p_1, lock=p2p_lock)


 if __name__ == '__main__':