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,
    pub custody: CustodyConfig,
}

Main configuration for the Offline Protocol.

Fields

app_id: String

Application identifier (required).

Two jobs. It is one of the two inputs to the storage namespace, with Self::profile, so changing it selects fresh storage and a fresh identity. And it is the id stamped on every frame this instance originates: messages, media chunks, acknowledgements and control traffic. A rich send may name another id for its own frame (crate::SendMessageOptions::app_id), which is how one instance serves several local applications behind one identity; the acknowledgements and control frames the engine sends always carry this one. The bindings also derive the BLE app tag from it.

It is cleartext on the wire and covered by no signature, so every carrier and hop can read it and rewrite it (threat model R17). It names an application, so it is not secret, but treat it as routing metadata only: the receive path delivers a message whatever id it carries.

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.

custody: CustodyConfig

Custody: holding a neighbour’s replication frames for hours. Off by default; see CustodyConfig.

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>> {
    let root = match std::env::args_os().nth(1) {
        Some(root) => PathBuf::from(root),
        None => {
            let mut suffix = [0u8; 8];
            OsRng.fill_bytes(&mut suffix);
            std::env::temp_dir().join(format!("replicated-notes-{}", hex::encode(suffix)))
        }
    };
    let key: Box<dyn StoreKeyProvider> =
        if std::env::var_os(EnvStoreKey::DEFAULT_VARIABLE).is_some() {
            Box::new(EnvStoreKey::default())
        } else {
            let mut key = [0u8; 32];
            OsRng.fill_bytes(&mut key);
            Box::new(StaticStoreKey::new(key))
        };
    println!("stores:    {}", root.display());

    // Both stores are on disk, 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
    // losing only that half looks exactly like data loss.
    let (secure, records) = open_stores(&root, key.as_ref())?;

    // `data.enabled` defaults to true, so nothing here switches the layer on.
    let config = ProtocolConfig::builder(APP_ID, PROFILE).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 directories, opened afresh as a
    // restarted process would. The records were sealed by the first engine
    // and are read back by the second, which is the property an application
    // depends on across a restart.
    drop(protocol);
    drop((secure, records));
    let (secure, records) = open_stores(&root, key.as_ref())?;
    let config = ProtocolConfig::builder(APP_ID, PROFILE).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.