Trait CryptoStore

pub trait CryptoStore: AsyncTraitDeps {
    type Error: Debug + Into<CryptoStoreError>;

    // Required methods
    fn load_account<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_identity<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Option<PrivateCrossSigningIdentity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_changes<'life0, 'async_trait>(
        &'life0 self,
        changes: Changes,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_pending_changes<'life0, 'async_trait>(
        &'life0 self,
        changes: PendingChanges,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_inbound_group_sessions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        sessions: Vec<InboundGroupSession>,
        backed_up_to_version: Option<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_sessions<'life0, 'life1, 'async_trait>(
        &'life0 self,
        sender_key: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Session>>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_inbound_group_session<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId,
        session_id: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_withheld_info<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId,
        session_id: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<RoomKeyWithheldEvent>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_inbound_group_sessions<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn inbound_group_session_counts<'life0, 'life1, 'async_trait>(
        &'life0 self,
        backup_version: Option<&'life1 str>,
    ) -> Pin<Box<dyn Future<Output = Result<RoomKeyCounts, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_inbound_group_sessions_for_device_batch<'life0, 'async_trait>(
        &'life0 self,
        curve_key: Curve25519PublicKey,
        sender_data_type: SenderDataType,
        after_session_id: Option<String>,
        limit: usize,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn inbound_group_sessions_for_backup<'life0, 'life1, 'async_trait>(
        &'life0 self,
        backup_version: &'life1 str,
        limit: usize,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn mark_inbound_group_sessions_as_backed_up<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        backup_version: &'life1 str,
        room_and_session_ids: &'life2 [(&'life3 RoomId, &'life4 str)],
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn reset_backup_state<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_backup_keys<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<BackupKeys, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_dehydrated_device_pickle_key<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Option<DehydratedDeviceKey>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete_dehydrated_device_pickle_key<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_outbound_group_session<'life0, 'life1, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<OutboundGroupSession>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_tracked_users<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<TrackedUser>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_tracked_users<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        users: &'life1 [(&'life2 UserId, bool)],
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_device<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        user_id: &'life1 UserId,
        device_id: &'life2 DeviceId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<DeviceData>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_user_devices<'life0, 'life1, 'async_trait>(
        &'life0 self,
        user_id: &'life1 UserId,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<OwnedDeviceId, DeviceData>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_own_device<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<DeviceData, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_user_identity<'life0, 'life1, 'async_trait>(
        &'life0 self,
        user_id: &'life1 UserId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<UserIdentityData>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_message_known<'life0, 'life1, 'async_trait>(
        &'life0 self,
        message_hash: &'life1 OlmMessageHash,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_outgoing_secret_requests<'life0, 'life1, 'async_trait>(
        &'life0 self,
        request_id: &'life1 TransactionId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_secret_request_by_info<'life0, 'life1, 'async_trait>(
        &'life0 self,
        secret_info: &'life1 SecretInfo,
    ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_unsent_secret_requests<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GossipRequest>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete_outgoing_secret_requests<'life0, 'life1, 'async_trait>(
        &'life0 self,
        request_id: &'life1 TransactionId,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_secrets_from_inbox<'life0, 'life1, 'async_trait>(
        &'life0 self,
        secret_name: &'life1 SecretName,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GossippedSecret>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_secrets_from_inbox<'life0, 'life1, 'async_trait>(
        &'life0 self,
        secret_name: &'life1 SecretName,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_room_settings<'life0, 'life1, 'async_trait>(
        &'life0 self,
        room_id: &'life1 RoomId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<RoomSettings>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_custom_value<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn set_custom_value<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 str,
        value: Vec<u8>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn remove_custom_value<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn try_take_leased_lock<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        lease_duration_ms: u32,
        key: &'life1 str,
        holder: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn next_batch_token<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Represents a store that the OlmMachine uses to store E2EE data (such as cryptographic keys).

Required Associated Types

type Error: Debug + Into<CryptoStoreError>

The error type used by this crypto store.

Required Methods

fn load_account<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load an account that was previously stored.

fn load_identity<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<PrivateCrossSigningIdentity>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Try to load a private cross signing identity, if one is stored.

fn save_changes<'life0, 'async_trait>( &'life0 self, changes: Changes, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save the set of changes to the store.

Arguments

• changes - The set of changes that should be stored.

fn save_pending_changes<'life0, 'async_trait>( &'life0 self, changes: PendingChanges, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save the set of changes to the store.

This is an updated version of save_changes that will replace it as #2624 makes progress.

Arguments

• changes - The set of changes that should be stored.

fn save_inbound_group_sessions<'life0, 'life1, 'async_trait>( &'life0 self, sessions: Vec<InboundGroupSession>, backed_up_to_version: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save a list of inbound group sessions to the store.

Arguments

• sessions - The sessions to be saved.
• backed_up_to_version - If the keys should be marked as having been backed up, the version of the backup.

Note: some implementations ignore backup_version and assume the current backup version, which is normally the same.

fn get_sessions<'life0, 'life1, 'async_trait>( &'life0 self, sender_key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Session>>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all the sessions that belong to the given sender key.

Arguments

• sender_key - The sender key that was used to establish the sessions.

fn get_inbound_group_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, session_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get the inbound group session from our store.

Arguments

• room_id - The room id of the room that the session belongs to.

• sender_key - The sender key that sent us the session.

• session_id - The unique id of the session.

fn get_withheld_info<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, session_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<RoomKeyWithheldEvent>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get withheld info for this key. Allows to know if the session was not sent on purpose. This only returns withheld info sent by the owner of the group session, not the one you can get from a response to a key request from another of your device.

fn get_inbound_group_sessions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get all the inbound group sessions we have stored.

fn inbound_group_session_counts<'life0, 'life1, 'async_trait>( &'life0 self, backup_version: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<RoomKeyCounts, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the number inbound group sessions we have and how many of them are backed up.

fn get_inbound_group_sessions_for_device_batch<'life0, 'async_trait>( &'life0 self, curve_key: Curve25519PublicKey, sender_data_type: SenderDataType, after_session_id: Option<String>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a batch of inbound group sessions for the device with the supplied curve key, whose sender data is of the supplied type.

Sessions are not necessarily returned in any specific order, but the returned batches are consistent: if this function is called repeatedly with after_session_id set to the session ID from the last result from the previous call, until an empty result is returned, then eventually all matching sessions are returned. (New sessions that are added in the course of iteration may or may not be returned.)

This function is used when the device information is updated via a /keys/query response and we want to update the sender data based on the new information.

Arguments

• curve_key - only return sessions created by the device with this curve key.

• sender_data_type - only return sessions whose SenderData record is in this state.

• after_session_id - return the sessions after this id, or start at the earliest if this is None.

• limit - return a maximum of this many sessions.

fn inbound_group_sessions_for_backup<'life0, 'life1, 'async_trait>( &'life0 self, backup_version: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Return a batch of [‘InboundGroupSession’] (“room keys”) that have not yet been backed up in the supplied backup version.

The size of the returned Vec is <= limit.

Note: some implementations ignore backup_version and assume the current backup version, which is normally the same.

fn mark_inbound_group_sessions_as_backed_up<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, backup_version: &'life1 str, room_and_session_ids: &'life2 [(&'life3 RoomId, &'life4 str)], ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Store the fact that the supplied sessions were backed up into the backup with version backup_version.

Note: some implementations ignore backup_version and assume the current backup version, which is normally the same.

fn reset_backup_state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reset the backup state of all the stored inbound group sessions.

Note: this is mostly implemented by stores that ignore the backup_version argument on inbound_group_sessions_for_backup and mark_inbound_group_sessions_as_backed_up. Implementations that pay attention to the supplied backup version probably don’t need to update their storage when the current backup version changes, so have empty implementations of this method.

fn load_backup_keys<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<BackupKeys, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the backup keys we have stored.

fn load_dehydrated_device_pickle_key<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<DehydratedDeviceKey>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the dehydrated device pickle key we have stored.

fn delete_dehydrated_device_pickle_key<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Deletes the previously stored dehydrated device pickle key.

fn get_outbound_group_session<'life0, 'life1, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, ) -> Pin<Box<dyn Future<Output = Result<Option<OutboundGroupSession>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the outbound group session we have stored that is used for the given room.

fn load_tracked_users<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<TrackedUser>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide the list of users whose devices we are keeping track of, and whether they are considered dirty/outdated.

fn save_tracked_users<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, users: &'life1 [(&'life2 UserId, bool)], ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update the list of users whose devices we are keeping track of, and whether they are considered dirty/outdated.

Replaces any existing entry with a matching user ID.

fn get_device<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, user_id: &'life1 UserId, device_id: &'life2 DeviceId, ) -> Pin<Box<dyn Future<Output = Result<Option<DeviceData>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get the device for the given user with the given device ID.

Arguments

• user_id - The user that the device belongs to.

• device_id - The unique id of the device.

fn get_user_devices<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 UserId, ) -> Pin<Box<dyn Future<Output = Result<HashMap<OwnedDeviceId, DeviceData>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all the devices of the given user.

Arguments

• user_id - The user for which we should get all the devices.

fn get_own_device<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<DeviceData, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the device for the current client.

Since our own device is set when the store is created, this will always return a device (unless there is an error).

fn get_user_identity<'life0, 'life1, 'async_trait>( &'life0 self, user_id: &'life1 UserId, ) -> Pin<Box<dyn Future<Output = Result<Option<UserIdentityData>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the user identity that is attached to the given user id.

Arguments

• user_id - The user for which we should get the identity.

fn is_message_known<'life0, 'life1, 'async_trait>( &'life0 self, message_hash: &'life1 OlmMessageHash, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a hash for an Olm message stored in the database.

fn get_outgoing_secret_requests<'life0, 'life1, 'async_trait>( &'life0 self, request_id: &'life1 TransactionId, ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get an outgoing secret request that we created that matches the given request id.

Arguments

• request_id - The unique request id that identifies this outgoing secret request.

fn get_secret_request_by_info<'life0, 'life1, 'async_trait>( &'life0 self, secret_info: &'life1 SecretInfo, ) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get an outgoing key request that we created that matches the given requested key info.

Arguments

• key_info - The key info of an outgoing secret request.

fn get_unsent_secret_requests<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<GossipRequest>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get all outgoing secret requests that we have in the store.

fn delete_outgoing_secret_requests<'life0, 'life1, 'async_trait>( &'life0 self, request_id: &'life1 TransactionId, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete an outgoing key request that we created that matches the given request id.

Arguments

• request_id - The unique request id that identifies this outgoing key request.

fn get_secrets_from_inbox<'life0, 'life1, 'async_trait>( &'life0 self, secret_name: &'life1 SecretName, ) -> Pin<Box<dyn Future<Output = Result<Vec<GossippedSecret>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all the secrets with the given SecretName we have currently stored.

fn delete_secrets_from_inbox<'life0, 'life1, 'async_trait>( &'life0 self, secret_name: &'life1 SecretName, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete all the secrets with the given SecretName we have currently stored.

fn get_room_settings<'life0, 'life1, 'async_trait>( &'life0 self, room_id: &'life1 RoomId, ) -> Pin<Box<dyn Future<Output = Result<Option<RoomSettings>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the room settings, such as the encryption algorithm or whether to encrypt only for trusted devices.

Arguments

• room_id - The room id of the room

fn get_custom_value<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get arbitrary data from the store

Arguments

• key - The key to fetch data for

fn set_custom_value<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, value: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Put arbitrary data into the store

Arguments

• key - The key to insert data into

• value - The value to insert

fn remove_custom_value<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove arbitrary data into the store

Arguments

• key - The key to insert data into

fn try_take_leased_lock<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, lease_duration_ms: u32, key: &'life1 str, holder: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Try to take a leased lock.

This attempts to take a lock for the given lease duration.

• If we already had the lease, this will extend the lease.
• If we didn’t, but the previous lease has expired, we will acquire the lock.
• If there was no previous lease, we will acquire the lock.
• Otherwise, we don’t get the lock.

Returns whether taking the lock succeeded.

fn next_batch_token<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load the next-batch token for a to-device query, if any.

Implementors

impl CryptoStore for MemoryStore

type Error = Infallible