Struct P2PNode 

pub struct P2PNode {
    pub security_dashboard: Option<Arc<SecurityDashboard>>,
    /* private fields */
}

Main P2P node structure Main P2P network node that manages connections, routing, and communication

This struct represents a complete P2P network participant that can:

• Connect to other peers via QUIC transport
• Participate in distributed hash table (DHT) operations
• Send and receive messages through various protocols
• Handle network events and peer lifecycle
• Provide MCP (Model Context Protocol) services

Fields

security_dashboard: Option<Arc<SecurityDashboard>>

Security dashboard for monitoring

Implementations

impl P2PNode

pub fn new_for_tests() -> Result<Self>

Minimal constructor for tests that avoids real networking

pub async fn new(config: NodeConfig) -> Result<Self>

Create a new P2P node with the given configuration

pub fn builder() -> NodeBuilder

Create a new node builder

pub fn peer_id(&self) -> &PeerId

Get the peer ID of this node

pub fn transport_peer_id(&self) -> Option<String>

Get the hex-encoded transport-level peer ID.

This is the ID used in P2PEvent::Message.source, connected_peers(), and send_message(). It differs from peer_id() which is the app-level ID.

Returns the transport peer ID from whichever stack (v4 or v6) is active.

pub fn local_addr(&self) -> Option<String>

pub async fn subscribe(&self, topic: &str) -> Result<()>

pub async fn publish(&self, topic: &str, data: &[u8]) -> Result<()>

pub fn config(&self) -> &NodeConfig

Get the node configuration

pub async fn start(&self) -> Result<()>

Start the P2P node

pub async fn run(&self) -> Result<()>

Run the P2P node (blocks until shutdown)

pub async fn stop(&self) -> Result<()>

Stop the P2P node

pub async fn shutdown(&self) -> Result<()>

Graceful shutdown alias for tests

pub async fn is_running(&self) -> bool

Check if the node is running

pub async fn listen_addrs(&self) -> Vec<SocketAddr>

Get the current listen addresses

pub async fn connected_peers(&self) -> Vec<PeerId>

Get connected peers

pub async fn peer_count(&self) -> usize

Get peer count

pub async fn peer_info(&self, peer_id: &PeerId) -> Option<PeerInfo>

Get peer info

pub async fn get_peer_id_by_address(&self, addr: &str) -> Option<PeerId>

Get the peer ID for a given socket address, if connected

This method searches through all connected peers to find one that has the specified address in its address list.

Arguments

• addr - The socket address to search for (e.g., “192.168.1.100:9000”)

Returns

• Some(PeerId) - The peer ID if a matching connected peer is found
• None - If no peer with this address is currently connected

pub async fn list_active_connections(&self) -> Vec<(PeerId, Vec<String>)>

List all active connections with their peer IDs and addresses

Returns

A vector of tuples containing (PeerId, Vec) where the Vec contains all known addresses for that peer.

pub async fn remove_peer(&self, peer_id: &PeerId) -> bool

Remove a peer from the peers map

This method removes a peer from the internal peers map. It should be used when a connection is no longer valid (e.g., after detecting that the underlying ant-quic connection has closed).

Arguments

• peer_id - The ID of the peer to remove

Returns

true if the peer was found and removed, false if the peer was not in the map

pub async fn is_peer_connected(&self, peer_id: &PeerId) -> bool

Check if a peer is connected

This method checks if the peer ID exists in the peers map. Note that this only verifies the peer is registered - it does not guarantee the underlying ant-quic connection is still active. For connection validation, use send_message which will fail if the connection is closed.

Arguments

• peer_id - The ID of the peer to check

Returns

true if the peer exists in the peers map, false otherwise

pub async fn connect_peer(&self, address: &str) -> Result<PeerId>

Connect to a peer

pub async fn disconnect_peer(&self, peer_id: &PeerId) -> Result<()>

Disconnect from a peer

Actively closes the underlying QUIC connection via P2pEndpoint::disconnect() and removes the peer from all local tracking maps.

pub async fn is_connection_active(&self, peer_id: &str) -> bool

Check if a connection to a peer is active

pub async fn send_message( &self, peer_id: &PeerId, protocol: &str, data: Vec<u8>, ) -> Result<()>

Send a message to a peer

impl P2PNode

pub fn subscribe_events(&self) -> Receiver<P2PEvent>

Subscribe to network events

pub fn events(&self) -> Receiver<P2PEvent>

Backwards-compat event stream accessor for tests

pub fn uptime(&self) -> Duration

Get node uptime

pub fn binary_hash(&self) -> &[u8; 32]

Get this node’s binary hash used for attestation.

pub fn entangled_id(&self) -> Option<&EntangledId>

Get this node’s entangled identity, if set.

pub fn set_entangled_id(&mut self, entangled_id: EntangledId)

Set the entangled identity for this node.

This should be called after the node’s cryptographic identity is established, typically by deriving from the NodeIdentity’s public key.

pub fn verify_peer_attestation( &self, peer_id: &str, peer_entangled_id: &EntangledId, peer_public_key: &MlDsaPublicKey, ) -> EnforcementDecision

Verify a peer’s attestation and return the enforcement decision.

This function implements the Entangled Attestation verification protocol (Phase 6: Hard Enforcement). Based on the configured enforcement mode:

• Off: Skips verification entirely
• Soft: Logs warnings but allows connections
• Hard: Rejects connections with invalid attestations

Arguments

• peer_id - The peer’s identifier for logging
• peer_entangled_id - The peer’s claimed entangled ID
• peer_public_key - The peer’s ML-DSA public key

Returns

An [EnforcementDecision] indicating whether to allow or reject the connection.

Example

let decision = node.verify_peer_attestation(peer_id, &entangled_id, &public_key);
if decision.should_reject() {
    // Send rejection message and close connection
    if let Some(rejection) = decision.rejection() {
        send_rejection(peer_id, rejection);
    }
    disconnect(peer_id);
}

pub fn verify_peer_attestation_simple( &self, peer_id: &str, peer_entangled_id: &EntangledId, peer_public_key: &MlDsaPublicKey, ) -> bool

Verify a peer’s attestation and return a simple boolean result.

This is a convenience method that wraps [verify_peer_attestation] for cases where only a pass/fail result is needed without the detailed decision.

Returns

true if the connection should be allowed, false if it should be rejected.

pub async fn resource_metrics(&self) -> Result<ResourceMetrics>

Get production resource metrics

pub async fn health_check(&self) -> Result<()>

Check system health

pub fn production_config(&self) -> Option<&ProductionConfig>

Get production configuration (if enabled)

pub fn is_production_mode(&self) -> bool

Check if production hardening is enabled

pub fn dht(&self) -> Option<&Arc<RwLock<DHT>>>

Get DHT reference

pub async fn dht_put(&self, key: Key, value: Vec<u8>) -> Result<()>

Store a value in the DHT

pub async fn dht_get(&self, key: Key) -> Result<Option<Vec<u8>>>

Retrieve a value from the DHT

pub async fn add_discovered_peer( &self, peer_id: PeerId, addresses: Vec<String>, ) -> Result<()>

Add a discovered peer to the bootstrap cache

pub async fn update_peer_metrics( &self, peer_id: &PeerId, success: bool, latency_ms: Option<u64>, _error: Option<String>, ) -> Result<()>

Update connection metrics for a peer in the bootstrap cache

pub async fn get_bootstrap_cache_stats(&self) -> Result<Option<CacheStats>>

Get bootstrap cache statistics

pub async fn cached_peer_count(&self) -> usize

Get the number of cached bootstrap peers