diff --git a/doc/functional-tests.md b/doc/functional-tests.md
--- a/doc/functional-tests.md
+++ b/doc/functional-tests.md
@@ -225,12 +225,12 @@
 with the bitcoind(s) being tested (using python's asyncore package); the other
 implements the test logic.
 
-- `NodeConn` is the class used to connect to a bitcoind.  If you implement
-a callback class that derives from `NodeConnCB` and pass that to the
-`NodeConn` object, your code will receive the appropriate callbacks when
-events of interest arrive.
+- `P2PConnection` is the class used to connect to a bitcoind.  `P2PInterface`
+contains the higher level logic for processing P2P payloads and connecting to
+the Bitcoin Core node application logic. For custom behaviour, subclass the
+P2PInterface object and override the callback methods.
 
-- Call `NetworkThread.start()` after all `NodeConn` objects are created to
+- Call `NetworkThread.start()` after all `P2PInterface` objects are created to
 start the networking thread.  (Continue with the test logic in your existing
 thread.)
 
diff --git a/test/functional/abc-p2p-compactblocks.py b/test/functional/abc-p2p-compactblocks.py
--- a/test/functional/abc-p2p-compactblocks.py
+++ b/test/functional/abc-p2p-compactblocks.py
@@ -30,7 +30,7 @@
 
 
 # TestNode: A peer we use to send messages to bitcoind, and store responses.
-class TestNode(NodeConnCB):
+class TestNode(P2PInterface):
 
     def __init__(self):
         self.last_sendcmpct = None
diff --git a/test/functional/abc-sync-chain.py b/test/functional/abc-sync-chain.py
--- a/test/functional/abc-sync-chain.py
+++ b/test/functional/abc-sync-chain.py
@@ -14,8 +14,7 @@
 from test_framework.blocktools import create_block, create_coinbase
 from test_framework.mininode import (CBlockHeader,
                                      NetworkThread,
-                                     NodeConn,
-                                     NodeConnCB,
+                                     P2PInterface,
                                      msg_block,
                                      msg_headers)
 from test_framework.test_framework import BitcoinTestFramework
@@ -25,7 +24,7 @@
 NUM_IBD_BLOCKS = 50
 
 
-class BaseNode(NodeConnCB):
+class BaseNode(P2PInterface):
     def send_header(self, block):
         msg = msg_headers()
         msg.headers = [CBlockHeader(block)]
diff --git a/test/functional/assumevalid.py b/test/functional/assumevalid.py
--- a/test/functional/assumevalid.py
+++ b/test/functional/assumevalid.py
@@ -39,7 +39,7 @@
                                      CTxIn,
                                      CTxOut,
                                      NetworkThread,
-                                     NodeConnCB,
+                                     P2PInterface,
                                      msg_block,
                                      msg_headers)
 from test_framework.script import (CScript, OP_TRUE)
@@ -47,7 +47,7 @@
 from test_framework.util import assert_equal
 
 
-class BaseNode(NodeConnCB):
+class BaseNode(P2PInterface):
     def send_header_for_blocks(self, new_blocks):
         headers_message = msg_headers()
         headers_message.headers = [CBlockHeader(b) for b in new_blocks]
diff --git a/test/functional/bip65-cltv-p2p.py b/test/functional/bip65-cltv-p2p.py
--- a/test/functional/bip65-cltv-p2p.py
+++ b/test/functional/bip65-cltv-p2p.py
@@ -71,7 +71,7 @@
         self.setup_clean_chain = True
 
     def run_test(self):
-        self.nodes[0].add_p2p_connection(NodeConnCB())
+        self.nodes[0].add_p2p_connection(P2PInterface())
 
         # Start up network handling in another thread
         NetworkThread().start()
diff --git a/test/functional/bipdersig-p2p.py b/test/functional/bipdersig-p2p.py
--- a/test/functional/bipdersig-p2p.py
+++ b/test/functional/bipdersig-p2p.py
@@ -59,7 +59,7 @@
         self.setup_clean_chain = True
 
     def run_test(self):
-        self.nodes[0].add_p2p_connection(NodeConnCB())
+        self.nodes[0].add_p2p_connection(P2PInterface())
 
         # Start up network handling in another thread
         NetworkThread().start()
diff --git a/test/functional/example_test.py b/test/functional/example_test.py
--- a/test/functional/example_test.py
+++ b/test/functional/example_test.py
@@ -18,7 +18,7 @@
 from test_framework.mininode import (
     CInv,
     NetworkThread,
-    NodeConnCB,
+    P2PInterface,
     mininode_lock,
     msg_block,
     msg_getdata,
@@ -30,17 +30,17 @@
     wait_until,
 )
 
-# NodeConnCB is a class containing callbacks to be executed when a P2P
-# message is received from the node-under-test. Subclass NodeConnCB and
+# P2PInterface is a class containing callbacks to be executed when a P2P
+# message is received from the node-under-test. Subclass P2PInterface and
 # override the on_*() methods if you need custom behaviour.
 
 
-class BaseNode(NodeConnCB):
+class BaseNode(P2PInterface):
     def __init__(self):
-        """Initialize the NodeConnCB
+        """Initialize the P2PInterface
 
         Used to inialize custom properties for the Node that aren't
-        included by default in the base class. Be aware that the NodeConnCB
+        included by default in the base class. Be aware that the P2PInterface
         base class already stores a counter for each P2P message type and the
         last received message of each type, which should be sufficient for the
         needs of most tests.
@@ -180,7 +180,7 @@
                 self.tip, create_coinbase(height), self.block_time)
             block.solve()
             block_message = msg_block(block)
-            # Send message is used to send a P2P message to the node over our NodeConn connection
+            # Send message is used to send a P2P message to the node over our P2PInterface
             self.nodes[0].p2p.send_message(block_message)
             self.tip = block.sha256
             blocks.append(self.tip)
@@ -207,13 +207,13 @@
         self.nodes[2].p2p.send_message(getdata_request)
 
         # wait_until() will loop until a predicate condition is met. Use it to test properties of the
-        # NodeConnCB objects.
+        # P2PInterface objects.
         wait_until(lambda: sorted(blocks) == sorted(
             list(self.nodes[2].p2p.block_receive_map.keys())), timeout=5, lock=mininode_lock)
 
         self.log.info("Check that each block was received only once")
-        # The network thread uses a global lock on data access to the NodeConn objects when sending and receiving
-        # messages. The test thread should acquire the global lock before accessing any NodeConn data to avoid locking
+        # 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:
             for block in self.nodes[2].p2p.block_receive_map.values():
diff --git a/test/functional/maxuploadtarget.py b/test/functional/maxuploadtarget.py
--- a/test/functional/maxuploadtarget.py
+++ b/test/functional/maxuploadtarget.py
@@ -22,8 +22,7 @@
 from test_framework.blocktools import mine_big_block
 
 
-class TestNode(NodeConnCB):
-
+class TestNode(P2PInterface):
     def __init__(self):
         super().__init__()
         self.block_receive_map = defaultdict(int)
diff --git a/test/functional/p2p-acceptblock.py b/test/functional/p2p-acceptblock.py
--- a/test/functional/p2p-acceptblock.py
+++ b/test/functional/p2p-acceptblock.py
@@ -15,7 +15,7 @@
 Setup: two nodes, node0+node1, not connected to each other. Node1 will have
 nMinimumChainWork set to 0x10, so it won't process low-work unrequested blocks.
 
-We have one NodeConn connection to node0 called test_node, and one to node1
+We have one P2PInterface connection to node0 called test_node, and one to node1
 called min_work_node.
 
 The test:
@@ -84,9 +84,9 @@
     def run_test(self):
         # Setup the p2p connections and start up the network thread.
         # test_node connects to node0 (not whitelisted)
-        test_node = self.nodes[0].add_p2p_connection(NodeConnCB())
-        # min_work_node connects to node1
-        min_work_node = self.nodes[1].add_p2p_connection(NodeConnCB())
+        test_node = self.nodes[0].add_p2p_connection(P2PInterface())
+        # min_work_node connects to node1 (whitelisted)
+        min_work_node = self.nodes[1].add_p2p_connection(P2PInterface())
 
         # Start up network handling in another thread
         NetworkThread().start()
@@ -223,7 +223,7 @@
         # The node should have requested the blocks at some point, so
         # disconnect/reconnect first
         self.nodes[0].disconnect_p2ps()
-        test_node = self.nodes[0].add_p2p_connection(NodeConnCB())
+        test_node = self.nodes[0].add_p2p_connection(P2PInterface())
 
         test_node.wait_for_verack()
         test_node.send_message(msg_block(block_h1f))
@@ -317,7 +317,7 @@
             test_node.wait_for_disconnect()
 
             self.nodes[0].disconnect_p2ps()
-            test_node = self.nodes[0].add_p2p_connection(NodeConnCB())
+            test_node = self.nodes[0].add_p2p_connection(P2PInterface())
 
             NetworkThread().start()  # Start up network handling in another thread
             test_node.wait_for_verack()
diff --git a/test/functional/p2p-compactblocks.py b/test/functional/p2p-compactblocks.py
--- a/test/functional/p2p-compactblocks.py
+++ b/test/functional/p2p-compactblocks.py
@@ -20,7 +20,7 @@
 # TestNode: A peer we use to send messages to bitcoind, and store responses.
 
 
-class TestNode(NodeConnCB):
+class TestNode(P2PInterface):
     def __init__(self):
         super().__init__()
         self.last_sendcmpct = []
diff --git a/test/functional/p2p-feefilter.py b/test/functional/p2p-feefilter.py
--- a/test/functional/p2p-feefilter.py
+++ b/test/functional/p2p-feefilter.py
@@ -29,7 +29,7 @@
     return False
 
 
-class TestNode(NodeConnCB):
+class TestNode(P2PInterface):
     def __init__(self):
         super().__init__()
         self.txinvs = []
diff --git a/test/functional/p2p-fingerprint.py b/test/functional/p2p-fingerprint.py
--- a/test/functional/p2p-fingerprint.py
+++ b/test/functional/p2p-fingerprint.py
@@ -14,7 +14,7 @@
 from test_framework.mininode import (
     CInv,
     NetworkThread,
-    NodeConnCB,
+    P2PInterface,
     msg_headers,
     msg_block,
     msg_getdata,
@@ -78,7 +78,7 @@
     # This does not currently test that stale blocks timestamped within the
     # last month but that have over a month's worth of work are also withheld.
     def run_test(self):
-        node0 = self.nodes[0].add_p2p_connection(NodeConnCB())
+        node0 = self.nodes[0].add_p2p_connection(P2PInterface())
 
         NetworkThread().start()
         node0.wait_for_verack()
diff --git a/test/functional/p2p-leaktests.py b/test/functional/p2p-leaktests.py
--- a/test/functional/p2p-leaktests.py
+++ b/test/functional/p2p-leaktests.py
@@ -17,7 +17,7 @@
 banscore = 10
 
 
-class CLazyNode(NodeConnCB):
+class CLazyNode(P2PInterface):
     def __init__(self):
         super().__init__()
         self.unexpected_msg = False
diff --git a/test/functional/p2p-mempool.py b/test/functional/p2p-mempool.py
--- a/test/functional/p2p-mempool.py
+++ b/test/functional/p2p-mempool.py
@@ -16,7 +16,7 @@
 
     def run_test(self):
         # Add a p2p connection
-        self.nodes[0].add_p2p_connection(NodeConnCB())
+        self.nodes[0].add_p2p_connection(P2PInterface())
         NetworkThread().start()
         self.nodes[0].p2p.wait_for_verack()
 
diff --git a/test/functional/p2p-timeouts.py b/test/functional/p2p-timeouts.py
--- a/test/functional/p2p-timeouts.py
+++ b/test/functional/p2p-timeouts.py
@@ -28,7 +28,7 @@
 from test_framework.util import *
 
 
-class TestNode(NodeConnCB):
+class TestNode(P2PInterface):
     def on_version(self, message):
         # Don't send a verack in response
         pass
diff --git a/test/functional/sendheaders.py b/test/functional/sendheaders.py
--- a/test/functional/sendheaders.py
+++ b/test/functional/sendheaders.py
@@ -93,7 +93,7 @@
 direct_fetch_response_time = 0.05
 
 
-class TestNode(NodeConnCB):
+class TestNode(P2PInterface):
     def __init__(self):
         super().__init__()
         self.block_announced = False
diff --git a/test/functional/test_framework/comptool.py b/test/functional/test_framework/comptool.py
--- a/test/functional/test_framework/comptool.py
+++ b/test/functional/test_framework/comptool.py
@@ -44,7 +44,7 @@
         return '%i:%s' % (self.code, self.reason or '*')
 
 
-class TestNode(NodeConnCB):
+class TestNode(P2PInterface):
 
     def __init__(self, block_store, tx_store):
         super().__init__()
diff --git a/test/functional/test_framework/mininode.py b/test/functional/test_framework/mininode.py
--- a/test/functional/test_framework/mininode.py
+++ b/test/functional/test_framework/mininode.py
@@ -9,10 +9,8 @@
 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.
 
-NodeConn: an object which manages p2p connectivity to a bitcoin node
-NodeConnCB: a base class that describes the interface for receiving
-            callbacks with network messages from a NodeConn
-"""
+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"""
 import asyncore
 from collections import defaultdict
 from io import BytesIO
@@ -58,7 +56,7 @@
 }
 
 
-class NodeConn(asyncore.dispatcher):
+class P2PConnection(asyncore.dispatcher):
     """A low-level connection object to a node's P2P interface.
 
     This class is responsible for:
@@ -69,9 +67,7 @@
     - logging messages as they are sent and received
 
     This class contains no logic for handing the P2P message payloads. It must be
-    sub-classed and the on_message() callback overridden.
-
-    TODO: rename this class P2PConnection."""
+    sub-classed and the on_message() callback overridden."""
 
     def __init__(self):
         super().__init__(map=mininode_socket_map)
@@ -255,7 +251,7 @@
         logger.debug(log_message)
 
 
-class NodeConnCB(NodeConn):
+class P2PInterface(P2PConnection):
     """A high-level P2P interface class for communicating with a Bitcoin Cash node.
 
     This class provides high-level callbacks for processing P2P message
@@ -263,9 +259,7 @@
     node over P2P.
 
     Individual testcases should subclass this and override the on_* methods
-    if they want to alter message handling behaviour.
-
-    TODO: rename this class P2PInterface"""
+    if they want to alter message handling behaviour."""
 
     def __init__(self):
         super().__init__()
@@ -436,10 +430,10 @@
 
 # One lock for synchronizing all data access between the networking thread (see
 # NetworkThread below) and the thread running the test logic.  For simplicity,
-# NodeConn acquires this lock whenever delivering a message to a NodeConnCB,
+# P2PConnection acquires this lock whenever delivering a message to a P2PInterface,
 # and whenever adding anything to the send buffer (in send_message()).  This
 # lock should be acquired in the thread running the test logic to synchronize
-# access to any data shared with the NodeConnCB or NodeConn.
+# access to any data shared with the P2PInterface or P2PConnection.
 mininode_lock = RLock()