Struct ProtocolConfigBuilder 

pub struct ProtocolConfigBuilder { /* private fields */ }

Builder for ProtocolConfig with a fluent API.

Implementations

impl ProtocolConfigBuilder

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

Creates a new builder.

pub fn transport(self, config: TransportConfig) -> Self

Configures transports.

pub fn ble_enabled(self, enabled: bool) -> Self

Enables or disables BLE transport.

pub fn wifi_direct_enabled(self, enabled: bool) -> Self

Enables or disables Wi-Fi Direct transport.

pub fn internet_enabled(self, enabled: bool) -> Self

Enables or disables Internet transport.

pub fn nostr_enabled(self, enabled: bool) -> Self

Enables or disables Nostr relay transport.

pub fn nostr_sealing_enabled(self, enabled: bool) -> Self

Enables or disables sealing of outgoing Nostr frames (default on).

pub fn nostr_username_discovery_enabled(self, enabled: bool) -> Self

Enables username discovery publication and resolution (default off; see TransportConfig::nostr_username_discovery_enabled).

pub fn nostr_cold_contact_enabled(self, enabled: bool) -> Self

Enables or disables Nostr key-package publication and peer resolution (default on; see TransportConfig::nostr_cold_contact_enabled).

pub fn dors(self, config: DorsConfig) -> Self

Configures DORS (Dynamic Offline Relay Switch).

pub fn online_first(self, enabled: bool) -> Self

Enables online-first mode (prefer Internet when available).

pub fn relay(self, config: RelayConfig) -> Self

Configures relay management.

pub fn mesh_relay(self, config: MeshRelayConfig) -> Self

Configures how traffic is carried for other people.

pub fn reliability(self, config: ReliabilityConfig) -> Self

Configures reliability layer.

pub fn initial_ttl(self, ttl: u8) -> Self

Sets the initial TTL for messages.

pub fn encryption(self, config: EncryptionConfig) -> Self

Configures encryption settings.

pub fn encryption_enabled(self, enabled: bool) -> Self

Enables or disables automatic encryption.

pub fn auto_key_exchange(self, enabled: bool) -> Self

Enables or disables automatic key exchange on peer discovery.

pub fn store_pending_messages(self, enabled: bool) -> Self

Enables or disables storing pending messages for later encryption.

pub fn require_encryption(self, required: bool) -> Self

Enables or disables strict encryption requirement.

pub fn pending_queue(self, config: PendingQueueConfig) -> Self

Configures pending encrypted message queue bounds and overflow behavior.

pub fn group(self, config: GroupConfig) -> Self

Configures group messaging settings.

pub fn max_group_members(self, max: usize) -> Self

Sets the maximum number of members allowed in a single group.

pub fn group_relay_enabled(self, enabled: bool) -> Self

Sets whether groups should attempt relay server registration.

pub fn group_relay_broadcast_enabled(self, enabled: bool) -> Self

Sets whether relay-synced groups may send via a single relay broadcast instead of per-member fan-out. See GroupConfig::relay_broadcast_enabled — on by default, but only ever taken against a relay that advertised the group_delivery_v3 capability, whose settled, address-space delivery report gives the broadcast a per-recipient delivery contract.

pub fn group_enforce_admin_commits(self, enabled: bool) -> Self

Sets whether unauthorized MLS membership commits are refused rather than applied-and-reported. See GroupConfig::enforce_admin_commits — off by default, and enabling it risks permanently forking members whose admin overlay disagrees.

pub fn security(self, config: SecurityConfig) -> Self

Configures security settings.

pub fn require_transport_identity(self, required: bool) -> Self

Sets whether transport identity is required for control messages.

pub fn data(self, config: DataConfig) -> Self

Configures the replicated-document data layer.

pub fn data_enabled(self, enabled: bool) -> Self

Sets whether the data layer accepts work. See DataConfig::enabled.

pub fn data_storage(self, storage: Arc<dyn ProtocolStateStorage>) -> Self

Points documents at a storage backend of the application’s choosing.

The whole bring-your-own-backend path, in one call. See DataConfig::storage, including what it means for logout.

pub fn custody(self, config: CustodyConfig) -> Self

Configures custody: whether this device holds a neighbour’s replication frames, and under what quotas. See CustodyConfig.

pub fn build(self) -> Result<ProtocolConfig>

Builds and validates the configuration.

Returns

Returns Ok(ProtocolConfig) if valid, Err otherwise.

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(())
}