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

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<Peer, Error>

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<Peer, Error>

pub async fn new_with_store_and_events( peer_id: PeerId, direction: PeerDirection, my_peer_id: PeerId, signaling_tx: Sender<SignalingMessage>, stun_servers: Vec<String>, store: Option<Arc<dyn ContentStore>>, state_event_tx: Option<Sender<PeerStateEvent>>, nostr_relay: Option<Arc<dyn MeshRelayClient>>, mesh_frame_tx: Option<Sender<(PeerId, MeshNostrFrame)>>, cashu_quotes: Option<Arc<CashuQuoteState>>, ) -> Result<Peer, Error>

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

pub fn state(&self) -> RTCPeerConnectionState

pub fn signaling_state(&self) -> RTCSignalingState

pub fn is_connected(&self) -> bool

pub fn htl_config(&self) -> &PeerHTLConfig

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

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

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

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

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

pub fn has_data_channel(&self) -> bool

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

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

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

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

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

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

Trait Implementations

impl PeerLink for Peer

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

where 'life0: 'async_trait, Peer: '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 'life0: 'async_trait, Peer: '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 'life0: 'async_trait, Peer: 'async_trait,

Close the link.