Trait matrix_sdk_crypto::store::CryptoStore

source · [−]
pub trait CryptoStore: AsyncTraitDeps {

Show 25 methods    fn load_account<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyAccount>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn save_account<'life0, 'async_trait>(
        &'life0 self, 
        account: ReadOnlyAccount
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn load_identity<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Option<PrivateCrossSigningIdentity>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn save_changes<'life0, 'async_trait>(
        &'life0 self, 
        changes: Changes
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn get_sessions<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        sender_key: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<Mutex<Vec<Session>>>>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;
    fn get_inbound_group_session<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self, 
        room_id: &'life1 RoomId, 
        sender_key: &'life2 str, 
        session_id: &'life3 str
    ) -> Pin<Box<dyn Future<Output = Result<Option<InboundGroupSession>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        'life3: 'async_trait,
        Self: 'async_trait;
    fn get_inbound_group_sessions<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn inbound_group_session_counts<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<RoomKeyCounts>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn inbound_group_sessions_for_backup<'life0, 'async_trait>(
        &'life0 self, 
        limit: usize
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn reset_backup_state<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn load_backup_keys<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<BackupKeys>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn get_outbound_group_sessions<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        room_id: &'life1 RoomId
    ) -> Pin<Box<dyn Future<Output = Result<Option<OutboundGroupSession>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;
    fn is_user_tracked(&self, user_id: &UserId) -> bool;
    fn has_users_for_key_query(&self) -> bool;
    fn users_for_key_query(&self) -> HashSet<OwnedUserId>;
    fn tracked_users(&self) -> HashSet<OwnedUserId>;
    fn update_tracked_user<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        user: &'life1 UserId, 
        dirty: bool
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: '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<ReadOnlyDevice>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;
    fn get_user_devices<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        user_id: &'life1 UserId
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<OwnedDeviceId, ReadOnlyDevice>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;
    fn get_user_identity<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        user_id: &'life1 UserId
    ) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyUserIdentities>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;
    fn is_message_known<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        message_hash: &'life1 OlmMessageHash
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: '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>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: '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>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;
    fn get_unsent_secret_requests<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = Result<Vec<GossipRequest>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_outgoing_secret_requests<'life0, 'life1, 'async_trait>(
        &'life0 self, 
        request_id: &'life1 TransactionId
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

}
Expand description

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

Required Methods

Load an account that was previously stored.

Save the given account in the store.

Arguments
  • account - The account that should be stored.

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

Save the set of changes to the store.

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

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

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

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.

Get all the inbound group sessions we have stored.

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

Get all the inbound group sessions we have not backed up yet.

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

Get the backup keys we have stored.

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

Is the given user already tracked.

Are there any tracked users that are marked as dirty.

Set of users that we need to query keys for. This is a subset of the tracked users.

Get all tracked users we know about.

Add an user for tracking.

Returns true if the user wasn’t already tracked, false otherwise.

Arguments

  • user - The user that should be marked as tracked.

  • dirty - Should the user be also marked for a key query.

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.

Get all the devices of the given user.

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

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

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

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

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.

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.

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

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.

Implementors