Struct ProtocolConfig 

pub struct ProtocolConfig {
    pub app_id: String,
    pub profile: String,
    pub transport: TransportConfig,
    pub dors: DorsConfig,
    pub relay: RelayConfig,
    pub mesh_relay: MeshRelayConfig,
    pub reliability: ReliabilityConfig,
    pub encryption: EncryptionConfig,
    pub initial_ttl: u8,
    pub group: GroupConfig,
    pub security: SecurityConfig,
    pub data: DataConfig,
}

Main configuration for the Offline Protocol.

Fields

app_id: String

Application identifier (required).

profile: String

Local profile selector (required).

Selects which stored identity this instance runs as — one namespace per (app_id, profile) pair — so an app hosting several accounts gives each its own value, and an app hosting one can pass a constant like "default".

It is not the device’s identity. The wire identity is the self-certifying address derived from the identity key held in this profile’s storage: it is minted on first start, reported by crate::OfflineProtocol::local_address, and it is what gets stamped as Message.sender, what peers see as NeighborDiscovered.peer_id, and what others use as recipient. An app cannot choose it, because choosing it would mean claiming a key one does not hold.

Under any configuration that reaches the wire the profile stays local. The one exception is the explicit EncryptionConfig::require_encryption = false opt-out, which lets a plaintext send go out with MLS never initialized — no address has been derived at that point, so the frame carries the profile as its sender and the send emits crate::events::SecurityWarningCode::PlaintextSend. The default (require_encryption = true) fails such a send closed instead. Treat the profile as private if that opt-out is in use.

transport: TransportConfig

Transport configuration.

dors: DorsConfig

DORS (Dynamic Offline Relay Switch) configuration.

relay: RelayConfig

Relay management configuration: whether this device carries traffic for other people at all, and the battery floors under which it stops.

mesh_relay: MeshRelayConfig

How this device carries traffic for other people: how far frames travel, how many neighbors each is handed to, and the ceilings that keep forwarding from crowding the radio out.

Whether to forward is Self::relay’s decision; this is the shape of it once the answer is yes.

reliability: ReliabilityConfig

Reliability layer configuration.

encryption: EncryptionConfig

Encryption configuration for automatic MLS handling.

initial_ttl: u8

Initial TTL (Time-To-Live) for messages.

group: GroupConfig

Mesh group messaging configuration.

security: SecurityConfig

Security configuration for transport and control-message hardening.

data: DataConfig

Replicated-document data layer configuration.

Implementations

impl ProtocolConfig

pub fn new(app_id: impl Into<String>, profile: impl Into<String>) -> Self

Creates a new protocol configuration.

Arguments

• app_id - Application identifier
• profile - Local profile selector (storage namespace, never on the wire)

pub fn builder( app_id: impl Into<String>, profile: impl Into<String>, ) -> ProtocolConfigBuilder

Creates a builder for more granular configuration.

Examples found in repository

examples/replicated_notes.rs (line 83)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Both stores outlive the engine below, which is what makes the reopen at
    // the end a reopen rather than a fresh start. The secure store matters as
    // much as the record store: documents are sealed with a key that lives in
    // it, so dropping only that half looks exactly like data loss.
    let secure = Arc::new(InMemoryStorage::default());
    let records = Arc::new(MemoryStateStorage::default());

    // `data.enabled` defaults to true, so nothing here switches the layer on.
    let config = ProtocolConfig::builder("com.example.notes", "default").build()?;
    let mut protocol = OfflineProtocol::new(config)?;

    // Documents are sealed at rest and the record key is minted here, so this
    // call is the prerequisite for every method below.
    protocol.initialize_mls(secure.clone(), records.clone())?;

    // A space is an MLS scope: a peer's address for a 1:1 space, or the group
    // id for a group. Nothing replicates in this example, so the name only
    // has to be a valid one.
    let space = "demo-space";

    protocol.data_create_doc(space, "trip")?;

    // A map: last writer wins per key, and different keys never conflict.
    protocol.data_map_set(
        space,
        "trip",
        "meta",
        "title",
        DataValue::Text {
            value: "Coast road".to_string(),
        },
    )?;

    // A list: concurrent insertions both survive, in a deterministic order.
    for item in ["water", "map", "torch"] {
        protocol.data_list_push(
            space,
            "trip",
            "packing",
            DataValue::Text {
                value: item.to_string(),
            },
        )?;
    }

    // Text: character-level merge, so two people typing in one paragraph keep
    // both sets of words. Positions are character offsets, not byte offsets.
    protocol.data_text_insert(space, "trip", "notes", 0, "Meet at the bridge")?;

    // A counter: increments add up rather than overwriting each other.
    protocol.data_counter_increment(space, "trip", "opened", 1.0)?;

    // Edits batch before they reach storage. This is the call that makes them
    // durable, and `data_changed` fires after the same point, never before.
    protocol.data_flush(space, "trip")?;

    println!("spaces:    {:?}", protocol.data_list_spaces()?);
    println!("documents: {:?}", protocol.data_list_docs(space)?);
    println!(
        "compacted: {} bytes",
        protocol.data_doc_size(space, "trip")?
    );
    println!(
        "history:   {} bytes",
        protocol.data_export_raw(space, "trip")?.len()
    );
    println!("json:      {}", protocol.data_doc_json(space, "trip")?);

    // Both halves of the escape hatch are above: `data_doc_json` is the plain
    // JSON of the current state, `data_export_raw` the engine-native history.
    // An application can always take its data and leave.

    // Reopen: a new engine over the same two stores. The records were sealed
    // by the first one and are read back by the second, which is the property
    // an application depends on across a restart.
    drop(protocol);
    let config = ProtocolConfig::builder("com.example.notes", "default").build()?;
    let mut reopened = OfflineProtocol::new(config)?;
    reopened.initialize_mls(secure, records)?;

    println!("after reopen");
    println!(
        "  title:   {:?}",
        reopened.data_map_get(space, "trip", "meta", "title")?
    );
    println!(
        "  packing: {}",
        reopened.data_list_len(space, "trip", "packing")?
    );
    println!(
        "  notes:   {:?}",
        reopened.data_text_value(space, "trip", "notes")?
    );
    println!(
        "  opened:  {}",
        reopened.data_counter_value(space, "trip", "opened")?
    );

    Ok(())
}

pub fn validate(&self) -> Result<()>

Validates the configuration.

Returns

Returns Ok(()) if valid, Err with a description of the problem if invalid.

Trait Implementations

impl Clone for ProtocolConfig

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 ProtocolConfig

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

Formats the value using the given formatter.