Trait matrix_sdk_crypto::store::CryptoStore

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


Show 35 methods    // 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 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;

}
Expand description

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

Required Associated Types§

source

type Error: Debug + Into<CryptoStoreError>

The error type used by this crypto store.

Required Methods§

source

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.

source

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.

source

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

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

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.

source

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

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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

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

source

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

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.

source

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

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

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.

source

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

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.

source

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.

source

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
source

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
source

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

source

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
source

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.

source

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§