Struct RemoteClient 

pub struct RemoteClient { /* private fields */ }

Remote client for connecting to a user-client through a proxy

Implementations

impl RemoteClient

pub async fn new( identity_provider: Box<dyn IdentityProvider>, session_store: Box<dyn SessionStore>, event_tx: Sender<RemoteClientEvent>, response_rx: Receiver<RemoteClientResponse>, proxy_client: Box<dyn ProxyClient>, ) -> Result<Self, RemoteClientError>

Create a new remote client and connect to the proxy server

This establishes the WebSocket connection and authenticates with the proxy. After calling this, use one of the pairing methods:

• pair_with_handshake() for new rendezvous-based pairing
• pair_with_psk() for PSK-based pairing
• load_cached_session() for reconnecting with a cached session

Arguments

• identity_provider - Provider for the client’s identity
• session_store - Store for caching sessions
• event_tx - Channel sender for client events
• response_rx - Channel receiver for client responses
• proxy_client - The proxy client implementation to use for communication

pub async fn pair_with_handshake( &mut self, rendezvous_code: &str, verify_fingerprint: bool, ) -> Result<IdentityFingerprint, RemoteClientError>

Pair with a remote device using a rendezvous code

This resolves the rendezvous code to a fingerprint, performs the Noise handshake, and optionally waits for user fingerprint verification.

Arguments

• rendezvous_code - The rendezvous code to resolve
• verify_fingerprint - If true, emit fingerprint event and wait for user verification. If false, emit fingerprint event informationally and proceed immediately.

pub async fn pair_with_psk( &mut self, psk: Psk, remote_fingerprint: IdentityFingerprint, ) -> Result<(), RemoteClientError>

Pair with a remote device using a pre-shared key

This uses the PSK for authentication, skipping fingerprint verification since trust is established through the PSK.

pub async fn load_cached_session( &mut self, remote_fingerprint: IdentityFingerprint, ) -> Result<(), RemoteClientError>

Reconnect to a remote device using a cached session

This verifies the session exists in the session store and reconnects without requiring fingerprint verification.

pub async fn request_credential( &mut self, query: &CredentialQuery, ) -> Result<CredentialData, RemoteClientError>

Request a credential over the secure channel

pub fn is_ready(&self) -> bool

Check if the secure channel is established

pub async fn close(&mut self)

Close the connection

pub fn session_store(&self) -> &dyn SessionStore

Get the session store for management operations

pub fn session_store_mut(&mut self) -> &mut dyn SessionStore

Get a mutable reference to the session store