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_vc_emulation_epoch_state<EpochId, VcEmulationEpochState>(
        &self,
        epoch_id: &EpochId,
        vc_emulation_epoch_state: &VcEmulationEpochState,
    ) -> Result<(), Self::Error>
       where EpochId: VcEpochId<VERSION>,
             VcEmulationEpochState: VcEmulationEpochState<VERSION>;
    fn write_vc_emulation_bindings<GroupId, VcEmulationBindings>(
        &self,
        group_id: &GroupId,
        bindings: &VcEmulationBindings,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>,
             VcEmulationBindings: VcEmulationBindings<VERSION>;
    fn write_vc_operation_tree<EpochId, VcOperationTree>(
        &self,
        epoch_id: &EpochId,
        vc_operation_tree: &VcOperationTree,
    ) -> Result<(), Self::Error>
       where EpochId: VcEpochId<VERSION>,
             VcOperationTree: VcOperationTree<VERSION>;
    fn write_retained_key_package_material_batch<EpochId, VcOperationTree, KeyPackageRef, RetainedKeyPackageMaterial>(
        &self,
        epoch_id: &EpochId,
        operation_tree: &VcOperationTree,
        materials: &[(KeyPackageRef, RetainedKeyPackageMaterial)],
    ) -> Result<(), Self::Error>
       where EpochId: VcEpochId<VERSION>,
             VcOperationTree: VcOperationTree<VERSION>,
             KeyPackageRef: HashReference<VERSION>,
             RetainedKeyPackageMaterial: RetainedKeyPackageMaterial<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 vc_emulation_epoch_state<EpochId, VcEmulationEpochState>(
        &self,
        epoch_id: &EpochId,
    ) -> Result<Option<VcEmulationEpochState>, Self::Error>
       where EpochId: VcEpochId<VERSION>,
             VcEmulationEpochState: VcEmulationEpochState<VERSION>;
    fn vc_emulation_bindings<GroupId, VcEmulationBindings>(
        &self,
        group_id: &GroupId,
    ) -> Result<Option<VcEmulationBindings>, Self::Error>
       where GroupId: GroupId<VERSION>,
             VcEmulationBindings: VcEmulationBindings<VERSION>;
    fn vc_operation_tree<EpochId, VcOperationTree>(
        &self,
        epoch_id: &EpochId,
    ) -> Result<Option<VcOperationTree>, Self::Error>
       where EpochId: VcEpochId<VERSION>,
             VcOperationTree: VcOperationTree<VERSION>;
    fn retained_key_package_material<KeyPackageRef, RetainedKeyPackageMaterial>(
        &self,
        hash_ref: &KeyPackageRef,
    ) -> Result<Option<RetainedKeyPackageMaterial>, Self::Error>
       where KeyPackageRef: HashReference<VERSION>,
             RetainedKeyPackageMaterial: RetainedKeyPackageMaterial<VERSION>;
    fn has_retained_key_package_material_for_epoch<EpochId>(
        &self,
        epoch_id: &EpochId,
    ) -> Result<bool, Self::Error>
       where EpochId: VcEpochId<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>;
    fn delete_vc_emulation_state_if_unreferenced<EpochId>(
        &self,
        epoch_id: &EpochId,
    ) -> Result<bool, Self::Error>
       where EpochId: VcEpochId<VERSION>;
    fn delete_vc_emulation_bindings<GroupId>(
        &self,
        group_id: &GroupId,
    ) -> Result<(), Self::Error>
       where GroupId: GroupId<VERSION>;
    fn delete_retained_key_package_material<KeyPackageRef>(
        &self,
        hash_ref: &KeyPackageRef,
    ) -> Result<(), Self::Error>
       where KeyPackageRef: HashReference<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 only.

Write the ApplicationExportTree for the group with the given id.

fn write_vc_emulation_epoch_state<EpochId, VcEmulationEpochState>( &self, epoch_id: &EpochId, vc_emulation_epoch_state: &VcEmulationEpochState, ) -> Result<(), Self::Error>

where EpochId: VcEpochId<VERSION>, VcEmulationEpochState: VcEmulationEpochState<VERSION>,

Available on crate feature virtual-clients-draft only.

Write the virtual clients per-emulation-epoch state (the AEAD key plus the registering client’s emulation-group leaf index) for the given epoch.

fn write_vc_emulation_bindings<GroupId, VcEmulationBindings>( &self, group_id: &GroupId, bindings: &VcEmulationBindings, ) -> Result<(), Self::Error>

where GroupId: GroupId<VERSION>, VcEmulationBindings: VcEmulationBindings<VERSION>,

Available on crate feature virtual-clients-draft only.

Store the record binding each recent epoch of a higher-level group to the emulation-group epoch whose virtual-client LeafNode was active at that epoch. Used by the reuse-guard derivation path to look up the per-message ReuseGuardSecret for the epoch a message was sent in.

The record is updated on every commit merged on the higher-level group and prunes its own entries in lockstep with the group’s message-secrets retention. A subsequent write replaces any previously stored record.

fn write_vc_operation_tree<EpochId, VcOperationTree>( &self, epoch_id: &EpochId, vc_operation_tree: &VcOperationTree, ) -> Result<(), Self::Error>

where EpochId: VcEpochId<VERSION>, VcOperationTree: VcOperationTree<VERSION>,

Available on crate feature virtual-clients-draft only.

Write the per-emulation-epoch Virtual Client Operation Secret Tree (the lazily derived node secrets plus the per-leaf operation ratchets) for the given epoch. The tree is written back after every ratchet advance. It is stored separately from the static EmulationEpochState so that per-operation writes do not rewrite the static fields.

fn write_retained_key_package_material_batch<EpochId, VcOperationTree, KeyPackageRef, RetainedKeyPackageMaterial>( &self, epoch_id: &EpochId, operation_tree: &VcOperationTree, materials: &[(KeyPackageRef, RetainedKeyPackageMaterial)], ) -> Result<(), Self::Error>

where EpochId: VcEpochId<VERSION>, VcOperationTree: VcOperationTree<VERSION>, KeyPackageRef: HashReference<VERSION>, RetainedKeyPackageMaterial: RetainedKeyPackageMaterial<VERSION>,

Available on crate feature virtual-clients-draft only.

Store the advanced operation secret tree for epoch_id together with the retained virtual clients KeyPackage material for every reference in materials.

A sibling calls this once when it processes a KeyPackageUpload: the upload consumes one operation generation in the tree and produces one RetainedKeyPackageMaterial per KeyPackage. These writes belong together: the tree must never be persisted as advanced without the materials it produced. Providers do not open their own transaction, so an application using a transactional provider (such as SQLite) should call this within a transaction to get atomicity and rollback on error. The in-memory provider applies the writes while holding its write lock. Each material is keyed by its HashReference and tagged with epoch_id so the epoch-liveness query (Self::has_retained_key_package_material_for_epoch) can find it. A subsequent write for the same reference replaces the stored material.

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 only.

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

fn vc_emulation_epoch_state<EpochId, VcEmulationEpochState>( &self, epoch_id: &EpochId, ) -> Result<Option<VcEmulationEpochState>, Self::Error>

where EpochId: VcEpochId<VERSION>, VcEmulationEpochState: VcEmulationEpochState<VERSION>,

Available on crate feature virtual-clients-draft only.

Get the virtual clients per-emulation-epoch state for the given epoch (the AEAD key plus the registering client’s emulation-group leaf index).

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

where GroupId: GroupId<VERSION>, VcEmulationBindings: VcEmulationBindings<VERSION>,

Available on crate feature virtual-clients-draft only.

Load the per-epoch emulation bindings of a higher-level group (see Self::write_vc_emulation_bindings). Returns None if no VC commit has been merged on this higher-level group.

fn vc_operation_tree<EpochId, VcOperationTree>( &self, epoch_id: &EpochId, ) -> Result<Option<VcOperationTree>, Self::Error>

where EpochId: VcEpochId<VERSION>, VcOperationTree: VcOperationTree<VERSION>,

Available on crate feature virtual-clients-draft only.

Get the per-emulation-epoch Virtual Client Operation Secret Tree for the given epoch (the lazily derived node secrets plus the per-leaf operation ratchets).

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

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

Available on crate feature virtual-clients-draft only.

Get the retained virtual clients KeyPackage material for the given KeyPackage reference. Returns None if no material was stored for that reference.

fn has_retained_key_package_material_for_epoch<EpochId>( &self, epoch_id: &EpochId, ) -> Result<bool, Self::Error>

where EpochId: VcEpochId<VERSION>,

Available on crate feature virtual-clients-draft only.

Return true if any retained virtual clients KeyPackage material still references epoch_id. Used to keep an emulation epoch’s state alive while KeyPackages derived from it can still be welcomed (see Self::delete_vc_emulation_state_if_unreferenced).

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.

Under the virtual-clients-draft feature, an implementation must also delete the retained virtual clients KeyPackage material stored for the same reference (see Self::delete_retained_key_package_material). Deleting non-existent material is a no-op, so this is safe for KeyPackages that were never uploaded by a virtual client.

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 only.

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

fn delete_vc_emulation_state_if_unreferenced<EpochId>( &self, epoch_id: &EpochId, ) -> Result<bool, Self::Error>

where EpochId: VcEpochId<VERSION>,

Available on crate feature virtual-clients-draft only.

Delete all per-epoch state for the given emulation epoch (both the emulation epoch state and the Virtual Client Operation Secret Tree), but only if no retained virtual clients KeyPackage material still references it.

Returns Ok(true) if the epoch state was deleted, and Ok(false) if it was kept because retained material still references the epoch. The liveness check and the deletion belong together. Providers do not open their own transaction, so an application using a transactional provider (such as SQLite) should call this within a transaction, so a material stored concurrently cannot be orphaned by a deletion that already observed the epoch as unreferenced. The in-memory provider holds its write lock across both.

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

where GroupId: GroupId<VERSION>,

Available on crate feature virtual-clients-draft only.

Remove the per-epoch emulation bindings of the given group. Called when the group is being deleted.

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

where KeyPackageRef: HashReference<VERSION>,

Available on crate feature virtual-clients-draft only.

Delete the retained virtual clients KeyPackage material stored for the given KeyPackage reference. Called from Self::delete_key_package so the material is removed together with the KeyPackage it describes.

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".

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 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 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 only.

fn write_vc_emulation_epoch_state<EpochId, VcEmulationEpochState>( &self, _epoch_id: &EpochId, _vc_emulation_epoch_state: &VcEmulationEpochState, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::test_store::{impl#0}::write_vc_emulation_epoch_state::{constant#0}>, VcEmulationEpochState: VcEmulationEpochState<openmls_memory_storage::::test_store::{impl#0}::write_vc_emulation_epoch_state::{constant#1}>,

Available on crate feature virtual-clients-draft only.

fn vc_emulation_epoch_state<EpochId, VcEmulationEpochState>( &self, _epoch_id: &EpochId, ) -> Result<Option<VcEmulationEpochState>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::test_store::{impl#0}::vc_emulation_epoch_state::{constant#0}>, VcEmulationEpochState: VcEmulationEpochState<openmls_memory_storage::::test_store::{impl#0}::vc_emulation_epoch_state::{constant#1}>,

Available on crate feature virtual-clients-draft only.

fn delete_vc_emulation_state_if_unreferenced<EpochId>( &self, _epoch_id: &EpochId, ) -> Result<bool, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::test_store::{impl#0}::delete_vc_emulation_state_if_unreferenced::{constant#0}>,

Available on crate feature virtual-clients-draft only.

fn write_vc_emulation_bindings<GroupId, VcEmulationBindings>( &self, _group_id: &GroupId, _bindings: &VcEmulationBindings, ) -> 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_vc_emulation_bindings::{constant#0}>, VcEmulationBindings: VcEmulationBindings<openmls_memory_storage::::test_store::{impl#0}::write_vc_emulation_bindings::{constant#1}>,

Available on crate feature virtual-clients-draft only.

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

where GroupId: GroupId<openmls_memory_storage::::test_store::{impl#0}::vc_emulation_bindings::{constant#0}>, VcEmulationBindings: VcEmulationBindings<openmls_memory_storage::::test_store::{impl#0}::vc_emulation_bindings::{constant#1}>,

Available on crate feature virtual-clients-draft only.

fn delete_vc_emulation_bindings<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_vc_emulation_bindings::{constant#0}>,

Available on crate feature virtual-clients-draft only.

fn write_vc_operation_tree<EpochId, VcOperationTree>( &self, _epoch_id: &EpochId, _vc_operation_tree: &VcOperationTree, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::test_store::{impl#0}::write_vc_operation_tree::{constant#0}>, VcOperationTree: VcOperationTree<openmls_memory_storage::::test_store::{impl#0}::write_vc_operation_tree::{constant#1}>,

Available on crate feature virtual-clients-draft only.

fn vc_operation_tree<EpochId, VcOperationTree>( &self, _epoch_id: &EpochId, ) -> Result<Option<VcOperationTree>, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::test_store::{impl#0}::vc_operation_tree::{constant#0}>, VcOperationTree: VcOperationTree<openmls_memory_storage::::test_store::{impl#0}::vc_operation_tree::{constant#1}>,

Available on crate feature virtual-clients-draft only.

fn write_retained_key_package_material_batch<EpochId, VcOperationTree, KeyPackageRef, RetainedKeyPackageMaterial>( &self, _epoch_id: &EpochId, _operation_tree: &VcOperationTree, _materials: &[(KeyPackageRef, RetainedKeyPackageMaterial)], ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::test_store::{impl#0}::write_retained_key_package_material_batch::{constant#0}>, VcOperationTree: VcOperationTree<openmls_memory_storage::::test_store::{impl#0}::write_retained_key_package_material_batch::{constant#1}>, KeyPackageRef: HashReference<openmls_memory_storage::::test_store::{impl#0}::write_retained_key_package_material_batch::{constant#2}>, RetainedKeyPackageMaterial: RetainedKeyPackageMaterial<openmls_memory_storage::::test_store::{impl#0}::write_retained_key_package_material_batch::{constant#3}>,

Available on crate feature virtual-clients-draft only.

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

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

Available on crate feature virtual-clients-draft only.

fn has_retained_key_package_material_for_epoch<EpochId>( &self, _epoch_id: &EpochId, ) -> Result<bool, <MemoryStorage as StorageProvider<openmls_memory_storage::::test_store::{impl#0}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::test_store::{impl#0}::has_retained_key_package_material_for_epoch::{constant#0}>,

Available on crate feature virtual-clients-draft only.

fn delete_retained_key_package_material<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_retained_key_package_material::{constant#0}>,

Available on crate feature virtual-clients-draft 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#3}>,

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 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 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 only.

fn write_vc_emulation_epoch_state<EpochId, VcEmulationEpochState>( &self, epoch_id: &EpochId, vc_emulation_epoch_state: &VcEmulationEpochState, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::{impl#3}::write_vc_emulation_epoch_state::{constant#1}>, VcEmulationEpochState: VcEmulationEpochState<openmls_memory_storage::::{impl#3}::write_vc_emulation_epoch_state::{constant#2}>,

Available on crate feature virtual-clients-draft only.

fn vc_emulation_epoch_state<EpochId, VcEmulationEpochState>( &self, epoch_id: &EpochId, ) -> Result<Option<VcEmulationEpochState>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::{impl#3}::vc_emulation_epoch_state::{constant#1}>, VcEmulationEpochState: VcEmulationEpochState<openmls_memory_storage::::{impl#3}::vc_emulation_epoch_state::{constant#2}>,

Available on crate feature virtual-clients-draft only.

fn delete_vc_emulation_state_if_unreferenced<EpochId>( &self, epoch_id: &EpochId, ) -> Result<bool, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::{impl#3}::delete_vc_emulation_state_if_unreferenced::{constant#2}>,

Available on crate feature virtual-clients-draft only.

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

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::write_vc_emulation_bindings::{constant#1}>, VcEmulationBindings: VcEmulationBindings<openmls_memory_storage::::{impl#3}::write_vc_emulation_bindings::{constant#2}>,

Available on crate feature virtual-clients-draft only.

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

where GroupId: GroupId<openmls_memory_storage::::{impl#3}::vc_emulation_bindings::{constant#1}>, VcEmulationBindings: VcEmulationBindings<openmls_memory_storage::::{impl#3}::vc_emulation_bindings::{constant#2}>,

Available on crate feature virtual-clients-draft only.

fn delete_vc_emulation_bindings<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_vc_emulation_bindings::{constant#1}>,

Available on crate feature virtual-clients-draft only.

fn write_vc_operation_tree<EpochId, VcOperationTree>( &self, epoch_id: &EpochId, vc_operation_tree: &VcOperationTree, ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::{impl#3}::write_vc_operation_tree::{constant#1}>, VcOperationTree: VcOperationTree<openmls_memory_storage::::{impl#3}::write_vc_operation_tree::{constant#2}>,

Available on crate feature virtual-clients-draft only.

fn vc_operation_tree<EpochId, VcOperationTree>( &self, epoch_id: &EpochId, ) -> Result<Option<VcOperationTree>, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::{impl#3}::vc_operation_tree::{constant#1}>, VcOperationTree: VcOperationTree<openmls_memory_storage::::{impl#3}::vc_operation_tree::{constant#2}>,

Available on crate feature virtual-clients-draft only.

fn write_retained_key_package_material_batch<EpochId, VcOperationTree, KeyPackageRef, RetainedKeyPackageMaterial>( &self, epoch_id: &EpochId, operation_tree: &VcOperationTree, materials: &[(KeyPackageRef, RetainedKeyPackageMaterial)], ) -> Result<(), <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::{impl#3}::write_retained_key_package_material_batch::{constant#3}>, VcOperationTree: VcOperationTree<openmls_memory_storage::::{impl#3}::write_retained_key_package_material_batch::{constant#4}>, KeyPackageRef: HashReference<openmls_memory_storage::::{impl#3}::write_retained_key_package_material_batch::{constant#5}>, RetainedKeyPackageMaterial: RetainedKeyPackageMaterial<openmls_memory_storage::::{impl#3}::write_retained_key_package_material_batch::{constant#6}>,

Available on crate feature virtual-clients-draft only.

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

where KeyPackageRef: HashReference<openmls_memory_storage::::{impl#3}::retained_key_package_material::{constant#1}>, RetainedKeyPackageMaterial: RetainedKeyPackageMaterial<openmls_memory_storage::::{impl#3}::retained_key_package_material::{constant#2}>,

Available on crate feature virtual-clients-draft only.

fn has_retained_key_package_material_for_epoch<EpochId>( &self, epoch_id: &EpochId, ) -> Result<bool, <MemoryStorage as StorageProvider<openmls_memory_storage::::{impl#3}::{constant#0}>>::Error>

where EpochId: VcEpochId<openmls_memory_storage::::{impl#3}::has_retained_key_package_material_for_epoch::{constant#0}>,

Available on crate feature virtual-clients-draft only.

fn delete_retained_key_package_material<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_retained_key_package_material::{constant#2}>,

Available on crate feature virtual-clients-draft only.

Implementors