Struct Peer 

pub struct Peer<S: Store> {
    pub remote_id: PeerId,
    /* private fields */
}

WebRTC peer connection wrapper

Each Peer is an independent agent that tracks:

• pending_requests: requests WE sent TO this peer (awaiting response)
• their_requests: requests THEY sent TO US that we couldn’t fulfill

This matches the hashtree-ts Peer architecture. Wire protocol is binary MessagePack compatible with hashtree-ts.

Fields

remote_id: PeerId

Remote peer identifier

Implementations

impl<S: Store + 'static> Peer<S>

pub async fn new( remote_id: PeerId, local_peer_id: String, signaling_tx: Sender<SignalingMessage>, local_store: Arc<S>, debug: bool, ) -> Result<Self, PeerError>

Create a new peer connection

pub async fn with_forward_channel( remote_id: PeerId, local_peer_id: String, signaling_tx: Sender<SignalingMessage>, local_store: Arc<S>, debug: bool, forward_tx: Option<ForwardTx>, ) -> Result<Self, PeerError>

Create a new peer connection with a forwarding channel

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

Initiate connection as offerer

pub async fn handle_signaling( &self, msg: SignalingMessage, ) -> Result<(), PeerError>

Handle incoming signaling message

pub async fn request(&self, hash: &Hash) -> Result<Option<Vec<u8>>, PeerError>

Request data by hash with default HTL

pub async fn request_with_htl( &self, hash: &Hash, htl: u8, ) -> Result<Option<Vec<u8>>, PeerError>

Request data by hash with specified HTL Uses binary MessagePack protocol compatible with hashtree-ts

pub async fn send_response_for_hash( &self, hash: &Hash, data: Option<&[u8]>, ) -> Result<(), PeerError>

Send data response using binary MessagePack protocol Note: For found data, use the internal fragmentation-aware send_response This method is kept for API compatibility but now uses binary protocol

pub async fn state(&self) -> PeerState

Get current connection state

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

Close the connection

pub fn set_on_forward_request<F>(&mut self, callback: F)

where F: Fn(Hash, String, u8) -> BoxFuture<'static, Option<Vec<u8>>> + Send + Sync + 'static,

Set the forward request callback Called when this peer requests data we don’t have locally Parameters: (hash, exclude_peer_id, htl)

pub fn htl_config(&self) -> PeerHTLConfig

Get the peer’s HTL config (for testing)

pub async fn send_data( &self, hash_hex: &str, data: &[u8], ) -> Result<bool, PeerError>

Send data to this peer for a hash they previously requested Returns true if this peer had requested this hash

pub async fn has_requested(&self, hash_hex: &str) -> bool

Check if this peer has requested a hash

pub async fn their_request_count(&self) -> usize

Get count of pending requests from this peer

pub async fn our_request_count(&self) -> usize

Get count of pending requests we sent to this peer