Struct SessionConfig 

pub struct SessionConfig {
    pub mnemonic: Mnemonic,
    pub network: NymNetworkDetails,
    pub credential_store_path: Option<PathBuf>,
    pub data_path: PathBuf,
    pub dvpn_directory_url: Option<String>,
    pub automatic_topups: Option<RestockPolicy>,
    pub bandwidth_provider: Option<Arc<dyn BandwidthTicketProvider>>,
    pub reuse_registrations: bool,
}

Configuration for creating a [Session].

Fields

mnemonic: Mnemonic

Funded chain mnemonic used to deposit NYM and issue ticketbooks. Ignored when bandwidth_provider is set.

network: NymNetworkDetails

Network to operate against (contract addresses, endpoints, denoms).

credential_store_path: Option<PathBuf>

Persistent credential store path. None uses a file under data_path (a fully ephemeral in-memory store is not used so tickets survive a bring-down/bring-up cycle).

data_path: PathBuf

Directory for the fetcher’s pending-request recovery database and other per-session data.

dvpn_directory_url: Option<String>

Optional dVPN gateway-directory URL. When set, the session fetches it to enrich gateway monikers and to enable QUIC-bridge entry selection (register_two_hop_quic). Fetched best-effort — a failure is logged and treated as an empty directory.

automatic_topups: Option<RestockPolicy>

Opt-in automatic chain-side restock. None (default) provisions once and never deposits in the background; the tunnel still tops up from already-stored tickets. Some(policy) lets a long-lived session re-issue ticketbooks when stock runs low (this spends NYM).

bandwidth_provider: Option<Arc<dyn BandwidthTicketProvider>>

Externally-managed bandwidth provider. When set, the session uses it for all ticket spending and does NOT spawn its own controller — for callers already running a controller over the same credential store (preserving the single-writer invariant). mnemonic and the credential store are then unused, and the caller is responsible for provisioning.

reuse_registrations: bool

Reuse persisted gateway registrations (default: true). A successful registration is stored under data_path (client WireGuard key + assigned configuration) and served back on later registrations against the same gateway/role — no gateway exchange, no ticket spent, resuming the peer’s remaining bandwidth allowance. Validate reused registrations by use (Tunnel::await_established) and fall back via crate::Session::invalidate_registration.

Privacy trade-off: reuse links this client’s connections to the same WireGuard peer identity at the gateway across sessions. Set to false for an unlinkable fresh peer per connection — every registration then spends a ticket, and nothing is persisted.

Implementations

impl SessionConfig

pub fn new( mnemonic: Mnemonic, network: NymNetworkDetails, data_path: PathBuf, ) -> Self

A config with the required fields and sensible defaults (no automatic topups, own controller).

pub fn with_automatic_topups(self, policy: RestockPolicy) -> Self

Opt into automatic chain-side restock with the given policy (this can spend NYM).

pub fn with_bandwidth_provider( self, provider: Arc<dyn BandwidthTicketProvider>, ) -> Self

Use an externally-managed bandwidth provider instead of spawning an own controller.

pub fn with_dvpn_directory_url(self, url: impl Into<String>) -> Self

Set the dVPN directory URL.

pub fn with_credential_store_path(self, path: impl Into<PathBuf>) -> Self

Set the credential store path.