Struct TransportConfig 

pub struct TransportConfig {
    pub ble_enabled: bool,
    pub wifi_direct_enabled: bool,
    pub internet_enabled: bool,
    pub reticulum_enabled: bool,
    pub nostr_enabled: bool,
    pub nostr_sealing_enabled: bool,
    pub nostr_cold_contact_enabled: bool,
    pub nostr_username_discovery_enabled: bool,
    pub binary_wire_enabled: bool,
}

Transport-specific configuration.

Fields

ble_enabled: bool

Whether BLE transport is enabled.

wifi_direct_enabled: bool

Whether Wi-Fi Direct transport is enabled.

internet_enabled: bool

Whether Internet transport is enabled.

reticulum_enabled: bool

Whether Reticulum mesh transport is enabled. Defaults to false because Reticulum requires external infrastructure (a running Reticulum daemon or RNode hardware).

nostr_enabled: bool

Whether Nostr relay transport is enabled. Defaults to false because Nostr requires relay configuration and a secp256k1 keypair.

nostr_sealing_enabled: bool

Whether outgoing Nostr frames are sealed into NIP-59 gift wraps.

Defaults to true. With it off, the transport publishes the legacy kind-4 event whose content is the whole protocol envelope in cleartext — both usernames, the app id, the metadata map, the content type and a millisecond timestamp, readable by every relay, permanently. Turn it off only to interoperate with a relay that rejects kind 1059 outright.

Send-side only, and never negotiated: inbound gift wraps are always unsealed and inbound legacy frames always parsed, so whatever this is set to, anything a peer sends us stays readable.

It does still affect outbound reachability, in the one direction the receive path cannot cover. A peer on a build that predates sealing subscribes with kinds: [4] only, so it is never handed our kind-1059 events and has no NIP-44 layer to open one with — leaving it on makes such a peer unreachable over Nostr (visibly: no ACK returns, so the send fails through the retry ladder rather than vanishing). That is the second reason to turn this off, alongside a relay that rejects kind 1059.

nostr_cold_contact_enabled: bool

Whether this install publishes MLS key packages to the relays and resolves peers’ published packages.

Defaults to true, and takes effect only when nostr_enabled is on — which is itself off by default, so nothing is published unless an app deliberately turns Nostr on.

Buys cold first contact: a peer known only by username becomes reachable over Nostr with no prior key-package exchange over some other transport, which is otherwise impossible. It also bounds the sealing downgrade that follows a peer-key eviction, since a forgotten key is re-resolved on the next send instead of waiting for a fresh exchange.

What it costs is worth stating plainly. Publication is the first thing this SDK emits to a relay unprompted: a small set of addressable records sits at this install’s routing tag and is refreshed as slots are consumed, whether or not any message is ever sent. Their content is sealed — a scraper filtering on the kind alone reads nothing, which matters because an MLS key package carries its owner’s username in the leaf credential and cannot be stripped of it — but the existence of a record at a given tag, and the timing of its refreshes, are visible to every relay published to. Turn this off to keep the transport silent until it has traffic, at the price of cold contact.

nostr_username_discovery_enabled: bool

Whether this install publishes a username discovery record and can resolve usernames to the devices claiming them.

Defaults to false, unlike nostr_cold_contact_enabled, and gates publication and resolution together. It also requires cold contact: a discovery record points at an address whose key packages are what a resolver fetches next, so with cold contact off the claim resolves and then dead-ends one hop later. The two are hard-coupled in the transport rather than merely documented.

Buys back reach by username, which the addressing migration removed: a stranger who knows only a name can find the addresses claiming it and open a session. The name is published as the app’s configured profile, normalized to NFC and lowercase.

Default-off is the deliberate choice, and the reason is disclosure. Publishing binds a human-readable name to an address in a public place. That is materially more than the key-package record’s “an install with this tag exists”: the mapping is the payload. The record is sealed to a key derived from the username, so a relay scraping by kind alone reads nothing, but anyone who guesses the name can compute the tag, confirm a claim exists, and read it. That is the same class of exposure a public user directory has, and it is a decision an app should make explicitly.

What the directory is not: authoritative. Anyone may publish any claim at any name. Every record is a claim that some key asserts a name, and a resolution returns the whole set of claimants with their verification status. An app that silently picks the first result has converted a non-authoritative directory into an authoritative-looking one; the user must confirm out of band. See docs/spec/username-discovery.md.

binary_wire_enabled: bool

Whether to negotiate and emit the compact binary wire codec.

Defaults to true. It only takes effect between two peers that both advertise support (via their signed key package), so a mixed fleet automatically stays on JSON. Decoding of binary frames is always on, independent of this flag; this gates only advertising and emitting.

Trait Implementations

impl Clone for TransportConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransportConfig

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

Formats the value using the given formatter.

impl Default for TransportConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TransportConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TransportConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.