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
@@ -134,7 +134,7 @@
 
         # Create P2P connections will wait for a verack to make sure the
         # connection is fully up
-        self.nodes[0].add_p2p_connection(BaseNode())
+        peer_messaging = self.nodes[0].add_p2p_connection(BaseNode())
 
         # Generating a block on one of the nodes will get us out of IBD
         blocks = [int(self.nodes[0].generate(nblocks=1)[0], 16)]
@@ -175,7 +175,7 @@
             block_message = msg_block(block)
             # Send message is used to send a P2P message to the node over our
             # P2PInterface
-            self.nodes[0].p2p.send_message(block_message)
+            peer_messaging.send_message(block_message)
             self.tip = block.sha256
             blocks.append(self.tip)
             self.block_time += 1
@@ -194,20 +194,20 @@
         self.log.info("Add P2P connection to node2")
         self.nodes[0].disconnect_p2ps()
 
-        self.nodes[2].add_p2p_connection(BaseNode())
+        peer_receiving = self.nodes[2].add_p2p_connection(BaseNode())
 
         self.log.info("Test that node2 propagates all the blocks to us")
 
         getdata_request = msg_getdata()
         for block in blocks:
             getdata_request.inv.append(CInv(MSG_BLOCK, block))
-        self.nodes[2].p2p.send_message(getdata_request)
+        peer_receiving.send_message(getdata_request)
 
         # wait_until() will loop until a predicate condition is met. Use it to test properties of the
         # P2PInterface objects.
-        self.nodes[2].p2p.wait_until(
+        peer_receiving.wait_until(
             lambda: sorted(blocks) == sorted(list(
-                self.nodes[2].p2p.block_receive_map.keys())),
+                peer_receiving.block_receive_map.keys())),
             timeout=5)
 
         self.log.info("Check that each block was received only once")
@@ -216,7 +216,7 @@
         # and synchronization issues. Note p2p.wait_until() acquires this
         # global lock internally when testing the predicate.
         with p2p_lock:
-            for block in self.nodes[2].p2p.block_receive_map.values():
+            for block in peer_receiving.block_receive_map.values():
                 assert_equal(block, 1)
 
 
diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -1270,14 +1270,14 @@
         """Add a P2P connection to the node.
 
         Helper to connect and wait for version handshake."""
-        self.nodes[0].add_p2p_connection(P2PDataStore())
+        self.helper_peer = self.nodes[0].add_p2p_connection(P2PDataStore())
         # We need to wait for the initial getheaders from the peer before we
         # start populating our blockstore. If we don't, then we may run ahead
         # to the next subtest before we receive the getheaders. We'd then send
         # an INV for the next block and receive two getheaders - one for the
         # IBD and one for the INV. We'd respond to both and could get
         # unexpectedly disconnected if the DoS score for that error is 50.
-        self.nodes[0].p2p.wait_for_getheaders(timeout=timeout)
+        self.helper_peer.wait_for_getheaders(timeout=timeout)
 
     def reconnect_p2p(self, timeout=60):
         """Tear down and bootstrap the P2P connection to the node.
@@ -1292,8 +1292,8 @@
         """Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
 
         Call with success = False if the tip shouldn't advance to the most recent block."""
-        self.nodes[0].p2p.send_blocks_and_test(blocks, self.nodes[0], success=success,
-                                               reject_reason=reject_reason, force_send=force_send, timeout=timeout, expect_disconnect=reconnect)
+        self.helper_peer.send_blocks_and_test(blocks, self.nodes[0], success=success,
+                                              reject_reason=reject_reason, force_send=force_send, timeout=timeout, expect_disconnect=reconnect)
 
         if reconnect:
             self.reconnect_p2p(timeout=timeout)
diff --git a/test/functional/feature_cltv.py b/test/functional/feature_cltv.py
--- a/test/functional/feature_cltv.py
+++ b/test/functional/feature_cltv.py
@@ -94,7 +94,7 @@
         self.skip_if_no_wallet()
 
     def run_test(self):
-        self.nodes[0].add_p2p_connection(P2PInterface())
+        peer = self.nodes[0].add_p2p_connection(P2PInterface())
 
         self.log.info("Mining {} blocks".format(CLTV_HEIGHT - 2))
         self.coinbase_txids = [self.nodes[0].getblock(
@@ -121,7 +121,7 @@
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        self.nodes[0].p2p.send_and_ping(msg_block(block))
+        peer.send_and_ping(msg_block(block))
         # This block is valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
@@ -133,9 +133,9 @@
         block.solve()
 
         with self.nodes[0].assert_debug_log(expected_msgs=['{}, bad-version(0x00000003)'.format(block.hash)]):
-            self.nodes[0].p2p.send_and_ping(msg_block(block))
+            peer.send_and_ping(msg_block(block))
             assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
-            self.nodes[0].p2p.sync_with_ping()
+            peer.sync_with_ping()
 
         self.log.info(
             "Test that invalid-according-to-cltv transactions cannot appear in a block")
@@ -148,7 +148,7 @@
 
         # The funding tx only has unexecuted bad CLTV, in scriptpubkey; this is
         # valid.
-        self.nodes[0].p2p.send_and_ping(msg_tx(fundtx))
+        peer.send_and_ping(msg_tx(fundtx))
         assert fundtx.hash in self.nodes[0].getrawmempool()
 
         # Mine a block containing the funding transaction
@@ -156,7 +156,7 @@
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        self.nodes[0].p2p.send_and_ping(msg_block(block))
+        peer.send_and_ping(msg_block(block))
         # This block is valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
@@ -185,9 +185,9 @@
         block.solve()
 
         with self.nodes[0].assert_debug_log(expected_msgs=['ConnectBlock {} failed, blk-bad-inputs'.format(block.hash)]):
-            self.nodes[0].p2p.send_and_ping(msg_block(block))
+            peer.send_and_ping(msg_block(block))
             assert_equal(self.nodes[0].getbestblockhash(), tip)
-            self.nodes[0].p2p.sync_with_ping()
+            peer.sync_with_ping()
 
         self.log.info(
             "Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
@@ -212,7 +212,7 @@
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        self.nodes[0].p2p.send_and_ping(msg_block(block))
+        peer.send_and_ping(msg_block(block))
         # This block is now valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
diff --git a/test/functional/feature_csv_activation.py b/test/functional/feature_csv_activation.py
--- a/test/functional/feature_csv_activation.py
+++ b/test/functional/feature_csv_activation.py
@@ -225,11 +225,11 @@
         """Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
 
         Call with success = False if the tip shouldn't advance to the most recent block."""
-        self.nodes[0].p2p.send_blocks_and_test(
+        self.helper_peer.send_blocks_and_test(
             blocks, self.nodes[0], success=success)
 
     def run_test(self):
-        self.nodes[0].add_p2p_connection(P2PDataStore())
+        self.helper_peer = self.nodes[0].add_p2p_connection(P2PDataStore())
 
         self.log.info("Generate blocks in the past for coinbase outputs.")
         # Enough to build up to 1000 blocks 10 minutes apart without worrying
diff --git a/test/functional/feature_dersig.py b/test/functional/feature_dersig.py
--- a/test/functional/feature_dersig.py
+++ b/test/functional/feature_dersig.py
@@ -50,7 +50,7 @@
         self.skip_if_no_wallet()
 
     def run_test(self):
-        self.nodes[0].add_p2p_connection(P2PInterface())
+        peer = self.nodes[0].add_p2p_connection(P2PInterface())
 
         self.log.info("Mining {} blocks".format(DERSIG_HEIGHT - 1))
         self.coinbase_txids = [self.nodes[0].getblock(
@@ -67,9 +67,9 @@
         block.solve()
 
         with self.nodes[0].assert_debug_log(expected_msgs=['{}, bad-version(0x00000002)'.format(block.hash)]):
-            self.nodes[0].p2p.send_and_ping(msg_block(block))
+            peer.send_and_ping(msg_block(block))
             assert_equal(self.nodes[0].getbestblockhash(), tip)
-            self.nodes[0].p2p.sync_with_ping()
+            peer.sync_with_ping()
 
         self.log.info(
             "Test that transactions with non-DER signatures cannot appear in a block")
@@ -96,9 +96,9 @@
         block.solve()
 
         with self.nodes[0].assert_debug_log(expected_msgs=['ConnectBlock {} failed, blk-bad-inputs'.format(block.hash)]):
-            self.nodes[0].p2p.send_and_ping(msg_block(block))
+            peer.send_and_ping(msg_block(block))
             assert_equal(self.nodes[0].getbestblockhash(), tip)
-            self.nodes[0].p2p.sync_with_ping()
+            peer.sync_with_ping()
 
         self.log.info(
             "Test that a version 3 block with a DERSIG-compliant transaction is accepted")
@@ -108,7 +108,7 @@
         block.rehash()
         block.solve()
 
-        self.nodes[0].p2p.send_and_ping(msg_block(block))
+        peer.send_and_ping(msg_block(block))
         assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)
 
 
diff --git a/test/functional/feature_maxuploadtarget.py b/test/functional/feature_maxuploadtarget.py
--- a/test/functional/feature_maxuploadtarget.py
+++ b/test/functional/feature_maxuploadtarget.py
@@ -156,17 +156,17 @@
                               "-maxuploadtarget=1", "-blockmaxsize=999000"])
 
         # Reconnect to self.nodes[0]
-        self.nodes[0].add_p2p_connection(TestP2PConn())
+        peer = self.nodes[0].add_p2p_connection(TestP2PConn())
 
         # retrieve 20 blocks which should be enough to break the 1MB limit
         getdata_request.inv = [CInv(MSG_BLOCK, big_new_block)]
         for i in range(20):
-            self.nodes[0].p2p.send_and_ping(getdata_request)
+            peer.send_and_ping(getdata_request)
             assert_equal(
-                self.nodes[0].p2p.block_receive_map[big_new_block], i + 1)
+                peer.block_receive_map[big_new_block], i + 1)
 
         getdata_request.inv = [CInv(MSG_BLOCK, big_old_block)]
-        self.nodes[0].p2p.send_and_ping(getdata_request)
+        peer.send_and_ping(getdata_request)
 
         self.log.info(
             "Peer still connected after trying to download old block (download permission)")
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -54,7 +54,7 @@
     def run_test(self):
         # Mine some blocks and have them mature.
         # keep track of invs
-        self.nodes[0].add_p2p_connection(P2PTxInvStore())
+        peer_inv_store = self.nodes[0].add_p2p_connection(P2PTxInvStore())
         self.nodes[0].generate(101)
         utxo = self.nodes[0].listunspent(10)
         txid = utxo[0]['txid']
@@ -74,7 +74,7 @@
         # (sent inv and received getdata)
         # Otherwise, getrawmempool may be inconsistent with getmempoolentry if
         # unbroadcast changes in between
-        self.nodes[0].p2p.wait_for_broadcast(chain)
+        peer_inv_store.wait_for_broadcast(chain)
 
         # Check mempool has MAX_ANCESTORS transactions in it, and descendant and ancestor
         # count and fees should look correct
diff --git a/test/functional/mining_basic.py b/test/functional/mining_basic.py
--- a/test/functional/mining_basic.py
+++ b/test/functional/mining_basic.py
@@ -243,10 +243,10 @@
 
         # Should ask for the block from a p2p node, if they announce the header
         # as well:
-        node.add_p2p_connection(P2PDataStore())
+        peer = node.add_p2p_connection(P2PDataStore())
         # Drop the first getheaders
-        node.p2p.wait_for_getheaders(timeout=5)
-        node.p2p.send_blocks_and_test(blocks=[block], node=node)
+        peer.wait_for_getheaders(timeout=5)
+        peer.send_blocks_and_test(blocks=[block], node=node)
         # Must be active now:
         assert chain_tip(block.hash, status='active',
                          branchlen=0) in node.getchaintips()
diff --git a/test/functional/p2p_blocksonly.py b/test/functional/p2p_blocksonly.py
--- a/test/functional/p2p_blocksonly.py
+++ b/test/functional/p2p_blocksonly.py
@@ -17,7 +17,7 @@
         self.extra_args = [["-blocksonly"]]
 
     def run_test(self):
-        self.nodes[0].add_p2p_connection(P2PInterface())
+        block_relay_peer = self.nodes[0].add_p2p_connection(P2PInterface())
 
         self.log.info(
             'Check that txs from p2p are rejected and result in disconnect')
@@ -46,14 +46,14 @@
         )['hex']
         assert_equal(self.nodes[0].getnetworkinfo()['localrelay'], False)
         with self.nodes[0].assert_debug_log(['transaction sent in violation of protocol peer=0']):
-            self.nodes[0].p2p.send_message(
+            block_relay_peer.send_message(
                 msg_tx(FromHex(CTransaction(), sigtx)))
-            self.nodes[0].p2p.wait_for_disconnect()
+            block_relay_peer.wait_for_disconnect()
             assert_equal(self.nodes[0].getmempoolinfo()['size'], 0)
 
         # Remove the disconnected peer and add a new one.
         del self.nodes[0].p2ps[0]
-        self.nodes[0].add_p2p_connection(P2PInterface())
+        tx_relay_peer = self.nodes[0].add_p2p_connection(P2PInterface())
 
         self.log.info(
             'Check that txs from rpc are not rejected and relayed to other peers')
@@ -61,7 +61,7 @@
         txid = self.nodes[0].testmempoolaccept([sigtx])[0]['txid']
         with self.nodes[0].assert_debug_log(['received getdata for: tx {} peer=1'.format(txid)]):
             self.nodes[0].sendrawtransaction(sigtx)
-            self.nodes[0].p2p.wait_for_tx(txid)
+            tx_relay_peer.wait_for_tx(txid)
             assert_equal(self.nodes[0].getmempoolinfo()['size'], 1)
 
         self.log.info(
diff --git a/test/functional/p2p_dos_header_tree.py b/test/functional/p2p_dos_header_tree.py
--- a/test/functional/p2p_dos_header_tree.py
+++ b/test/functional/p2p_dos_header_tree.py
@@ -48,8 +48,8 @@
 
         self.log.info(
             "Feed all non-fork headers, including and up to the first checkpoint")
-        self.nodes[0].add_p2p_connection(P2PInterface())
-        self.nodes[0].p2p.send_and_ping(msg_headers(self.headers))
+        peer_checkpoint = self.nodes[0].add_p2p_connection(P2PInterface())
+        peer_checkpoint.send_and_ping(msg_headers(self.headers))
         assert {
             'height': 546,
             'hash': '000000002a936ca763904c3c35fce2f3556c559c0214345d31b1bcebf76acb70',
@@ -59,14 +59,14 @@
 
         self.log.info("Feed all fork headers (fails due to checkpoint)")
         with self.nodes[0].assert_debug_log(['bad-fork-prior-to-checkpoint']):
-            self.nodes[0].p2p.send_message(msg_headers(self.headers_fork))
-            self.nodes[0].p2p.wait_for_disconnect()
+            peer_checkpoint.send_message(msg_headers(self.headers_fork))
+            peer_checkpoint.wait_for_disconnect()
 
         self.log.info("Feed all fork headers (succeeds without checkpoint)")
         # On node 0 it succeeds because checkpoints are disabled
         self.restart_node(0, extra_args=['-nocheckpoints'])
-        self.nodes[0].add_p2p_connection(P2PInterface())
-        self.nodes[0].p2p.send_and_ping(msg_headers(self.headers_fork))
+        peer_no_checkpoint = self.nodes[0].add_p2p_connection(P2PInterface())
+        peer_no_checkpoint.send_and_ping(msg_headers(self.headers_fork))
         assert {
             "height": 2,
             "hash": "00000000b0494bd6c3d5ff79c497cfce40831871cbf39b1bc28bd1dac817dc39",
@@ -76,8 +76,10 @@
 
         # On node 1 it succeeds because no checkpoint has been reached yet by a
         # chain tip
-        self.nodes[1].add_p2p_connection(P2PInterface())
-        self.nodes[1].p2p.send_and_ping(msg_headers(self.headers_fork))
+        peer_before_checkpoint = self.nodes[1].add_p2p_connection(
+            P2PInterface())
+        peer_before_checkpoint.send_and_ping(
+            msg_headers(self.headers_fork))
         assert {
             "height": 2,
             "hash": "00000000b0494bd6c3d5ff79c497cfce40831871cbf39b1bc28bd1dac817dc39",
diff --git a/test/functional/p2p_filter.py b/test/functional/p2p_filter.py
--- a/test/functional/p2p_filter.py
+++ b/test/functional/p2p_filter.py
@@ -152,7 +152,7 @@
             "Send a mempool msg after connecting and check that the tx is received")
         self.nodes[0].add_p2p_connection(filter_peer)
         filter_peer.send_and_ping(filter_peer.watch_filter_init)
-        self.nodes[0].p2p.send_message(msg_mempool())
+        filter_peer.send_message(msg_mempool())
         filter_peer.wait_for_tx(txid)
 
     def test_frelay_false(self, filter_peer):
diff --git a/test/functional/p2p_invalid_block.py b/test/functional/p2p_invalid_block.py
--- a/test/functional/p2p_invalid_block.py
+++ b/test/functional/p2p_invalid_block.py
@@ -34,7 +34,7 @@
     def run_test(self):
         # Add p2p connection to node0
         node = self.nodes[0]  # convenience reference to the node
-        node.add_p2p_connection(P2PDataStore())
+        peer = node.add_p2p_connection(P2PDataStore())
 
         best_block = node.getblock(node.getbestblockhash())
         tip = int(node.getbestblockhash(), 16)
@@ -49,7 +49,7 @@
         # Save the coinbase for later
         block1 = block
         tip = block.sha256
-        node.p2p.send_blocks_and_test([block1], node, success=True)
+        peer.send_blocks_and_test([block1], node, success=True)
 
         self.log.info("Mature the block.")
         node.generatetoaddress(100, node.get_deterministic_priv_key().address)
@@ -92,7 +92,7 @@
         assert_equal(orig_hash, block2.rehash())
         assert block2_orig.vtx != block2.vtx
 
-        node.p2p.send_blocks_and_test(
+        peer.send_blocks_and_test(
             [block2], node, success=False, reject_reason='bad-txns-duplicate')
 
         # Check transactions for duplicate inputs (CVE-2018-17144)
@@ -105,7 +105,7 @@
         block2_dup.hashMerkleRoot = block2_dup.calc_merkle_root()
         block2_dup.rehash()
         block2_dup.solve()
-        node.p2p.send_blocks_and_test(
+        peer.send_blocks_and_test(
             [block2_dup], node, success=False,
             reject_reason='bad-txns-inputs-duplicate')
 
@@ -120,7 +120,7 @@
         block3.rehash()
         block3.solve()
 
-        node.p2p.send_blocks_and_test(
+        peer.send_blocks_and_test(
             [block3], node, success=False, reject_reason='bad-cb-amount')
 
         # Complete testing of CVE-2012-2459 by sending the original block.
@@ -129,8 +129,8 @@
 
         self.log.info("Test accepting original block after rejecting its"
                       " mutated version.")
-        node.p2p.send_blocks_and_test([block2_orig], node, success=True,
-                                      timeout=5)
+        peer.send_blocks_and_test([block2_orig], node, success=True,
+                                  timeout=5)
 
         # Update tip info
         height += 1
@@ -152,8 +152,8 @@
         block4.rehash()
         block4.solve()
         self.log.info("Test inflation by duplicating input")
-        node.p2p.send_blocks_and_test([block4], node, success=False,
-                                      reject_reason='bad-txns-inputs-duplicate')
+        peer.send_blocks_and_test([block4], node, success=False,
+                                  reject_reason='bad-txns-inputs-duplicate')
 
 
 if __name__ == '__main__':
diff --git a/test/functional/p2p_invalid_locator.py b/test/functional/p2p_invalid_locator.py
--- a/test/functional/p2p_invalid_locator.py
+++ b/test/functional/p2p_invalid_locator.py
@@ -30,23 +30,23 @@
         for msg in [msg_getheaders(), msg_getblocks()]:
             self.log.info('Wait for disconnect when sending {} hashes in locator'.format(
                 MAX_LOCATOR_SZ + 1))
-            node.add_p2p_connection(P2PInterface())
+            exceed_max_peer = node.add_p2p_connection(P2PInterface())
             msg.locator.vHave = [int(node.getblockhash(
                 i - 1), 16) for i in range(block_count, block_count - (MAX_LOCATOR_SZ + 1), -1)]
-            node.p2p.send_message(msg)
-            node.p2p.wait_for_disconnect()
-            node.disconnect_p2ps()
+            exceed_max_peer.send_message(msg)
+            exceed_max_peer.wait_for_disconnect()
 
             self.log.info(
                 'Wait for response when sending {} hashes in locator'.format(MAX_LOCATOR_SZ))
-            node.add_p2p_connection(P2PInterface())
+            within_max_peer = node.add_p2p_connection(P2PInterface())
             msg.locator.vHave = [int(node.getblockhash(
                 i - 1), 16) for i in range(block_count, block_count - (MAX_LOCATOR_SZ), -1)]
-            node.p2p.send_message(msg)
+            within_max_peer.send_message(msg)
             if isinstance(msg, msg_getheaders):
-                node.p2p.wait_for_header(node.getbestblockhash())
+                within_max_peer.wait_for_header(node.getbestblockhash())
             else:
-                node.p2p.wait_for_block(int(node.getbestblockhash(), 16))
+                within_max_peer.wait_for_block(
+                    int(node.getbestblockhash(), 16))
 
 
 if __name__ == '__main__':
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -354,7 +354,7 @@
     def _test_waitforblockheight(self):
         self.log.info("Test waitforblockheight")
         node = self.nodes[0]
-        node.add_p2p_connection(P2PInterface())
+        peer = node.add_p2p_connection(P2PInterface())
 
         current_height = node.getblock(node.getbestblockhash())['height']
 
@@ -371,7 +371,7 @@
         def solve_and_send_block(prevhash, height, time):
             b = create_block(prevhash, create_coinbase(height), time)
             b.solve()
-            node.p2p.send_and_ping(msg_block(b))
+            peer.send_and_ping(msg_block(b))
             return b
 
         b21f = solve_and_send_block(int(b20hash, 16), 21, b20['time'] + 1)
diff --git a/test/functional/wallet_resendwallettransactions.py b/test/functional/wallet_resendwallettransactions.py
--- a/test/functional/wallet_resendwallettransactions.py
+++ b/test/functional/wallet_resendwallettransactions.py
@@ -22,7 +22,7 @@
     def run_test(self):
         node = self.nodes[0]  # alias
 
-        node.add_p2p_connection(P2PTxInvStore())
+        peer_first = node.add_p2p_connection(P2PTxInvStore())
 
         self.log.info("Create a new transaction and wait until it's broadcast")
         txid = node.sendtoaddress(node.getnewaddress(), 1_000_000)
@@ -34,11 +34,11 @@
         node.mockscheduler(1)
 
         # Can take a few seconds due to transaction trickling
-        node.p2p.wait_for_broadcast([txid])
+        peer_first.wait_for_broadcast([txid])
 
         # Add a second peer since txs aren't rebroadcast to the same peer (see
         # filterInventoryKnown)
-        node.add_p2p_connection(P2PTxInvStore())
+        peer_second = node.add_p2p_connection(P2PTxInvStore())
 
         self.log.info("Create a block")
         # Create and submit a block without the transaction.
@@ -74,7 +74,7 @@
             node.mockscheduler(1)
         # Give some time for trickle to occur
         node.setmocktime(now + 36 * 60 * 60 + 600)
-        node.p2p.wait_for_broadcast([txid])
+        peer_second.wait_for_broadcast([txid])
 
 
 if __name__ == '__main__':