Struct Peer 

pub struct Peer {
    pub peer_id: PeerId,
    pub direction: PeerDirection,
    pub created_at: Instant,
    pub connected_at: Option<Instant>,
    pub data_channel: Arc<Mutex<Option<Arc<RTCDataChannel>>>>,
    pub pending_requests: Arc<Mutex<HashMap<String, PendingRequest>>>,
    /* private fields */
}

WebRTC peer connection with data channel protocol

Fields

peer_id: PeerId

direction: PeerDirection

created_at: Instant

connected_at: Option<Instant>

data_channel: Arc<Mutex<Option<Arc<RTCDataChannel>>>>

Data channel - can be set from callback when receiving channel from peer

pending_requests: Arc<Mutex<HashMap<String, PendingRequest>>>

Implementations

impl Peer

pub async fn new( peer_id: PeerId, direction: PeerDirection, my_peer_id: PeerId, signaling_tx: Sender<SignalingMessage>, stun_servers: Vec<String>, ) -> Result<Self>

Create a new peer connection

pub async fn new_with_store( peer_id: PeerId, direction: PeerDirection, my_peer_id: PeerId, signaling_tx: Sender<SignalingMessage>, stun_servers: Vec<String>, store: Option<Arc<dyn ContentStore>>, ) -> Result<Self>

Create a new peer connection with content store

pub fn set_store(&mut self, store: Arc<dyn ContentStore>)

Set content store

pub fn state(&self) -> RTCPeerConnectionState

Get connection state

pub fn signaling_state(&self) -> RTCSignalingState

Get signaling state

pub fn is_connected(&self) -> bool

Check if connected

pub fn htl_config(&self) -> &PeerHTLConfig

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

Setup event handlers for the peer connection

pub async fn connect(&self) -> Result<Value>

Initiate connection (create offer) - for outbound connections

pub async fn handle_offer(&self, offer: Value) -> Result<Value>

Handle incoming offer and create answer

pub async fn handle_answer(&self, answer: Value) -> Result<()>

Handle incoming answer

pub async fn handle_candidate(&self, candidate: Value) -> Result<()>

Handle incoming ICE candidate

pub fn has_data_channel(&self) -> bool

Check if data channel is ready

pub async fn request(&self, hash_hex: &str) -> Result<Option<Vec<u8>>>

Request content by hash from this peer

pub async fn request_with_timeout( &self, hash_hex: &str, timeout: Duration, ) -> Result<Option<Vec<u8>>>

Request content by hash from this peer with an explicit timeout.

pub async fn query_nostr_events( &self, filters: Vec<NostrFilter>, timeout: Duration, ) -> Result<Vec<Event>>

Query a peer’s embedded Nostr relay over the WebRTC data channel. Returns all events received before EOSE/timeout.

pub async fn send_mesh_frame_text(&self, frame: &MeshNostrFrame) -> Result<()>

Send a mesh signaling frame as text over the data channel.

pub async fn send_message(&self, msg: &DataMessage) -> Result<()>

Send a message over the data channel

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

Close the connection

Trait Implementations

impl PeerLink for Peer

fn send<'life0, 'async_trait>( &'life0 self, data: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), RoutedTransportError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Send data to the peer.

fn recv<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<Vec<u8>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receive data from the peer.

fn try_recv(&self) -> Option<Vec<u8>>

Try to receive data without blocking. Returns None when no message is currently available.

fn is_open(&self) -> bool

Check if the link is open.

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Close the link.