rpc: Expose transport type via getpeerinfo

Author: dhruv

src/net.cpp

@@ -688,6 +688,7 @@ void CNode::CopyStats(CNodeStats& stats)
     stats.addrLocal = addrLocalUnlocked.IsValid() ? addrLocalUnlocked.ToString() : "";
 
     X(m_conn_type);
+    X(m_transport_type);
 }
 #undef X
 
@@ -1329,6 +1330,7 @@ void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
                                .prefer_evict = discouraged,
                              },
                              /*prefer_p2p_v2*/ false);
+    pnode->m_transport_type = TransportProtocolType::V1;
     pnode->AddRef();
     m_msgproc->InitializeNode(*pnode, nodeServices);
 
@@ -1627,6 +1629,7 @@ void CConnman::SocketHandlerConnected(const std::vector<CNode*>& nodes,
                                 PushV2EllSwiftPubkey(pnode);
                                 // We now know the peer prefers a BIP324 v2 connection
                                 pnode->m_prefer_p2p_v2 = true;
+                                pnode->m_transport_type = TransportProtocolType::V2;
                             }
 
                             // Keys are not derived because we don't have the peer ellswift yet, keep buffering.
@@ -1695,6 +1698,7 @@ void CConnman::SocketHandlerConnected(const std::vector<CNode*>& nodes,
                                 pnode->CloseSocketDisconnect();
                             } else {
                                 pnode->v2_key_exchange_complete = true;
+                                pnode->m_transport_type = TransportProtocolType::V2;
                                 if (!pnode->IsInboundConn()) {
                                     // Outbound peer has completed key exchange and can start the P2P protocol
                                     m_msgproc->InitP2P(*pnode, nLocalServices);
@@ -2401,6 +2405,9 @@ void CConnman::OpenNetworkConnection(const CAddress& addrConnect, bool fCountFai
     // Only the outbound peer knows that both sides support BIP324 transport
     if (pnode->PreferV2Conn()) {
         PushV2EllSwiftPubkey(pnode);
+        pnode->m_transport_type = TransportProtocolType::V2;
+    } else {
+        pnode->m_transport_type = TransportProtocolType::V1;
     }
     m_msgproc->InitializeNode(*pnode, nLocalServices);
     {
@@ -3154,7 +3161,8 @@ CNode::CNode(NodeId idIn,
              ConnectionType conn_type_in,
              bool inbound_onion,
              CNodeOptions&& node_opts,
-             bool prefer_p2p_v2)
+             bool prefer_p2p_v2,
+             TransportProtocolType transport_type_in)
     : m_permission_flags{node_opts.permission_flags},
       m_sock{sock},
       m_connected{GetTime<std::chrono::seconds>()},
@@ -3164,6 +3172,7 @@ CNode::CNode(NodeId idIn,
       m_inbound_onion{inbound_onion},
       m_prefer_evict{node_opts.prefer_evict},
       nKeyedNetGroup{nKeyedNetGroupIn},
+      m_transport_type{transport_type_in},
       id{idIn},
       nLocalHostNonce{nLocalHostNonceIn},
       m_conn_type{conn_type_in},

src/net.h

@@ -233,6 +233,7 @@ class CNodeStats
     Network m_network;
     uint32_t m_mapped_as;
     ConnectionType m_conn_type;
+    TransportProtocolType m_transport_type;
 };
 
 
@@ -527,6 +528,7 @@ class CNode
     const uint64_t nKeyedNetGroup;
     std::atomic_bool fPauseRecv{false};
     std::atomic_bool fPauseSend{false};
+    TransportProtocolType m_transport_type;
     std::atomic_bool v2_key_exchange_complete{false};
     std::atomic_bool m_authenticated_v2_garbage{false};
     bool v2_garbage_terminated{false};
@@ -653,7 +655,8 @@ class CNode
           ConnectionType conn_type_in,
           bool inbound_onion,
           CNodeOptions&& node_opts = {},
-          bool prefer_p2p_v2 = false);
+          bool prefer_p2p_v2 = false,
+         TransportProtocolType transport_type_in = TransportProtocolType::V1);
     CNode(const CNode&) = delete;
     CNode& operator=(const CNode&) = delete;
 

src/node/connection_types.cpp

@@ -24,3 +24,15 @@ std::string ConnectionTypeAsString(ConnectionType conn_type)
 
     assert(false);
 }
+
+std::string TransportTypeAsString(TransportProtocolType transport_type)
+{
+    switch (transport_type) {
+    case TransportProtocolType::V1:
+        return "v1";
+    case TransportProtocolType::V2:
+        return "v2";
+    } // no default case, so the compiler can warn about missing cases
+
+    assert(false);
+}

src/node/connection_types.h

@@ -79,4 +79,13 @@ enum class ConnectionType {
 /** Convert ConnectionType enum to a string value */
 std::string ConnectionTypeAsString(ConnectionType conn_type);
 
+/** Transport layer version */
+enum class TransportProtocolType {
+    V1, // unencrypted, plaintext protocol
+    V2, // BIP324 protocol
+};
+
+/** Convert TransportProtocolType enum to a string value */
+std::string TransportTypeAsString(TransportProtocolType transport_type);
+
 #endif // BITCOIN_NODE_CONNECTION_TYPES_H

src/rpc/net.cpp

@@ -44,6 +44,11 @@ const std::vector<std::string> CONNECTION_TYPE_DOC{
         "feeler (short-lived automatic connection for testing addresses)"
 };
 
+const std::vector<std::string> TRANSPORT_TYPE_DOC{
+        "v1 (plaintext transport protocol)",
+        "v2 (BIP324 encrypted transport protocol)"
+};
+
 static RPCHelpMan getconnectioncount()
 {
     return RPCHelpMan{"getconnectioncount",
@@ -163,6 +168,7 @@ static RPCHelpMan getpeerinfo()
                     {RPCResult::Type::STR, "connection_type", "Type of connection: \n" + Join(CONNECTION_TYPE_DOC, ",\n") + ".\n"
                                                               "Please note this output is unlikely to be stable in upcoming releases as we iterate to\n"
                                                               "best capture connection behaviors."},
+                    {RPCResult::Type::STR, "transport_protocol_type", "Type of transport protocol: \n" + Join(TRANSPORT_TYPE_DOC, ",\n") + ".\n"},
                 }},
             }},
         },
@@ -263,6 +269,7 @@ static RPCHelpMan getpeerinfo()
         }
         obj.pushKV("bytesrecv_per_msg", recvPerMsgType);
         obj.pushKV("connection_type", ConnectionTypeAsString(stats.m_conn_type));
+        obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type));
 
         ret.push_back(obj);
     }

test/functional/p2p_v2.py

@@ -31,6 +31,7 @@ def run_test(self):
         # sync_all() verifies that the block tips match
         self.sync_all(self.nodes[0:2])
         assert_equal(self.nodes[1].getblockcount(), 5)
+        assert_equal(self.nodes[1].getpeerinfo()[0]["transport_protocol_type"], "v2")
 
         # V1 nodes can sync with each other
         assert_equal(self.nodes[2].getblockcount(), 0)
@@ -42,6 +43,7 @@ def run_test(self):
         self.sync_all(self.nodes[2:4])
         assert_equal(self.nodes[3].getblockcount(), 8)
         assert self.nodes[0].getbestblockhash() != self.nodes[2].getbestblockhash()
+        assert_equal(self.nodes[2].getpeerinfo()[0]["transport_protocol_type"], "v1")
 
         # V1 nodes can sync with V2 nodes
         self.disconnect_nodes(0, 1)
@@ -50,12 +52,14 @@ def run_test(self):
         self.sync_all(self.nodes[1:3])
         assert_equal(self.nodes[1].getblockcount(), 8)
         assert self.nodes[0].getbestblockhash() != self.nodes[1].getbestblockhash()
+        assert_equal(self.nodes[2].getpeerinfo()[0]["transport_protocol_type"], "v1")
 
         # V2 nodes can sync with V1 nodes
         self.disconnect_nodes(1, 2)
         self.connect_nodes(0, 3, False)
         self.sync_all([self.nodes[0], self.nodes[3]])
         assert_equal(self.nodes[0].getblockcount(), 8)
+        assert_equal(self.nodes[0].getpeerinfo()[0]["transport_protocol_type"], "v1")
 
         # V2 node mines another block and everyone gets it
         self.connect_nodes(0, 1, True)
@@ -74,6 +78,7 @@ def run_test(self):
         self.connect_nodes(1, 4, True)
         self.sync_all()
         assert_equal(self.nodes[4].getblockcount(), 11)
+        assert_equal(self.nodes[4].getpeerinfo()[0]["transport_protocol_type"], "v1")
 
 
 if __name__ == '__main__':