Struct DigLink 

pub struct DigLink(/* private fields */);

A live websocket link to one peer, framing every message as a DigMessage.

Cheap to clone: every clone shares one connection, one request map and one rate-limit budget.

Implementations

impl DigLink

pub fn from_websocket( ws: WebSocketStream<MaybeTlsStream<TcpStream>>, options: LinkOptions, ) -> Result<(Self, Receiver<DigMessage>), LinkError>

Adopt an already-established client-side websocket.

The peer address is recovered from the underlying stream. The connection is expected to be TLS-secured, so that a peer id can be derived from the certificate.

pub fn from_server_websocket<S>( ws: WebSocketStream<S>, socket_addr: SocketAddr, options: LinkOptions, ) -> (Self, Receiver<DigMessage>)

where S: AsyncRead + AsyncWrite + Unpin + Send + 'static,

Adopt an already-established server-side websocket.

An inbound acceptor already knows socket_addr and holds a server-side TLS stream that cannot inhabit MaybeTlsStream, hence the separate constructor generic over the transport.

The caller must derive the peer id from the client certificate before calling this: the certificate is no longer reachable once the stream has been split.

pub fn socket_addr(&self) -> SocketAddr

The address of the peer on the other end.

pub async fn send<T>(&self, body: T) -> Result<(), LinkError>

where T: Streamable + ChiaProtocolMessage,

Send a Chia-typed body with no correlation id and no expected reply.

pub async fn send_dig(&self, opcode: u8, data: Bytes) -> Result<(), LinkError>

Send a DIG-band body with no correlation id and no expected reply.

The payload is opaque to the link: framing an opcode says nothing about what its body means, which is precisely what lets the free band (220+) carry protocols this crate does not know about.

pub async fn send_message(&self, message: DigMessage) -> Result<(), LinkError>

Send a fully-formed message, preserving its id.

This is how an inbound request is answered: the reply must carry the requester’s id, which neither Self::send nor Self::send_dig can express. Rate-limit refusals are handled by kind, never by blanket retry: an over-budget message waits for the next window (up to LinkOptions::send_timeout), while a message that no window could ever admit fails immediately. Retrying the latter is an infinite loop with no error, which is how a caller silently disappears.

pub async fn request_raw<T>(&self, body: T) -> Result<DigMessage, LinkError>

where T: Streamable + ChiaProtocolMessage,

Send a Chia-typed body and await the correlated reply, unparsed.

pub async fn request_dig( &self, opcode: u8, data: Bytes, ) -> Result<DigMessage, LinkError>

Send a DIG-band body and await the correlated reply, unparsed.

pub async fn request_infallible<T, B>(&self, body: B) -> Result<T, LinkError>

where T: Streamable + ChiaProtocolMessage, B: Streamable + ChiaProtocolMessage,

Send a Chia-typed body and await a reply of exactly one expected type.

pub async fn request_fallible<T, E, B>( &self, body: B, ) -> Result<Result<T, E>, LinkError>

where T: Streamable + ChiaProtocolMessage, E: Streamable + ChiaProtocolMessage, B: Streamable + ChiaProtocolMessage,

Send a Chia-typed body and await either the expected reply or its rejection.

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

Close the connection.

Trait Implementations

impl Clone for DigLink

fn clone(&self) -> DigLink

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DigLink

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.