Struct mls_rs::external_client::builder::ExternalClientBuilder

pub struct ExternalClientBuilder<C>(/* private fields */);

Available on crate feature external_client only.

Builder for ExternalClient

This is returned by ExternalClient::builder and allows to tweak settings the ExternalClient will use. At a minimum, the builder must be told the CryptoProvider and IdentityProvider to use. Other settings have default values. This means that the following methods must be called before ExternalClientBuilder::build:

• To specify the CryptoProvider: ExternalClientBuilder::crypto_provider
• To specify the IdentityProvider: ExternalClientBuilder::identity_provider

Example

use mls_rs::{
    external_client::ExternalClient,
    identity::basic::BasicIdentityProvider,
};

use mls_rs_crypto_openssl::OpensslCryptoProvider;

let _client = ExternalClient::builder()
    .crypto_provider(OpensslCryptoProvider::default())
    .identity_provider(BasicIdentityProvider::new())
    .build();

Spelling out an ExternalClient type

There are two main ways to spell out an ExternalClient type if needed (e.g. function return type).

The first option uses impl MlsConfig:

use mls_rs::{
    external_client::{ExternalClient, builder::MlsConfig},
    identity::basic::BasicIdentityProvider,
};

use mls_rs_crypto_openssl::OpensslCryptoProvider;

fn make_client() -> ExternalClient<impl MlsConfig> {
    ExternalClient::builder()
        .crypto_provider(OpensslCryptoProvider::default())
        .identity_provider(BasicIdentityProvider::new())
        .build()
}

The second option is more verbose and consists in writing the full ExternalClient type:

use mls_rs::{
    external_client::{ExternalClient, builder::{ExternalBaseConfig, WithIdentityProvider, WithCryptoProvider}},
    identity::basic::BasicIdentityProvider,
};

use mls_rs_crypto_openssl::OpensslCryptoProvider;

type MlsClient = ExternalClient<WithIdentityProvider<
    BasicIdentityProvider,
    WithCryptoProvider<OpensslCryptoProvider, ExternalBaseConfig>,
>>;

fn make_client_2() -> MlsClient {
    ExternalClient::builder()
        .crypto_provider(OpensslCryptoProvider::new())
        .identity_provider(BasicIdentityProvider::new())
        .build()
}

Implementations

impl ExternalClientBuilder<ExternalBaseConfig>

pub fn new() -> Self

impl<C: IntoConfig> ExternalClientBuilder<C>

pub fn extension_type( self, type_: ExtensionType, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

Add an extension type to the list of extension types supported by the client.

pub fn extension_types<I>( self, types: I, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

where I: IntoIterator<Item = ExtensionType>,

Add multiple extension types to the list of extension types supported by the client.

pub fn custom_proposal_type( self, type_: ProposalType, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

Add a custom proposal type to the list of proposals types supported by the client.

pub fn custom_proposal_types<I>( self, types: I, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

where I: IntoIterator<Item = ProposalType>,

Add multiple custom proposal types to the list of proposal types supported by the client.

pub fn protocol_version( self, version: ProtocolVersion, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

Add a protocol version to the list of protocol versions supported by the client.

If no protocol version is explicitly added, the client will support all protocol versions supported by this crate.

pub fn protocol_versions<I>( self, versions: I, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

where I: IntoIterator<Item = ProtocolVersion>,

Add multiple protocol versions to the list of protocol versions supported by the client.

If no protocol version is explicitly added, the client will support all protocol versions supported by this crate.

pub fn external_signing_key( self, id: Vec<u8>, key: SignaturePublicKey, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

Add an external signing key to be used by the client.

pub fn max_epoch_jitter( self, max_jitter: u64, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

Specify the number of epochs before the current one to keep.

By default, all epochs are kept.

pub fn cache_proposals( self, cache_proposals: bool, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

Specify whether processed proposals should be cached by the external group. In case they are not cached by the group, they should be cached externally and inserted using ExternalGroup::insert_proposal before processing the next commit.

pub fn identity_provider<I>( self, identity_provider: I, ) -> ExternalClientBuilder<WithIdentityProvider<I, C>>

where I: IdentityProvider,

Set the identity validator to be used by the client.

pub fn crypto_provider<Cp>( self, crypto_provider: Cp, ) -> ExternalClientBuilder<WithCryptoProvider<Cp, C>>

where Cp: CryptoProvider,

Set the crypto provider to be used by the client.

pub fn mls_rules<Pr>( self, mls_rules: Pr, ) -> ExternalClientBuilder<WithMlsRules<Pr, C>>

where Pr: MlsRules,

Set the user-defined proposal rules to be used by the client.

User-defined rules are used when sending and receiving commits before enforcing general MLS protocol rules. If the rule set returns an error when receiving a commit, the entire commit is considered invalid. If the rule set would return an error when sending a commit, individual proposals may be filtered out to compensate.

pub fn signer( self, signer: SignatureSecretKey, signing_identity: SigningIdentity, ) -> ExternalClientBuilder<IntoConfigOutput<C>>

Set the signature secret key used by the client to send external proposals.

impl<C: IntoConfig> ExternalClientBuilder<C>

where C::IdentityProvider: IdentityProvider + Clone, C::MlsRules: MlsRules + Clone, C::CryptoProvider: CryptoProvider + Clone,

pub fn build(self) -> ExternalClient<IntoConfigOutput<C>>

Build an external client.

See ExternalClientBuilder documentation if the return type of this function needs to be spelled out.

Trait Implementations

impl<C: Debug> Debug for ExternalClientBuilder<C>

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

Formats the value using the given formatter.

impl Default for ExternalClientBuilder<ExternalBaseConfig>

fn default() -> Self

Returns the “default value” for a type.