Struct Session 

pub struct Session { /* private fields */ }

Provisioning facade over the credential + registration machinery.

Implementations

impl Session

pub async fn new( config: SessionConfig, cancel: CancellationToken, ) -> Result<Self, SessionError>

Build a session. Unless an external bandwidth_provider is supplied, this connects the signing chain client, opens the credential store, wires the bandwidth controller + credential fetcher (scoped to WireGuard ticket types), and spawns the controller event loop.

pub async fn ensure_ticketbooks( &self, two_hop: bool, ) -> Result<(), SessionError>

Ensure the WireGuard ticketbooks needed for the tunnel shape are stored, issuing (and depositing) only when no usable ticketbook of a required type is already stored.

With an external bandwidth provider this is a no-op — the caller provisions.

pub async fn obtain_wireguard_credential( &self, gateway_id: PublicKey, role: WgRole, ) -> Result<BandwidthCredential, SessionError>

Obtain a spendable bandwidth credential for gateway_id by spending one stored WireGuard ticket. Feeds the gateway metadata endpoint’s topup_bandwidth so a long-lived tunnel can extend its bandwidth.

pub fn bandwidth_provider(&self) -> Arc<dyn BandwidthTicketProvider>

The bandwidth provider used for ticket spending. Hand this to the datapath so a live tunnel can top up from stored tickets.

pub async fn select_gateway( &self, spec: &GatewaySpec, role: WgRole, ) -> Result<SelectedGateway, SessionError>

Select a WireGuard-capable gateway for the given role (fetches topology).

pub async fn register_single_hop( &self, gateway: &GatewaySpec, ) -> Result<Registration, SessionError>

Register a single-hop tunnel against one gateway via the LP single-gateway register_dvpn path (spends a V1WireguardEntry ticket).

pub fn invalidate_registration(&self, gateway: &PublicKey, role: WgRole)

Remove a cached registration for (gateway, role) — the fallback path when a reused registration fails to establish (see Tunnel::await_established in smoldvpn): invalidate the failed hop(s), then register again for a fresh (ticket-spending) peer. A missing entry (or reuse disabled) is a no-op.

pub async fn register_two_hop( &self, entry: &GatewaySpec, exit: &GatewaySpec, ) -> Result<Registration, SessionError>

Register a two-hop tunnel: an outer LP session with the entry gateway, the exit registered via entry forwarding, then the entry itself.

pub async fn register_two_hop_quic( &self, entry: &GatewaySpec, exit: &GatewaySpec, ) -> Result<Registration, SessionError>

Like register_two_hop, but the ENTRY gateway must advertise a QUIC bridge (per the configured dVPN directory). The returned entry hop carries its QuicBridge in bridge. Fails with SessionError::NoQuicGateway if no QUIC entry matches the spec. (QUIC only fronts the two-hop entry leg; the exit is registered normally.)

pub async fn shutdown(self)

Shut down the session’s bandwidth controller (if it owns one), awaiting its cleanup so the credential store is closed cleanly. Stored tickets are retained.

Trait Implementations

impl Drop for Session

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.