Struct OpenMlsService 

pub struct OpenMlsService<S: DeMlsStorage> { /* private fields */ }

OpenMLS-backed MLS service, scoped to a single conversation. Owns one MlsGroup plus an optional staged-commit slot for the inbound stage→merge/discard pipeline. Credentials are Arc<MlsCredentials> so one user’s keypair backs every per-conversation service.

Implementations

impl<S: DeMlsStorage> OpenMlsService<S>

pub fn new_as_creator( conversation_id: String, storage: S, credentials: Arc<MlsCredentials>, ) -> Result<Self, MlsError>

Create a fresh MLS group as the sole initial member (“creator”).

pub fn new_from_welcome( welcome_bytes: &[u8], storage: S, credentials: Arc<MlsCredentials>, ) -> Result<Option<Self>, MlsError>

Try to join a group from a serialized welcome.

Returns Ok(None) when the welcome doesn’t address one of our key packages — that’s the “not for us” branch, not an error. On Ok(Some(svc)) the caller has a fully initialized service for the group the welcome described.

pub fn generate_key_package( storage: &S, credentials: &MlsCredentials, ) -> Result<KeyPackageBytes, MlsError>

Generate a single-use key package for credentials backed by storage.

Takes only storage + credentials rather than &self, so a joiner can publish a key package before any MLS group has been created. The resulting hash ref is registered in storage so a later new_from_welcome can identify the welcome as “for us”.

Trait Implementations

impl<S> MlsService for OpenMlsService<S>

where S: DeMlsStorage,

fn conversation_id(&self) -> &str

The conversation id this service is scoped to.

fn delete(&mut self) -> Result<(), MlsError>

Tear down all local MLS state for this conversation. Idempotent so repeated leave / cleanup is safe.

fn members(&self) -> Result<Vec<Vec<u8>>, MlsError>

Current conversation members as serialized credential bytes (one entry per leaf, in MLS leaf order).

fn is_member(&self, identity: &[u8]) -> bool

Whether identity is currently a member.

fn current_epoch(&self) -> Result<u64, MlsError>

Current MLS epoch. This is the single source of truth — never maintain a parallel counter at the app layer.

fn create_commit_candidate( &mut self, updates: &[MlsCommitInput], ) -> Result<CommitCandidate, MlsError>

Build a commit candidate from a list of membership changes and stage it locally. Returns the wire bytes (proposals + commit + an optional welcome) for the steward to broadcast.

fn merge_own_commit(&mut self) -> Result<(), MlsError>

Apply our pending commit, advancing the MLS epoch. Call after a successful create_commit_candidate when our candidate has won the freeze round.

fn discard_own_commit(&mut self) -> Result<(), MlsError>

Roll back the local side effects of create_commit_candidate: drop the pending commit and the pending proposals it contained.

fn stage_remote_commit( &mut self, proposals: &[Vec<u8>], commit_bytes: &[u8], ) -> Result<StagedCandidateResult, MlsError>

Validate and stage a remote commit candidate atomically: each proposal is processed and stored as MLS-pending, then the commit is processed against that pending set, producing a staged commit held internally.

fn merge_staged_commit(&mut self) -> Result<(), MlsError>

Apply the previously staged inbound commit, advancing the MLS epoch. Errors if no commit is staged.

fn discard_staged_commit(&mut self) -> Result<(), MlsError>

Roll back stage_remote_commit: drop the staged commit and clear the pending proposals it staged on top of.

fn encrypt(&mut self, plaintext: &[u8]) -> Result<Vec<u8>, MlsError>

Encrypt an application message for the conversation, returning the raw MLS wire bytes.

fn build_message( &mut self, app_msg: &AppMessage, app_id: &[u8], ) -> Result<OutboundPacket, MlsError>

Encode and encrypt app_msg and wrap the result as an OutboundPacket on the application subtopic. The convenience path most senders use.

fn decrypt_application_only( &mut self, ciphertext: &[u8], ) -> Result<DecryptResult, MlsError>

Strict app-subtopic decrypt: accepts only Application messages, silently ignoring anything else (including proposals and commits). This guards the app subtopic against MLS-state pollution from peers that misroute control messages.

fn decrypt(&mut self, ciphertext: &[u8]) -> Result<DecryptResult, MlsError>

General decrypt: accepts Application messages and stores incoming proposals as pending. Commits are out of scope here — route them through stage_remote_commit so they pass the validation pipeline.

fn inspect_message_kind( &self, message_bytes: &[u8], ) -> Result<MlsMessageKind, MlsError>

Peek the untrusted outer kind of an MLS wire message without processing or signature-checking it. Used for cheap pre-dispatch lane checks (e.g. “is this a proposal or a commit”).

fn commit_batch_max(&self) -> usize

Maximum number of MLS proposals the steward will pack into one commit batch. Defaults to DEFAULT_COMMIT_BATCH_MAX; impls may override per-instance.