Trait StorageProviderTrait 

pub trait StorageProviderTrait<const VERSION: u16> {
    type Error: Debug + Error;

    // Required methods
    fn write_mls_join_config<GroupId, MlsGroupJoinConfig>(
        &self,
        group_id: &GroupId,
        config: &MlsGroupJoinConfig,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             MlsGroupJoinConfig: MlsGroupJoinConfig<VERSION>;
    fn append_own_leaf_node<GroupId, LeafNode>(
        &self,
        group_id: &GroupId,
        leaf_node: &LeafNode,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             LeafNode: LeafNode<VERSION>;
    fn queue_proposal<GroupId, ProposalRef, QueuedProposal>(
        &self,
        group_id: &GroupId,
        proposal_ref: &ProposalRef,
        proposal: &QueuedProposal,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             ProposalRef: ProposalRef<VERSION>,
             QueuedProposal: QueuedProposal<VERSION>;
    fn write_tree<GroupId, TreeSync>(
        &self,
        group_id: &GroupId,
        tree: &TreeSync,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             TreeSync: TreeSync<VERSION>;
    fn write_interim_transcript_hash<GroupId, InterimTranscriptHash>(
        &self,
        group_id: &GroupId,
        interim_transcript_hash: &InterimTranscriptHash,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             InterimTranscriptHash: InterimTranscriptHash<VERSION>;
    fn write_context<GroupId, GroupContext>(
        &self,
        group_id: &GroupId,
        group_context: &GroupContext,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             GroupContext: GroupContext<VERSION>;
    fn write_confirmation_tag<GroupId, ConfirmationTag>(
        &self,
        group_id: &GroupId,
        confirmation_tag: &ConfirmationTag,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             ConfirmationTag: ConfirmationTag<VERSION>;
    fn write_group_state<GroupState, GroupId>(
        &self,
        group_id: &GroupId,
        group_state: &GroupState,
    ) -> Result<(), Self::Error>
       where GroupState: GroupState<VERSION>,
             GroupId: GroupId<VERSION>;
    fn write_message_secrets<GroupId, MessageSecrets>(
        &self,
        group_id: &GroupId,
        message_secrets: &MessageSecrets,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             MessageSecrets: MessageSecrets<VERSION>;
    fn write_resumption_psk_store<GroupId, ResumptionPskStore>(
        &self,
        group_id: &GroupId,
        resumption_psk_store: &ResumptionPskStore,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             ResumptionPskStore: ResumptionPskStore<VERSION>;
    fn write_own_leaf_index<GroupId, LeafNodeIndex>(
        &self,
        group_id: &GroupId,
        own_leaf_index: &LeafNodeIndex,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             LeafNodeIndex: LeafNodeIndex<VERSION>;
    fn write_group_epoch_secrets<GroupId, GroupEpochSecrets>(
        &self,
        group_id: &GroupId,
        group_epoch_secrets: &GroupEpochSecrets,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             GroupEpochSecrets: GroupEpochSecrets<VERSION>;
    fn write_application_export_tree<GroupId, ApplicationExportTree>(
        &self,
        group_id: &GroupId,
        application_export_tree: &ApplicationExportTree,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             ApplicationExportTree: ApplicationExportTree<VERSION>;
    fn write_signature_key_pair<SignaturePublicKey, SignatureKeyPair>(
        &self,
        public_key: &SignaturePublicKey,
        signature_key_pair: &SignatureKeyPair,
    ) -> Result<(), Self::Error>
       where SignaturePublicKey: SignaturePublicKey<VERSION>,
             SignatureKeyPair: SignatureKeyPair<VERSION>;
    fn write_encryption_key_pair<EncryptionKey, HpkeKeyPair>(
        &self,
        public_key: &EncryptionKey,
        key_pair: &HpkeKeyPair,
    ) -> Result<(), Self::Error>
       where EncryptionKey: EncryptionKey<VERSION>,
             HpkeKeyPair: HpkeKeyPair<VERSION>;
    fn write_encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>(
        &self,
        group_id: &GroupId,
        epoch: &EpochKey,
        leaf_index: u32,
        key_pairs: &[HpkeKeyPair],
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             EpochKey: EpochKey<VERSION>,
             HpkeKeyPair: HpkeKeyPair<VERSION>;
    fn write_key_package<HashReference, KeyPackage>(
        &self,
        hash_ref: &HashReference,
        key_package: &KeyPackage,
    ) -> Result<(), Self::Error>
       where HashReference: HashReference<VERSION>,
             KeyPackage: KeyPackage<VERSION>;
    fn write_psk<PskId, PskBundle>(
        &self,
        psk_id: &PskId,
        psk: &PskBundle,
    ) -> Result<(), Self::Error>
       where PskId: PskId<VERSION>,
             PskBundle: PskBundle<VERSION>;
    fn mls_group_join_config<GroupId, MlsGroupJoinConfig>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<MlsGroupJoinConfig>, Self::Error>
       where GroupId: GroupId<VERSION>,
             MlsGroupJoinConfig: MlsGroupJoinConfig<VERSION>;
    fn own_leaf_nodes<GroupId, LeafNode>(
        &self,
        group_id: &GroupId,
    ) -> Result<Vec<LeafNode>, Self::Error>
       where GroupId: GroupId<VERSION>,
             LeafNode: LeafNode<VERSION>;
    fn queued_proposal_refs<GroupId, ProposalRef>(
        &self,
        group_id: &GroupId,
    ) -> Result<Vec<ProposalRef>, Self::Error>
       where GroupId: GroupId<VERSION>,
             ProposalRef: ProposalRef<VERSION>;
    fn queued_proposals<GroupId, ProposalRef, QueuedProposal>(
        &self,
        group_id: &GroupId,
    ) -> Result<Vec<(ProposalRef, QueuedProposal)>, Self::Error>
       where GroupId: GroupId<VERSION>,
             ProposalRef: ProposalRef<VERSION>,
             QueuedProposal: QueuedProposal<VERSION>;
    fn tree<GroupId, TreeSync>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<TreeSync>, Self::Error>
       where GroupId: GroupId<VERSION>,
             TreeSync: TreeSync<VERSION>;
    fn group_context<GroupId, GroupContext>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<GroupContext>, Self::Error>
       where GroupId: GroupId<VERSION>,
             GroupContext: GroupContext<VERSION>;
    fn interim_transcript_hash<GroupId, InterimTranscriptHash>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<InterimTranscriptHash>, Self::Error>
       where GroupId: GroupId<VERSION>,
             InterimTranscriptHash: InterimTranscriptHash<VERSION>;
    fn confirmation_tag<GroupId, ConfirmationTag>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<ConfirmationTag>, Self::Error>
       where GroupId: GroupId<VERSION>,
             ConfirmationTag: ConfirmationTag<VERSION>;
    fn group_state<GroupState, GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<GroupState>, Self::Error>
       where GroupState: GroupState<VERSION>,
             GroupId: GroupId<VERSION>;
    fn message_secrets<GroupId, MessageSecrets>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<MessageSecrets>, Self::Error>
       where GroupId: GroupId<VERSION>,
             MessageSecrets: MessageSecrets<VERSION>;
    fn resumption_psk_store<GroupId, ResumptionPskStore>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<ResumptionPskStore>, Self::Error>
       where GroupId: GroupId<VERSION>,
             ResumptionPskStore: ResumptionPskStore<VERSION>;
    fn own_leaf_index<GroupId, LeafNodeIndex>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<LeafNodeIndex>, Self::Error>
       where GroupId: GroupId<VERSION>,
             LeafNodeIndex: LeafNodeIndex<VERSION>;
    fn group_epoch_secrets<GroupId, GroupEpochSecrets>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<GroupEpochSecrets>, Self::Error>
       where GroupId: GroupId<VERSION>,
             GroupEpochSecrets: GroupEpochSecrets<VERSION>;
    fn signature_key_pair<SignaturePublicKey, SignatureKeyPair>(
        &self,
        public_key: &SignaturePublicKey,
    ) -> Result<Option<SignatureKeyPair>, Self::Error>
       where SignaturePublicKey: SignaturePublicKey<VERSION>,
             SignatureKeyPair: SignatureKeyPair<VERSION>;
    fn encryption_key_pair<HpkeKeyPair, EncryptionKey>(
        &self,
        public_key: &EncryptionKey,
    ) -> Result<Option<HpkeKeyPair>, Self::Error>
       where HpkeKeyPair: HpkeKeyPair<VERSION>,
             EncryptionKey: EncryptionKey<VERSION>;
    fn encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>(
        &self,
        group_id: &GroupId,
        epoch: &EpochKey,
        leaf_index: u32,
    ) -> Result<Vec<HpkeKeyPair>, Self::Error>
       where GroupId: GroupId<VERSION>,
             EpochKey: EpochKey<VERSION>,
             HpkeKeyPair: HpkeKeyPair<VERSION>;
    fn key_package<KeyPackageRef, KeyPackage>(
        &self,
        hash_ref: &KeyPackageRef,
    ) -> Result<Option<KeyPackage>, Self::Error>
       where KeyPackageRef: HashReference<VERSION>,
             KeyPackage: KeyPackage<VERSION>;
    fn psk<PskBundle, PskId>(
        &self,
        psk_id: &PskId,
    ) -> Result<Option<PskBundle>, Self::Error>
       where PskBundle: PskBundle<VERSION>,
             PskId: PskId<VERSION>;
    fn application_export_tree<GroupId, ApplicationExportTree>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<ApplicationExportTree>, Self::Error>
       where GroupId: GroupId<VERSION>,
             ApplicationExportTree: ApplicationExportTree<VERSION>;
    fn remove_proposal<GroupId, ProposalRef>(
        &self,
        group_id: &GroupId,
        proposal_ref: &ProposalRef,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             ProposalRef: ProposalRef<VERSION>;
    fn delete_own_leaf_nodes<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_group_config<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_tree<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_confirmation_tag<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_group_state<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_context<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_interim_transcript_hash<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_message_secrets<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_all_resumption_psk_secrets<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_own_leaf_index<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_group_epoch_secrets<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn clear_proposal_queue<GroupId, ProposalRef>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             ProposalRef: ProposalRef<VERSION>;
    fn delete_signature_key_pair<SignaturePublicKey>(
        &self,
        public_key: &SignaturePublicKey,
    ) -> Result<(), Self::Error>
       where SignaturePublicKey: SignaturePublicKey<VERSION>;
    fn delete_encryption_key_pair<EncryptionKey>(
        &self,
        public_key: &EncryptionKey,
    ) -> Result<(), Self::Error>
       where EncryptionKey: EncryptionKey<VERSION>;
    fn delete_encryption_epoch_key_pairs<GroupId, EpochKey>(
        &self,
        group_id: &GroupId,
        epoch: &EpochKey,
        leaf_index: u32,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             EpochKey: EpochKey<VERSION>;
    fn delete_key_package<KeyPackageRef>(
        &self,
        hash_ref: &KeyPackageRef,
    ) -> Result<(), Self::Error>
       where KeyPackageRef: HashReference<VERSION>;
    fn delete_psk<PskKey>(&self, psk_id: &PskKey) -> Result<(), Self::Error>
       where PskKey: PskId<VERSION>;
    fn delete_application_export_tree<GroupId, ApplicationExportTree>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             ApplicationExportTree: ApplicationExportTree<VERSION>;

    // Provided method
    fn version() -> u16 { ... }
}

Available on (32-bit or 64-bit) and (crate features test-utils) only.

StorageProvider describes the storage backing OpenMLS and persists the state of OpenMLS groups.

The getters for individual values usually return a Result<Option<T>, E>, where Err(_) indicates that some sort of IO or internal error occurred, and Ok(None) indicates that no error occurred, but no value exists. Many getters for lists return a Result<Vec<T>, E>. In this case, if there was no error but the value doesn’t exist, an empty vector should be returned.

Any value that uses the group id as key is required by the group. Returning None or an error for any of them will cause a failure when loading a group.

More details can be taken from the comments on the respective method.

Required Associated Types

type Error: Debug + Error

An opaque error returned by all methods on this trait.

Required Methods

fn write_mls_join_config<GroupId, MlsGroupJoinConfig>( &self, group_id: &GroupId, config: &MlsGroupJoinConfig, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, MlsGroupJoinConfig: MlsGroupJoinConfig<VERSION>,

Writes the MlsGroupJoinConfig for the group with given id to storage

fn append_own_leaf_node<GroupId, LeafNode>( &self, group_id: &GroupId, leaf_node: &LeafNode, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, LeafNode: LeafNode<VERSION>,

Adds an own leaf node for the group with given id to storage

fn queue_proposal<GroupId, ProposalRef, QueuedProposal>( &self, group_id: &GroupId, proposal_ref: &ProposalRef, proposal: &QueuedProposal, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, ProposalRef: ProposalRef<VERSION>, QueuedProposal: QueuedProposal<VERSION>,

Enqueue a proposal.

A good way to implement this could be to add a proposal to a proposal store, indexed by the proposal reference, and adding the reference to a per-group proposal queue list.

fn write_tree<GroupId, TreeSync>( &self, group_id: &GroupId, tree: &TreeSync, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, TreeSync: TreeSync<VERSION>,

Write the TreeSync tree.

fn write_interim_transcript_hash<GroupId, InterimTranscriptHash>( &self, group_id: &GroupId, interim_transcript_hash: &InterimTranscriptHash, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, InterimTranscriptHash: InterimTranscriptHash<VERSION>,

Write the interim transcript hash.

fn write_context<GroupId, GroupContext>( &self, group_id: &GroupId, group_context: &GroupContext, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, GroupContext: GroupContext<VERSION>,

Write the group context.

fn write_confirmation_tag<GroupId, ConfirmationTag>( &self, group_id: &GroupId, confirmation_tag: &ConfirmationTag, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, ConfirmationTag: ConfirmationTag<VERSION>,

Write the confirmation tag.

fn write_group_state<GroupState, GroupId>( &self, group_id: &GroupId, group_state: &GroupState, ) -> Result<(), Self::Error>

where GroupState: GroupState<VERSION>, GroupId: GroupId<VERSION>,

Writes the MlsGroupState for group with given id.

fn write_message_secrets<GroupId, MessageSecrets>( &self, group_id: &GroupId, message_secrets: &MessageSecrets, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, MessageSecrets: MessageSecrets<VERSION>,

Writes the MessageSecretsStore for the group with the given id.

fn write_resumption_psk_store<GroupId, ResumptionPskStore>( &self, group_id: &GroupId, resumption_psk_store: &ResumptionPskStore, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, ResumptionPskStore: ResumptionPskStore<VERSION>,

Writes the ResumptionPskStore for the group with the given id.

fn write_own_leaf_index<GroupId, LeafNodeIndex>( &self, group_id: &GroupId, own_leaf_index: &LeafNodeIndex, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, LeafNodeIndex: LeafNodeIndex<VERSION>,

Writes the own leaf index inside the group for the group with the given id.

fn write_group_epoch_secrets<GroupId, GroupEpochSecrets>( &self, group_id: &GroupId, group_epoch_secrets: &GroupEpochSecrets, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, GroupEpochSecrets: GroupEpochSecrets<VERSION>,

Writes the GroupEpochSecrets for the group with the given id.

fn write_application_export_tree<GroupId, ApplicationExportTree>( &self, group_id: &GroupId, application_export_tree: &ApplicationExportTree, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, ApplicationExportTree: ApplicationExportTree<VERSION>,

Available on crate feature extensions-draft-08 only.

Write the ApplicationExportTree for the group with the given id.

fn write_signature_key_pair<SignaturePublicKey, SignatureKeyPair>( &self, public_key: &SignaturePublicKey, signature_key_pair: &SignatureKeyPair, ) -> Result<(), Self::Error>

where SignaturePublicKey: SignaturePublicKey<VERSION>, SignatureKeyPair: SignatureKeyPair<VERSION>,

Store a signature key.

The signature key pair is not known to OpenMLS. This may be used by the application

fn write_encryption_key_pair<EncryptionKey, HpkeKeyPair>( &self, public_key: &EncryptionKey, key_pair: &HpkeKeyPair, ) -> Result<(), Self::Error>

where EncryptionKey: EncryptionKey<VERSION>, HpkeKeyPair: HpkeKeyPair<VERSION>,

Store an HPKE encryption key pair. This includes the private and public key

This is only be used for encryption key pairs that are generated for update leaf nodes. All other encryption key pairs are stored as part of the key package or the epoch encryption key pairs.

fn write_encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>( &self, group_id: &GroupId, epoch: &EpochKey, leaf_index: u32, key_pairs: &[HpkeKeyPair], ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, EpochKey: EpochKey<VERSION>, HpkeKeyPair: HpkeKeyPair<VERSION>,

Store a list of HPKE encryption key pairs for a given epoch. This includes the private and public keys.

fn write_key_package<HashReference, KeyPackage>( &self, hash_ref: &HashReference, key_package: &KeyPackage, ) -> Result<(), Self::Error>

where HashReference: HashReference<VERSION>, KeyPackage: KeyPackage<VERSION>,

Store key packages.

Store a key package. This includes the private init key. The encryption key is stored separately with write_encryption_key_pair.

Note that it is recommended to store a list of the hash references as well in order to iterate over key packages. OpenMLS does not have a reference for them.

fn write_psk<PskId, PskBundle>( &self, psk_id: &PskId, psk: &PskBundle, ) -> Result<(), Self::Error>

where PskId: PskId<VERSION>, PskBundle: PskBundle<VERSION>,

Store a PSK.

This stores PSKs based on the PSK id.

PSKs are only read by OpenMLS. The application is responsible for managing and storing PSKs.

fn mls_group_join_config<GroupId, MlsGroupJoinConfig>( &self, group_id: &GroupId, ) -> Result<Option<MlsGroupJoinConfig>, Self::Error>

where GroupId: GroupId<VERSION>, MlsGroupJoinConfig: MlsGroupJoinConfig<VERSION>,

Returns the MlsGroupJoinConfig for the group with given id

fn own_leaf_nodes<GroupId, LeafNode>( &self, group_id: &GroupId, ) -> Result<Vec<LeafNode>, Self::Error>

where GroupId: GroupId<VERSION>, LeafNode: LeafNode<VERSION>,

Returns the own leaf nodes for the group with given id

fn queued_proposal_refs<GroupId, ProposalRef>( &self, group_id: &GroupId, ) -> Result<Vec<ProposalRef>, Self::Error>

where GroupId: GroupId<VERSION>, ProposalRef: ProposalRef<VERSION>,

Returns references of all queued proposals for the group with group id group_id, or an empty vector of none are stored.

fn queued_proposals<GroupId, ProposalRef, QueuedProposal>( &self, group_id: &GroupId, ) -> Result<Vec<(ProposalRef, QueuedProposal)>, Self::Error>

where GroupId: GroupId<VERSION>, ProposalRef: ProposalRef<VERSION>, QueuedProposal: QueuedProposal<VERSION>,

Returns all queued proposals for the group with group id group_id, or an empty vector of none are stored.

fn tree<GroupId, TreeSync>( &self, group_id: &GroupId, ) -> Result<Option<TreeSync>, Self::Error>

where GroupId: GroupId<VERSION>, TreeSync: TreeSync<VERSION>,

Returns the TreeSync tree for the group with group id group_id.

fn group_context<GroupId, GroupContext>( &self, group_id: &GroupId, ) -> Result<Option<GroupContext>, Self::Error>

where GroupId: GroupId<VERSION>, GroupContext: GroupContext<VERSION>,

Returns the group context for the group with group id group_id.

fn interim_transcript_hash<GroupId, InterimTranscriptHash>( &self, group_id: &GroupId, ) -> Result<Option<InterimTranscriptHash>, Self::Error>

where GroupId: GroupId<VERSION>, InterimTranscriptHash: InterimTranscriptHash<VERSION>,

Returns the interim transcript hash for the group with group id group_id.

fn confirmation_tag<GroupId, ConfirmationTag>( &self, group_id: &GroupId, ) -> Result<Option<ConfirmationTag>, Self::Error>

where GroupId: GroupId<VERSION>, ConfirmationTag: ConfirmationTag<VERSION>,

Returns the confirmation tag for the group with group id group_id.

fn group_state<GroupState, GroupId>( &self, group_id: &GroupId, ) -> Result<Option<GroupState>, Self::Error>

where GroupState: GroupState<VERSION>, GroupId: GroupId<VERSION>,

Returns the group state for the group with group id group_id.

fn message_secrets<GroupId, MessageSecrets>( &self, group_id: &GroupId, ) -> Result<Option<MessageSecrets>, Self::Error>

where GroupId: GroupId<VERSION>, MessageSecrets: MessageSecrets<VERSION>,

Returns the MessageSecretsStore for the group with the given id.

fn resumption_psk_store<GroupId, ResumptionPskStore>( &self, group_id: &GroupId, ) -> Result<Option<ResumptionPskStore>, Self::Error>

where GroupId: GroupId<VERSION>, ResumptionPskStore: ResumptionPskStore<VERSION>,

Returns the ResumptionPskStore for the group with the given id.

Returning None here is considered an error because the store is needed by OpenMLS when loading a group.

fn own_leaf_index<GroupId, LeafNodeIndex>( &self, group_id: &GroupId, ) -> Result<Option<LeafNodeIndex>, Self::Error>

where GroupId: GroupId<VERSION>, LeafNodeIndex: LeafNodeIndex<VERSION>,

Returns the own leaf index inside the group for the group with the given id.

fn group_epoch_secrets<GroupId, GroupEpochSecrets>( &self, group_id: &GroupId, ) -> Result<Option<GroupEpochSecrets>, Self::Error>

where GroupId: GroupId<VERSION>, GroupEpochSecrets: GroupEpochSecrets<VERSION>,

Returns the GroupEpochSecrets for the group with the given id.

fn signature_key_pair<SignaturePublicKey, SignatureKeyPair>( &self, public_key: &SignaturePublicKey, ) -> Result<Option<SignatureKeyPair>, Self::Error>

where SignaturePublicKey: SignaturePublicKey<VERSION>, SignatureKeyPair: SignatureKeyPair<VERSION>,

Get a signature key based on the public key.

The signature key pair is not known to OpenMLS. This may be used by the application

fn encryption_key_pair<HpkeKeyPair, EncryptionKey>( &self, public_key: &EncryptionKey, ) -> Result<Option<HpkeKeyPair>, Self::Error>

where HpkeKeyPair: HpkeKeyPair<VERSION>, EncryptionKey: EncryptionKey<VERSION>,

Get an HPKE encryption key pair based on the public key.

This is only be used for encryption key pairs that are generated for update leaf nodes. All other encryption key pairs are stored as part of the key package or the epoch encryption key pairs.

fn encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>( &self, group_id: &GroupId, epoch: &EpochKey, leaf_index: u32, ) -> Result<Vec<HpkeKeyPair>, Self::Error>

where GroupId: GroupId<VERSION>, EpochKey: EpochKey<VERSION>, HpkeKeyPair: HpkeKeyPair<VERSION>,

Get a list of HPKE encryption key pairs for a given epoch. This includes the private and public keys.

fn key_package<KeyPackageRef, KeyPackage>( &self, hash_ref: &KeyPackageRef, ) -> Result<Option<KeyPackage>, Self::Error>

where KeyPackageRef: HashReference<VERSION>, KeyPackage: KeyPackage<VERSION>,

Get a key package based on its hash reference.

fn psk<PskBundle, PskId>( &self, psk_id: &PskId, ) -> Result<Option<PskBundle>, Self::Error>

where PskBundle: PskBundle<VERSION>, PskId: PskId<VERSION>,

Get a PSK based on the PSK identifier.

fn application_export_tree<GroupId, ApplicationExportTree>( &self, group_id: &GroupId, ) -> Result<Option<ApplicationExportTree>, Self::Error>

where GroupId: GroupId<VERSION>, ApplicationExportTree: ApplicationExportTree<VERSION>,

Available on crate feature extensions-draft-08 only.

Get the application export tree for the group with the given id.

fn remove_proposal<GroupId, ProposalRef>( &self, group_id: &GroupId, proposal_ref: &ProposalRef, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, ProposalRef: ProposalRef<VERSION>,

Removes an individual proposal from the proposal queue of the group with the provided id

fn delete_own_leaf_nodes<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes own leaf nodes for the given id from storage

fn delete_group_config<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the MlsGroupJoinConfig for the given id from storage

fn delete_tree<GroupId>(&self, group_id: &GroupId) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the tree from storage

fn delete_confirmation_tag<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the confirmation tag from storage

fn delete_group_state<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the MlsGroupState for group with given id.

fn delete_context<GroupId>(&self, group_id: &GroupId) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the group context for the group with given id

fn delete_interim_transcript_hash<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the interim transcript hash for the group with given id

fn delete_message_secrets<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the MessageSecretsStore for the group with the given id.

fn delete_all_resumption_psk_secrets<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the ResumptionPskStore for the group with the given id.

fn delete_own_leaf_index<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the own leaf index inside the group for the group with the given id.

fn delete_group_epoch_secrets<GroupId>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>,

Deletes the GroupEpochSecrets for the group with the given id.

fn clear_proposal_queue<GroupId, ProposalRef>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, ProposalRef: ProposalRef<VERSION>,

Clear the proposal queue for the group with the given id.

fn delete_signature_key_pair<SignaturePublicKey>( &self, public_key: &SignaturePublicKey, ) -> Result<(), Self::Error>

where SignaturePublicKey: SignaturePublicKey<VERSION>,

Delete a signature key pair based on its public key

The signature key pair is not known to OpenMLS. This may be used by the application

fn delete_encryption_key_pair<EncryptionKey>( &self, public_key: &EncryptionKey, ) -> Result<(), Self::Error>

where EncryptionKey: EncryptionKey<VERSION>,

Delete an encryption key pair for a public key.

This is only be used for encryption key pairs that are generated for update leaf nodes. All other encryption key pairs are stored as part of the key package or the epoch encryption key pairs.

fn delete_encryption_epoch_key_pairs<GroupId, EpochKey>( &self, group_id: &GroupId, epoch: &EpochKey, leaf_index: u32, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, EpochKey: EpochKey<VERSION>,

Delete a list of HPKE encryption key pairs for a given epoch. This includes the private and public keys.

fn delete_key_package<KeyPackageRef>( &self, hash_ref: &KeyPackageRef, ) -> Result<(), Self::Error>

where KeyPackageRef: HashReference<VERSION>,

Delete a key package based on the hash reference.

This function only deletes the key package. The corresponding encryption keys must be deleted separately.

fn delete_psk<PskKey>(&self, psk_id: &PskKey) -> Result<(), Self::Error>

where PskKey: PskId<VERSION>,

Delete a PSK based on an identifier.

fn delete_application_export_tree<GroupId, ApplicationExportTree>( &self, group_id: &GroupId, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, ApplicationExportTree: ApplicationExportTree<VERSION>,

Available on crate feature extensions-draft-08 only.

Delete the application export tree for the group with the given id.

Provided Methods

fn version() -> u16

Get the version of this provider.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}> for MemoryStorage

type Error = MemoryStorageError

fn write_encryption_key_pair<EncryptionKey, HpkeKeyPair>( &self, public_key: &EncryptionKey, key_pair: &HpkeKeyPair, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EncryptionKey: EncryptionKey<openmls_memory_storage::::test_store::{impl#0}::write_encryption_key_pair::{constant#1}>, HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::test_store::{impl#0}::write_encryption_key_pair::{constant#2}>,

fn encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>( &self, group_id: &GroupId, epoch: &EpochKey, leaf_index: u32, ) -> Result<Vec<HpkeKeyPair>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::encryption_epoch_key_pairs::{constant#0}>, EpochKey: EpochKey<openmls_memory_storage::::test_store::{impl#0}::encryption_epoch_key_pairs::{constant#1}>, HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::test_store::{impl#0}::encryption_epoch_key_pairs::{constant#2}>,

fn key_package<KeyPackageRef, KeyPackage>( &self, hash_ref: &KeyPackageRef, ) -> Result<Option<KeyPackage>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where KeyPackageRef: HashReference<openmls_memory_storage::::test_store::{impl#0}::key_package::{constant#0}>, KeyPackage: KeyPackage<openmls_memory_storage::::test_store::{impl#0}::key_package::{constant#1}>,

fn write_key_package<HashReference, KeyPackage>( &self, hash_ref: &HashReference, key_package: &KeyPackage, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where HashReference: HashReference<openmls_memory_storage::::test_store::{impl#0}::write_key_package::{constant#1}>, KeyPackage: KeyPackage<openmls_memory_storage::::test_store::{impl#0}::write_key_package::{constant#2}>,

fn queue_proposal<GroupId, ProposalRef, QueuedProposal>( &self, _group_id: &GroupId, _proposal_ref: &ProposalRef, _proposal: &QueuedProposal, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::queue_proposal::{constant#0}>, ProposalRef: ProposalRef<openmls_memory_storage::::test_store::{impl#0}::queue_proposal::{constant#1}>, QueuedProposal: QueuedProposal<openmls_memory_storage::::test_store::{impl#0}::queue_proposal::{constant#2}>,

fn write_tree<GroupId, TreeSync>( &self, _group_id: &GroupId, _tree: &TreeSync, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_tree::{constant#0}>, TreeSync: TreeSync<openmls_memory_storage::::test_store::{impl#0}::write_tree::{constant#1}>,

fn write_interim_transcript_hash<GroupId, InterimTranscriptHash>( &self, _group_id: &GroupId, _interim_transcript_hash: &InterimTranscriptHash, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_interim_transcript_hash::{constant#0}>, InterimTranscriptHash: InterimTranscriptHash<openmls_memory_storage::::test_store::{impl#0}::write_interim_transcript_hash::{constant#1}>,

fn write_context<GroupId, GroupContext>( &self, _group_id: &GroupId, _group_context: &GroupContext, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_context::{constant#0}>, GroupContext: GroupContext<openmls_memory_storage::::test_store::{impl#0}::write_context::{constant#1}>,

fn write_confirmation_tag<GroupId, ConfirmationTag>( &self, _group_id: &GroupId, _confirmation_tag: &ConfirmationTag, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_confirmation_tag::{constant#0}>, ConfirmationTag: ConfirmationTag<openmls_memory_storage::::test_store::{impl#0}::write_confirmation_tag::{constant#1}>,

fn write_signature_key_pair<SignaturePublicKey, SignatureKeyPair>( &self, _public_key: &SignaturePublicKey, _signature_key_pair: &SignatureKeyPair, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where SignaturePublicKey: SignaturePublicKey<openmls_memory_storage::::test_store::{impl#0}::write_signature_key_pair::{constant#0}>, SignatureKeyPair: SignatureKeyPair<openmls_memory_storage::::test_store::{impl#0}::write_signature_key_pair::{constant#1}>,

fn write_encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>( &self, _group_id: &GroupId, _epoch: &EpochKey, _leaf_index: u32, _key_pairs: &[HpkeKeyPair], ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_encryption_epoch_key_pairs::{constant#0}>, EpochKey: EpochKey<openmls_memory_storage::::test_store::{impl#0}::write_encryption_epoch_key_pairs::{constant#1}>, HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::test_store::{impl#0}::write_encryption_epoch_key_pairs::{constant#2}>,

fn write_psk<PskId, PskBundle>( &self, _psk_id: &PskId, _psk: &PskBundle, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where PskId: PskId<openmls_memory_storage::::test_store::{impl#0}::write_psk::{constant#0}>, PskBundle: PskBundle<openmls_memory_storage::::test_store::{impl#0}::write_psk::{constant#1}>,

fn queued_proposal_refs<GroupId, ProposalRef>( &self, _group_id: &GroupId, ) -> Result<Vec<ProposalRef>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::queued_proposal_refs::{constant#0}>, ProposalRef: ProposalRef<openmls_memory_storage::::test_store::{impl#0}::queued_proposal_refs::{constant#1}>,

fn tree<GroupId, TreeSync>( &self, _group_id: &GroupId, ) -> Result<Option<TreeSync>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::tree::{constant#0}>, TreeSync: TreeSync<openmls_memory_storage::::test_store::{impl#0}::tree::{constant#1}>,

fn group_context<GroupId, GroupContext>( &self, _group_id: &GroupId, ) -> Result<Option<GroupContext>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::group_context::{constant#0}>, GroupContext: GroupContext<openmls_memory_storage::::test_store::{impl#0}::group_context::{constant#1}>,

fn interim_transcript_hash<GroupId, InterimTranscriptHash>( &self, _group_id: &GroupId, ) -> Result<Option<InterimTranscriptHash>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::interim_transcript_hash::{constant#0}>, InterimTranscriptHash: InterimTranscriptHash<openmls_memory_storage::::test_store::{impl#0}::interim_transcript_hash::{constant#1}>,

fn confirmation_tag<GroupId, ConfirmationTag>( &self, _group_id: &GroupId, ) -> Result<Option<ConfirmationTag>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::confirmation_tag::{constant#0}>, ConfirmationTag: ConfirmationTag<openmls_memory_storage::::test_store::{impl#0}::confirmation_tag::{constant#1}>,

fn signature_key_pair<SignaturePublicKey, SignatureKeyPair>( &self, _public_key: &SignaturePublicKey, ) -> Result<Option<SignatureKeyPair>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where SignaturePublicKey: SignaturePublicKey<openmls_memory_storage::::test_store::{impl#0}::signature_key_pair::{constant#0}>, SignatureKeyPair: SignatureKeyPair<openmls_memory_storage::::test_store::{impl#0}::signature_key_pair::{constant#1}>,

fn encryption_key_pair<HpkeKeyPair, EncryptionKey>( &self, _public_key: &EncryptionKey, ) -> Result<Option<HpkeKeyPair>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::test_store::{impl#0}::encryption_key_pair::{constant#0}>, EncryptionKey: EncryptionKey<openmls_memory_storage::::test_store::{impl#0}::encryption_key_pair::{constant#1}>,

fn psk<PskBundle, PskId>( &self, _psk_id: &PskId, ) -> Result<Option<PskBundle>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where PskBundle: PskBundle<openmls_memory_storage::::test_store::{impl#0}::psk::{constant#0}>, PskId: PskId<openmls_memory_storage::::test_store::{impl#0}::psk::{constant#1}>,

fn delete_signature_key_pair<SignaturePublicKeuy>( &self, _public_key: &SignaturePublicKeuy, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where SignaturePublicKeuy: SignaturePublicKey<openmls_memory_storage::::test_store::{impl#0}::delete_signature_key_pair::{constant#0}>,

fn delete_encryption_key_pair<EncryptionKey>( &self, _public_key: &EncryptionKey, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EncryptionKey: EncryptionKey<openmls_memory_storage::::test_store::{impl#0}::delete_encryption_key_pair::{constant#0}>,

fn delete_encryption_epoch_key_pairs<GroupId, EpochKey>( &self, _group_id: &GroupId, _epoch: &EpochKey, _leaf_index: u32, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_encryption_epoch_key_pairs::{constant#0}>, EpochKey: EpochKey<openmls_memory_storage::::test_store::{impl#0}::delete_encryption_epoch_key_pairs::{constant#1}>,

fn delete_key_package<KeyPackageRef>( &self, _hash_ref: &KeyPackageRef, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where KeyPackageRef: HashReference<openmls_memory_storage::::test_store::{impl#0}::delete_key_package::{constant#0}>,

fn delete_psk<PskKey>( &self, _psk_id: &PskKey, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where PskKey: PskId<openmls_memory_storage::::test_store::{impl#0}::delete_psk::{constant#0}>,

fn group_state<GroupState, GroupId>( &self, _group_id: &GroupId, ) -> Result<Option<GroupState>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupState: GroupState<openmls_memory_storage::::test_store::{impl#0}::group_state::{constant#0}>, GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::group_state::{constant#1}>,

fn write_group_state<GroupState, GroupId>( &self, _group_id: &GroupId, _group_state: &GroupState, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupState: GroupState<openmls_memory_storage::::test_store::{impl#0}::write_group_state::{constant#0}>, GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_group_state::{constant#1}>,

fn delete_group_state<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_group_state::{constant#0}>,

fn message_secrets<GroupId, MessageSecrets>( &self, _group_id: &GroupId, ) -> Result<Option<MessageSecrets>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::message_secrets::{constant#0}>, MessageSecrets: MessageSecrets<openmls_memory_storage::::test_store::{impl#0}::message_secrets::{constant#1}>,

fn write_message_secrets<GroupId, MessageSecrets>( &self, _group_id: &GroupId, _message_secrets: &MessageSecrets, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_message_secrets::{constant#0}>, MessageSecrets: MessageSecrets<openmls_memory_storage::::test_store::{impl#0}::write_message_secrets::{constant#1}>,

fn delete_message_secrets<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_message_secrets::{constant#0}>,

fn resumption_psk_store<GroupId, ResumptionPskStore>( &self, _group_id: &GroupId, ) -> Result<Option<ResumptionPskStore>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::resumption_psk_store::{constant#0}>, ResumptionPskStore: ResumptionPskStore<openmls_memory_storage::::test_store::{impl#0}::resumption_psk_store::{constant#1}>,

fn write_resumption_psk_store<GroupId, ResumptionPskStore>( &self, _group_id: &GroupId, _resumption_psk_store: &ResumptionPskStore, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_resumption_psk_store::{constant#0}>, ResumptionPskStore: ResumptionPskStore<openmls_memory_storage::::test_store::{impl#0}::write_resumption_psk_store::{constant#1}>,

fn delete_all_resumption_psk_secrets<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_all_resumption_psk_secrets::{constant#0}>,

fn own_leaf_index<GroupId, LeafNodeIndex>( &self, _group_id: &GroupId, ) -> Result<Option<LeafNodeIndex>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::own_leaf_index::{constant#0}>, LeafNodeIndex: LeafNodeIndex<openmls_memory_storage::::test_store::{impl#0}::own_leaf_index::{constant#1}>,

fn write_own_leaf_index<GroupId, LeafNodeIndex>( &self, _group_id: &GroupId, _own_leaf_index: &LeafNodeIndex, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_own_leaf_index::{constant#0}>, LeafNodeIndex: LeafNodeIndex<openmls_memory_storage::::test_store::{impl#0}::write_own_leaf_index::{constant#1}>,

fn delete_own_leaf_index<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_own_leaf_index::{constant#0}>,

fn group_epoch_secrets<GroupId, GroupEpochSecrets>( &self, _group_id: &GroupId, ) -> Result<Option<GroupEpochSecrets>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::group_epoch_secrets::{constant#0}>, GroupEpochSecrets: GroupEpochSecrets<openmls_memory_storage::::test_store::{impl#0}::group_epoch_secrets::{constant#1}>,

fn write_group_epoch_secrets<GroupId, GroupEpochSecrets>( &self, _group_id: &GroupId, _group_epoch_secrets: &GroupEpochSecrets, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_group_epoch_secrets::{constant#0}>, GroupEpochSecrets: GroupEpochSecrets<openmls_memory_storage::::test_store::{impl#0}::write_group_epoch_secrets::{constant#1}>,

fn delete_group_epoch_secrets<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_group_epoch_secrets::{constant#0}>,

fn clear_proposal_queue<GroupId, ProposalRef>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::clear_proposal_queue::{constant#0}>, ProposalRef: ProposalRef<openmls_memory_storage::::test_store::{impl#0}::clear_proposal_queue::{constant#1}>,

fn mls_group_join_config<GroupId, MlsGroupJoinConfig>( &self, _group_id: &GroupId, ) -> Result<Option<MlsGroupJoinConfig>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::mls_group_join_config::{constant#0}>, MlsGroupJoinConfig: MlsGroupJoinConfig<openmls_memory_storage::::test_store::{impl#0}::mls_group_join_config::{constant#1}>,

fn write_mls_join_config<GroupId, MlsGroupJoinConfig>( &self, _group_id: &GroupId, _config: &MlsGroupJoinConfig, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_mls_join_config::{constant#0}>, MlsGroupJoinConfig: MlsGroupJoinConfig<openmls_memory_storage::::test_store::{impl#0}::write_mls_join_config::{constant#1}>,

fn own_leaf_nodes<GroupId, LeafNode>( &self, _group_id: &GroupId, ) -> Result<Vec<LeafNode>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::own_leaf_nodes::{constant#0}>, LeafNode: LeafNode<openmls_memory_storage::::test_store::{impl#0}::own_leaf_nodes::{constant#1}>,

fn append_own_leaf_node<GroupId, LeafNode>( &self, _group_id: &GroupId, _leaf_node: &LeafNode, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::append_own_leaf_node::{constant#0}>, LeafNode: LeafNode<openmls_memory_storage::::test_store::{impl#0}::append_own_leaf_node::{constant#1}>,

fn queued_proposals<GroupId, ProposalRef, QueuedProposal>( &self, _group_id: &GroupId, ) -> Result<Vec<(ProposalRef, QueuedProposal)>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::queued_proposals::{constant#0}>, ProposalRef: ProposalRef<openmls_memory_storage::::test_store::{impl#0}::queued_proposals::{constant#1}>, QueuedProposal: QueuedProposal<openmls_memory_storage::::test_store::{impl#0}::queued_proposals::{constant#2}>,

fn remove_proposal<GroupId, ProposalRef>( &self, _group_id: &GroupId, _proposal_ref: &ProposalRef, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::remove_proposal::{constant#0}>, ProposalRef: ProposalRef<openmls_memory_storage::::test_store::{impl#0}::remove_proposal::{constant#1}>,

fn delete_own_leaf_nodes<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_own_leaf_nodes::{constant#0}>,

fn delete_group_config<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_group_config::{constant#0}>,

fn delete_tree<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_tree::{constant#0}>,

fn delete_confirmation_tag<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_confirmation_tag::{constant#0}>,

fn delete_context<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_context::{constant#0}>,

fn delete_interim_transcript_hash<GroupId>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_interim_transcript_hash::{constant#0}>,

fn write_application_export_tree<GroupId, ApplicationExportTree>( &self, _group_id: &GroupId, _application_export_tree: &ApplicationExportTree, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::write_application_export_tree::{constant#0}>, ApplicationExportTree: ApplicationExportTree<openmls_memory_storage::::test_store::{impl#0}::write_application_export_tree::{constant#1}>,

Available on crate feature extensions-draft-08 only.

fn application_export_tree<GroupId, ApplicationExportTree>( &self, _group_id: &GroupId, ) -> Result<Option<ApplicationExportTree>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::application_export_tree::{constant#0}>, ApplicationExportTree: ApplicationExportTree<openmls_memory_storage::::test_store::{impl#0}::application_export_tree::{constant#1}>,

Available on crate feature extensions-draft-08 only.

fn delete_application_export_tree<GroupId, ApplicationExportTree>( &self, _group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::delete_application_export_tree::{constant#0}>, ApplicationExportTree: ApplicationExportTree<openmls_memory_storage::::test_store::{impl#0}::delete_application_export_tree::{constant#1}>,

Available on crate feature extensions-draft-08 only.

impl StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}> for MemoryStorage

type Error = MemoryStorageError

fn queue_proposal<GroupId, ProposalRef, QueuedProposal>( &self, group_id: &GroupId, proposal_ref: &ProposalRef, proposal: &QueuedProposal, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::queue_proposal::{constant#2}>, ProposalRef: ProposalRef<openmls_memory_storage::::{impl#3}::queue_proposal::{constant#3}>, QueuedProposal: QueuedProposal<openmls_memory_storage::::{impl#3}::queue_proposal::{constant#4}>,

fn write_tree<GroupId, TreeSync>( &self, group_id: &GroupId, tree: &TreeSync, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_tree::{constant#1}>, TreeSync: TreeSync<openmls_memory_storage::::{impl#3}::write_tree::{constant#2}>,

fn write_interim_transcript_hash<GroupId, InterimTranscriptHash>( &self, group_id: &GroupId, interim_transcript_hash: &InterimTranscriptHash, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_interim_transcript_hash::{constant#1}>, InterimTranscriptHash: InterimTranscriptHash<openmls_memory_storage::::{impl#3}::write_interim_transcript_hash::{constant#2}>,

fn write_context<GroupId, GroupContext>( &self, group_id: &GroupId, group_context: &GroupContext, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_context::{constant#1}>, GroupContext: GroupContext<openmls_memory_storage::::{impl#3}::write_context::{constant#2}>,

fn write_confirmation_tag<GroupId, ConfirmationTag>( &self, group_id: &GroupId, confirmation_tag: &ConfirmationTag, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_confirmation_tag::{constant#1}>, ConfirmationTag: ConfirmationTag<openmls_memory_storage::::{impl#3}::write_confirmation_tag::{constant#2}>,

fn write_signature_key_pair<SignaturePublicKey, SignatureKeyPair>( &self, public_key: &SignaturePublicKey, signature_key_pair: &SignatureKeyPair, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where SignaturePublicKey: SignaturePublicKey<openmls_memory_storage::::{impl#3}::write_signature_key_pair::{constant#1}>, SignatureKeyPair: SignatureKeyPair<openmls_memory_storage::::{impl#3}::write_signature_key_pair::{constant#2}>,

fn queued_proposal_refs<GroupId, ProposalRef>( &self, group_id: &GroupId, ) -> Result<Vec<ProposalRef>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::queued_proposal_refs::{constant#0}>, ProposalRef: ProposalRef<openmls_memory_storage::::{impl#3}::queued_proposal_refs::{constant#1}>,

fn queued_proposals<GroupId, ProposalRef, QueuedProposal>( &self, group_id: &GroupId, ) -> Result<Vec<(ProposalRef, QueuedProposal)>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::queued_proposals::{constant#0}>, ProposalRef: ProposalRef<openmls_memory_storage::::{impl#3}::queued_proposals::{constant#1}>, QueuedProposal: QueuedProposal<openmls_memory_storage::::{impl#3}::queued_proposals::{constant#2}>,

fn tree<GroupId, TreeSync>( &self, group_id: &GroupId, ) -> Result<Option<TreeSync>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::tree::{constant#1}>, TreeSync: TreeSync<openmls_memory_storage::::{impl#3}::tree::{constant#2}>,

fn group_context<GroupId, GroupContext>( &self, group_id: &GroupId, ) -> Result<Option<GroupContext>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::group_context::{constant#1}>, GroupContext: GroupContext<openmls_memory_storage::::{impl#3}::group_context::{constant#2}>,

fn interim_transcript_hash<GroupId, InterimTranscriptHash>( &self, group_id: &GroupId, ) -> Result<Option<InterimTranscriptHash>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::interim_transcript_hash::{constant#1}>, InterimTranscriptHash: InterimTranscriptHash<openmls_memory_storage::::{impl#3}::interim_transcript_hash::{constant#2}>,

fn confirmation_tag<GroupId, ConfirmationTag>( &self, group_id: &GroupId, ) -> Result<Option<ConfirmationTag>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::confirmation_tag::{constant#1}>, ConfirmationTag: ConfirmationTag<openmls_memory_storage::::{impl#3}::confirmation_tag::{constant#2}>,

fn signature_key_pair<SignaturePublicKey, SignatureKeyPair>( &self, public_key: &SignaturePublicKey, ) -> Result<Option<SignatureKeyPair>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where SignaturePublicKey: SignaturePublicKey<openmls_memory_storage::::{impl#3}::signature_key_pair::{constant#1}>, SignatureKeyPair: SignatureKeyPair<openmls_memory_storage::::{impl#3}::signature_key_pair::{constant#2}>,

fn write_key_package<HashReference, KeyPackage>( &self, hash_ref: &HashReference, key_package: &KeyPackage, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where HashReference: HashReference<openmls_memory_storage::::{impl#3}::write_key_package::{constant#1}>, KeyPackage: KeyPackage<openmls_memory_storage::::{impl#3}::write_key_package::{constant#2}>,

fn write_psk<PskId, PskBundle>( &self, psk_id: &PskId, psk: &PskBundle, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where PskId: PskId<openmls_memory_storage::::{impl#3}::write_psk::{constant#1}>, PskBundle: PskBundle<openmls_memory_storage::::{impl#3}::write_psk::{constant#2}>,

fn write_encryption_key_pair<EncryptionKey, HpkeKeyPair>( &self, public_key: &EncryptionKey, key_pair: &HpkeKeyPair, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EncryptionKey: EncryptionKey<openmls_memory_storage::::{impl#3}::write_encryption_key_pair::{constant#1}>, HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::{impl#3}::write_encryption_key_pair::{constant#2}>,

fn key_package<KeyPackageRef, KeyPackage>( &self, hash_ref: &KeyPackageRef, ) -> Result<Option<KeyPackage>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where KeyPackageRef: HashReference<openmls_memory_storage::::{impl#3}::key_package::{constant#0}>, KeyPackage: KeyPackage<openmls_memory_storage::::{impl#3}::key_package::{constant#1}>,

fn psk<PskBundle, PskId>( &self, psk_id: &PskId, ) -> Result<Option<PskBundle>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where PskBundle: PskBundle<openmls_memory_storage::::{impl#3}::psk::{constant#0}>, PskId: PskId<openmls_memory_storage::::{impl#3}::psk::{constant#1}>,

fn encryption_key_pair<HpkeKeyPair, EncryptionKey>( &self, public_key: &EncryptionKey, ) -> Result<Option<HpkeKeyPair>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::{impl#3}::encryption_key_pair::{constant#0}>, EncryptionKey: EncryptionKey<openmls_memory_storage::::{impl#3}::encryption_key_pair::{constant#1}>,

fn delete_signature_key_pair<SignaturePublicKeuy>( &self, public_key: &SignaturePublicKeuy, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where SignaturePublicKeuy: SignaturePublicKey<openmls_memory_storage::::{impl#3}::delete_signature_key_pair::{constant#1}>,

fn delete_encryption_key_pair<EncryptionKey>( &self, public_key: &EncryptionKey, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EncryptionKey: EncryptionKey<openmls_memory_storage::::{impl#3}::delete_encryption_key_pair::{constant#1}>,

fn delete_key_package<KeyPackageRef>( &self, hash_ref: &KeyPackageRef, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where KeyPackageRef: HashReference<openmls_memory_storage::::{impl#3}::delete_key_package::{constant#1}>,

fn delete_psk<PskKey>( &self, psk_id: &PskKey, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where PskKey: PskId<openmls_memory_storage::::{impl#3}::delete_psk::{constant#1}>,

fn group_state<GroupState, GroupId>( &self, group_id: &GroupId, ) -> Result<Option<GroupState>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupState: GroupState<openmls_memory_storage::::{impl#3}::group_state::{constant#0}>, GroupId: GroupId<openmls_memory_storage::::{impl#3}::group_state::{constant#1}>,

fn write_group_state<GroupState, GroupId>( &self, group_id: &GroupId, group_state: &GroupState, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupState: GroupState<openmls_memory_storage::::{impl#3}::write_group_state::{constant#1}>, GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_group_state::{constant#2}>,

fn delete_group_state<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_group_state::{constant#1}>,

fn message_secrets<GroupId, MessageSecrets>( &self, group_id: &GroupId, ) -> Result<Option<MessageSecrets>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::message_secrets::{constant#0}>, MessageSecrets: MessageSecrets<openmls_memory_storage::::{impl#3}::message_secrets::{constant#1}>,

fn write_message_secrets<GroupId, MessageSecrets>( &self, group_id: &GroupId, message_secrets: &MessageSecrets, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_message_secrets::{constant#1}>, MessageSecrets: MessageSecrets<openmls_memory_storage::::{impl#3}::write_message_secrets::{constant#2}>,

fn delete_message_secrets<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_message_secrets::{constant#1}>,

fn resumption_psk_store<GroupId, ResumptionPskStore>( &self, group_id: &GroupId, ) -> Result<Option<ResumptionPskStore>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::resumption_psk_store::{constant#0}>, ResumptionPskStore: ResumptionPskStore<openmls_memory_storage::::{impl#3}::resumption_psk_store::{constant#1}>,

fn write_resumption_psk_store<GroupId, ResumptionPskStore>( &self, group_id: &GroupId, resumption_psk_store: &ResumptionPskStore, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_resumption_psk_store::{constant#1}>, ResumptionPskStore: ResumptionPskStore<openmls_memory_storage::::{impl#3}::write_resumption_psk_store::{constant#2}>,

fn delete_all_resumption_psk_secrets<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_all_resumption_psk_secrets::{constant#1}>,

fn own_leaf_index<GroupId, LeafNodeIndex>( &self, group_id: &GroupId, ) -> Result<Option<LeafNodeIndex>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::own_leaf_index::{constant#0}>, LeafNodeIndex: LeafNodeIndex<openmls_memory_storage::::{impl#3}::own_leaf_index::{constant#1}>,

fn write_own_leaf_index<GroupId, LeafNodeIndex>( &self, group_id: &GroupId, own_leaf_index: &LeafNodeIndex, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_own_leaf_index::{constant#1}>, LeafNodeIndex: LeafNodeIndex<openmls_memory_storage::::{impl#3}::write_own_leaf_index::{constant#2}>,

fn delete_own_leaf_index<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_own_leaf_index::{constant#1}>,

fn group_epoch_secrets<GroupId, GroupEpochSecrets>( &self, group_id: &GroupId, ) -> Result<Option<GroupEpochSecrets>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::group_epoch_secrets::{constant#0}>, GroupEpochSecrets: GroupEpochSecrets<openmls_memory_storage::::{impl#3}::group_epoch_secrets::{constant#1}>,

fn write_group_epoch_secrets<GroupId, GroupEpochSecrets>( &self, group_id: &GroupId, group_epoch_secrets: &GroupEpochSecrets, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_group_epoch_secrets::{constant#1}>, GroupEpochSecrets: GroupEpochSecrets<openmls_memory_storage::::{impl#3}::write_group_epoch_secrets::{constant#2}>,

fn delete_group_epoch_secrets<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_group_epoch_secrets::{constant#1}>,

fn write_encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>( &self, group_id: &GroupId, epoch: &EpochKey, leaf_index: u32, key_pairs: &[HpkeKeyPair], ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_encryption_epoch_key_pairs::{constant#1}>, EpochKey: EpochKey<openmls_memory_storage::::{impl#3}::write_encryption_epoch_key_pairs::{constant#2}>, HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::{impl#3}::write_encryption_epoch_key_pairs::{constant#3}>,

fn encryption_epoch_key_pairs<GroupId, EpochKey, HpkeKeyPair>( &self, group_id: &GroupId, epoch: &EpochKey, leaf_index: u32, ) -> Result<Vec<HpkeKeyPair>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::encryption_epoch_key_pairs::{constant#1}>, EpochKey: EpochKey<openmls_memory_storage::::{impl#3}::encryption_epoch_key_pairs::{constant#2}>, HpkeKeyPair: HpkeKeyPair<openmls_memory_storage::::{impl#3}::encryption_epoch_key_pairs::{constant#3}>,

fn delete_encryption_epoch_key_pairs<GroupId, EpochKey>( &self, group_id: &GroupId, epoch: &EpochKey, leaf_index: u32, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_encryption_epoch_key_pairs::{constant#1}>, EpochKey: EpochKey<openmls_memory_storage::::{impl#3}::delete_encryption_epoch_key_pairs::{constant#2}>,

fn clear_proposal_queue<GroupId, ProposalRef>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::clear_proposal_queue::{constant#1}>, ProposalRef: ProposalRef<openmls_memory_storage::::{impl#3}::clear_proposal_queue::{constant#2}>,

fn mls_group_join_config<GroupId, MlsGroupJoinConfig>( &self, group_id: &GroupId, ) -> Result<Option<MlsGroupJoinConfig>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::mls_group_join_config::{constant#0}>, MlsGroupJoinConfig: MlsGroupJoinConfig<openmls_memory_storage::::{impl#3}::mls_group_join_config::{constant#1}>,

fn write_mls_join_config<GroupId, MlsGroupJoinConfig>( &self, group_id: &GroupId, config: &MlsGroupJoinConfig, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_mls_join_config::{constant#1}>, MlsGroupJoinConfig: MlsGroupJoinConfig<openmls_memory_storage::::{impl#3}::write_mls_join_config::{constant#2}>,

fn own_leaf_nodes<GroupId, LeafNode>( &self, group_id: &GroupId, ) -> Result<Vec<LeafNode>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::own_leaf_nodes::{constant#0}>, LeafNode: LeafNode<openmls_memory_storage::::{impl#3}::own_leaf_nodes::{constant#1}>,

fn append_own_leaf_node<GroupId, LeafNode>( &self, group_id: &GroupId, leaf_node: &LeafNode, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::append_own_leaf_node::{constant#1}>, LeafNode: LeafNode<openmls_memory_storage::::{impl#3}::append_own_leaf_node::{constant#2}>,

fn delete_own_leaf_nodes<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_own_leaf_nodes::{constant#1}>,

fn delete_group_config<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_group_config::{constant#1}>,

fn delete_tree<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_tree::{constant#1}>,

fn delete_confirmation_tag<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_confirmation_tag::{constant#1}>,

fn delete_context<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_context::{constant#1}>,

fn delete_interim_transcript_hash<GroupId>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_interim_transcript_hash::{constant#1}>,

fn remove_proposal<GroupId, ProposalRef>( &self, group_id: &GroupId, proposal_ref: &ProposalRef, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::remove_proposal::{constant#2}>, ProposalRef: ProposalRef<openmls_memory_storage::::{impl#3}::remove_proposal::{constant#3}>,

fn write_application_export_tree<GroupId, ApplicationExportTree>( &self, group_id: &GroupId, application_export_tree: &ApplicationExportTree, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_application_export_tree::{constant#1}>, ApplicationExportTree: ApplicationExportTree<openmls_memory_storage::::{impl#3}::write_application_export_tree::{constant#2}>,

Available on crate feature extensions-draft-08 only.

fn application_export_tree<GroupId, ApplicationExportTree>( &self, group_id: &GroupId, ) -> Result<Option<ApplicationExportTree>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::application_export_tree::{constant#1}>, ApplicationExportTree: ApplicationExportTree<openmls_memory_storage::::{impl#3}::application_export_tree::{constant#2}>,

Available on crate feature extensions-draft-08 only.

fn delete_application_export_tree<GroupId, ApplicationExportTree>( &self, group_id: &GroupId, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::delete_application_export_tree::{constant#1}>, ApplicationExportTree: ApplicationExportTree<openmls_memory_storage::::{impl#3}::delete_application_export_tree::{constant#2}>,

Available on crate feature extensions-draft-08 only.

Implementors