Struct FireCloudNode 

pub struct FireCloudNode { /* private fields */ }

A FireCloud P2P node

Implementations

impl FireCloudNode

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

Create a new FireCloud node

pub fn peer_latency(&self, peer: &PeerId) -> Option<Duration>

Get the latest measured RTT for a peer, if available

pub fn select_lowest_latency_peer( &self, candidates: &[PeerId], ) -> Option<PeerId>

Select the peer with the lowest recorded latency from the provided list Returns None if no latencies are known for the provided peers

pub fn is_local_peer(&self, peer: &PeerId) -> bool

Check if a peer was discovered via mDNS (i.e., is on the local network)

pub fn local_peers(&self) -> &HashSet<PeerId>

Get list of local (mDNS-discovered) peers

pub fn choose_best_peer(&self, candidates: &[PeerId]) -> Option<PeerId>

Choose the best peer from candidates for chunk retrieval. Priority:

1. Local peers (mDNS-discovered) with lowest latency
2. Any peer with lowest latency
3. First candidate if no latency info available

pub fn local_peer_id(&self) -> PeerId

Get local peer ID

pub fn known_peers(&self) -> &HashSet<PeerId>

Get known peers

pub fn connected_peers_count(&self) -> usize

Get the number of connected peers

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

Get all connected peer IDs

pub fn kademlia_peers_count(&self) -> usize

Get Kademlia routing table size (approximate)

pub fn add_bootstrap_peer(&mut self, peer_id: &PeerId, addr: Multiaddr)

Add a bootstrap peer to Kademlia

pub fn bootstrap(&mut self) -> NetResult<QueryId>

Trigger Kademlia bootstrap process

pub fn subscribe(&mut self, topic: &str) -> NetResult<()>

Subscribe to a GossipSub topic

pub fn publish(&mut self, topic: &str, data: Vec<u8>) -> NetResult<()>

Publish a message to a topic

pub fn dial(&mut self, addr: Multiaddr) -> NetResult<()>

Dial a peer by address

pub fn health_monitor(&self) -> &HealthMonitor

Get reference to health monitor

pub fn get_best_peer_for_transfer(&self) -> Option<PeerId>

Get best peer for transfer (uses health monitor)

pub fn get_healthy_peers(&self) -> Vec<PeerId>

Get healthy peers sorted by health score

pub fn cleanup_offline_peers(&mut self)

Cleanup offline peers from health monitor

pub fn send_transfer_request( &mut self, peer: &PeerId, request: TransferRequest, ) -> OutboundRequestId

Send a transfer request to a peer

pub fn respond_transfer( &mut self, channel: ResponseChannel<TransferResponse>, response: TransferResponse, ) -> NetResult<()>

Send a response to a transfer request

pub fn request_chunk( &mut self, peer: &PeerId, hash: String, ) -> OutboundRequestId

Request a chunk from a peer

pub fn send_message_request( &mut self, peer: &PeerId, request: MessageRequest, ) -> OutboundRequestId

Send a message request to a peer

pub fn respond_message( &mut self, channel: ResponseChannel<MessageResponse>, response: MessageResponse, ) -> NetResult<()>

Send a response to a message request

pub fn send_friend_request( &mut self, peer: &PeerId, name: Option<String>, ) -> OutboundRequestId

Send a friend request to a peer

pub fn send_friend_accept(&mut self, peer: &PeerId) -> OutboundRequestId

Accept a friend request from a peer

pub fn send_direct_message( &mut self, peer: &PeerId, content: Vec<u8>, message_id: String, timestamp: i64, ) -> OutboundRequestId

Send a direct message to a friend (content already padded to 1KB!)

pub fn ping_peer(&mut self, peer: &PeerId) -> OutboundRequestId

Ping a peer to check if they’re online

pub fn store_chunk_on_peer( &mut self, peer: &PeerId, hash: String, data: Vec<u8>, original_size: u64, ) -> OutboundRequestId

Store a chunk on a peer

pub fn check_chunk(&mut self, peer: &PeerId, hash: String) -> OutboundRequestId

Check if a peer has a chunk

pub fn announce_file(&mut self, file_id: &str) -> QueryId

Announce this node as a provider for a file (by file_id) Other nodes can then find us via get_providers

pub fn stop_announcing_file(&mut self, file_id: &str)

Stop announcing as a provider for a file

pub fn find_file_providers(&mut self, file_id: &str) -> QueryId

Find providers for a file (by file_id) Results will come via NodeEvent::ProvidersFound

pub fn put_dht_record(&mut self, key: &str, value: Vec<u8>) -> QueryId

Store a record in the DHT (for manifest metadata) Results will come via NodeEvent::RecordStored

pub fn get_dht_record(&mut self, key: &str) -> QueryId

Get a record from the DHT Results will come via NodeEvent::RecordFound

pub fn bootstrap_dht(&mut self) -> Result<QueryId, NoKnownPeers>

Bootstrap Kademlia DHT (find closest peers to self)

pub async fn run(&mut self)

Run the node event loop

pub async fn poll_event(&mut self) -> Option<NodeEvent>

Poll for the next event (non-blocking version for integration)