Struct P2PNode

pub struct P2PNode { /* private fields */ }

Main P2P node structure

Implementations

impl P2PNode

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 async fn initialize_mcp_network(&self) -> Result<()>

Initialize MCP network integration This method should be called after node creation to enable MCP network features

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 is_running(&self) -> bool

Check if the node is running

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

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 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

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 uptime(&self) -> Duration

Get node uptime

pub fn mcp_server(&self) -> Option<&Arc<MCPServer>>

Get MCP server reference

pub async fn register_mcp_tool(&self, tool: Tool) -> Result<()>

Register a tool in the MCP server

pub async fn call_mcp_tool( &self, tool_name: &str, arguments: Value, ) -> Result<Value>

Call a local MCP tool

pub async fn call_remote_mcp_tool( &self, peer_id: &PeerId, tool_name: &str, arguments: Value, ) -> Result<Value>

Call a remote MCP tool on another node

pub async fn list_mcp_tools(&self) -> Result<Vec<String>>

List available tools in the local MCP server

pub async fn discover_remote_mcp_services(&self) -> Result<Vec<MCPService>>

Discover remote MCP services in the network

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

List tools available on a specific remote peer

pub async fn mcp_stats(&self) -> Result<MCPServerStats>

Get MCP server statistics

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

pub async fn discover_mcp_services(&self) -> Result<Vec<MCPService>>

Discover available MCP services on the network

pub async fn get_all_mcp_services(&self) -> Result<Vec<MCPService>>

Get all known MCP services (local + remote)

pub async fn find_mcp_services_with_tool( &self, tool_name: &str, ) -> Result<Vec<MCPService>>

Find MCP services that provide a specific tool

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

Manually announce local MCP services

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

Refresh MCP service discovery

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

Send a service discovery query to a specific peer

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

Broadcast service discovery query to all connected peers