refactor(crypto)!: Add an error type to the CryptoStore trait

This makes it easier to implement it. However, using a different error
type than CryptoStoreError is a non-trivial change, so left for the
coming commits for all stores except the memory store.

Author: jplatte

crates/matrix-sdk-base/src/client.rs

@@ -25,7 +25,7 @@ use futures_signals::signal::ReadOnlyMutable;
 use matrix_sdk_common::{instant::Instant, locks::RwLock};
 #[cfg(feature = "e2e-encryption")]
 use matrix_sdk_crypto::{
-    store::CryptoStore, EncryptionSettings, OlmError, OlmMachine, ToDeviceRequest,
+    store::DynCryptoStore, EncryptionSettings, OlmError, OlmMachine, ToDeviceRequest,
 };
 #[cfg(feature = "e2e-encryption")]
 use once_cell::sync::OnceCell;
@@ -82,7 +82,7 @@ pub struct BaseClient {
     /// This field is only meant to be used for `OlmMachine` initialization.
     /// All operations on it happen inside the `OlmMachine`.
     #[cfg(feature = "e2e-encryption")]
-    crypto_store: Arc<dyn CryptoStore>,
+    crypto_store: Arc<DynCryptoStore>,
     /// The olm-machine that is created once the
     /// [`SessionMeta`][crate::session::SessionMeta] is set via
     /// [`BaseClient::set_session_meta`]

crates/matrix-sdk-base/src/store/mod.rs

@@ -42,7 +42,7 @@ use async_trait::async_trait;
 use dashmap::DashMap;
 use matrix_sdk_common::{locks::RwLock, AsyncTraitDeps};
 #[cfg(feature = "e2e-encryption")]
-use matrix_sdk_crypto::store::{CryptoStore, IntoCryptoStore};
+use matrix_sdk_crypto::store::{DynCryptoStore, IntoCryptoStore};
 pub use matrix_sdk_store_encryption::Error as StoreEncryptionError;
 use ruma::{
     api::client::push::get_notifications::v3::Notification,
@@ -839,7 +839,7 @@ impl StateChanges {
 #[derive(Clone)]
 pub struct StoreConfig {
     #[cfg(feature = "e2e-encryption")]
-    pub(crate) crypto_store: Arc<dyn CryptoStore>,
+    pub(crate) crypto_store: Arc<DynCryptoStore>,
     pub(crate) state_store: Arc<dyn StateStore>,
 }
 
@@ -856,7 +856,7 @@ impl StoreConfig {
     pub fn new() -> Self {
         Self {
             #[cfg(feature = "e2e-encryption")]
-            crypto_store: Arc::new(matrix_sdk_crypto::store::MemoryStore::new()),
+            crypto_store: matrix_sdk_crypto::store::MemoryStore::new().into_crypto_store(),
             state_store: Arc::new(MemoryStore::new()),
         }
     }

crates/matrix-sdk-crypto/src/gossiping/machine.rs

@@ -1011,7 +1011,7 @@ mod tests {
         identities::{LocalTrust, ReadOnlyDevice},
         olm::{Account, OutboundGroupSession, PrivateCrossSigningIdentity, ReadOnlyAccount},
         session_manager::GroupSessionCache,
-        store::{Changes, CryptoStore, MemoryStore, Store},
+        store::{Changes, IntoCryptoStore, MemoryStore, Store},
         types::{
             events::{
                 forwarded_room_key::ForwardedRoomKeyContent,
@@ -1068,7 +1068,7 @@ mod tests {
         let device_id = DeviceId::new();
 
         let account = ReadOnlyAccount::new(&user_id, &device_id);
-        let store: Arc<dyn CryptoStore> = Arc::new(MemoryStore::new());
+        let store = MemoryStore::new().into_crypto_store();
         let identity = Arc::new(Mutex::new(PrivateCrossSigningIdentity::empty(alice_id())));
         let verification = VerificationMachine::new(account, identity.clone(), store.clone());
         let store = Store::new(user_id.to_owned(), identity, store, verification);
@@ -1090,7 +1090,7 @@ mod tests {
         let another_device =
             ReadOnlyDevice::from_account(&ReadOnlyAccount::new(&user_id, alice2_device_id())).await;
 
-        let store: Arc<dyn CryptoStore> = Arc::new(MemoryStore::new());
+        let store = MemoryStore::new().into_crypto_store();
         let identity = Arc::new(Mutex::new(PrivateCrossSigningIdentity::empty(alice_id())));
         let verification = VerificationMachine::new(account, identity.clone(), store.clone());
 

crates/matrix-sdk-crypto/src/identities/device.rs

@@ -41,7 +41,7 @@ use crate::{
     error::{EventError, OlmError, OlmResult, SignatureError},
     identities::{ReadOnlyOwnUserIdentity, ReadOnlyUserIdentities},
     olm::{InboundGroupSession, Session, SignedJsonObject, VerifyJson},
-    store::{Changes, CryptoStore, DeviceChanges, Result as StoreResult},
+    store::{Changes, DeviceChanges, DynCryptoStore, Result as StoreResult},
     types::{
         events::{
             forwarded_room_key::ForwardedRoomKeyContent,
@@ -570,7 +570,7 @@ impl ReadOnlyDevice {
 
     pub(crate) async fn encrypt(
         &self,
-        store: &dyn CryptoStore,
+        store: &DynCryptoStore,
         event_type: &str,
         content: Value,
     ) -> OlmResult<(Session, Raw<ToDeviceEncryptedEventContent>)> {

crates/matrix-sdk-crypto/src/identities/manager.rs

@@ -667,7 +667,7 @@ pub(crate) mod testing {
         identities::IdentityManager,
         machine::testing::response_from_file,
         olm::{PrivateCrossSigningIdentity, ReadOnlyAccount},
-        store::{CryptoStore, MemoryStore, Store},
+        store::{DynCryptoStore, IntoCryptoStore, MemoryStore, Store},
         types::DeviceKeys,
         verification::VerificationMachine,
         UploadSigningKeysRequest,
@@ -690,10 +690,14 @@ pub(crate) mod testing {
         let identity = Arc::new(Mutex::new(identity));
         let user_id = Arc::from(user_id());
         let account = ReadOnlyAccount::new(&user_id, device_id());
-        let store: Arc<dyn CryptoStore> = Arc::new(MemoryStore::new());
+        let store: Arc<DynCryptoStore> = MemoryStore::new().into_crypto_store();
         let verification = VerificationMachine::new(account, identity.clone(), store);
-        let store =
-            Store::new(user_id.clone(), identity, Arc::new(MemoryStore::new()), verification);
+        let store = Store::new(
+            user_id.clone(),
+            identity,
+            MemoryStore::new().into_crypto_store(),
+            verification,
+        );
         IdentityManager::new(user_id, device_id().into(), store)
     }
 

crates/matrix-sdk-crypto/src/identities/user.rs

@@ -1061,7 +1061,7 @@ pub(crate) mod tests {
             Device, MasterPubkey, SelfSigningPubkey, UserSigningPubkey,
         },
         olm::{PrivateCrossSigningIdentity, ReadOnlyAccount},
-        store::MemoryStore,
+        store::{IntoCryptoStore, MemoryStore},
         types::CrossSigningKey,
         verification::VerificationMachine,
     };
@@ -1105,7 +1105,7 @@ pub(crate) mod tests {
         let verification_machine = VerificationMachine::new(
             ReadOnlyAccount::new(second.user_id(), second.device_id()),
             private_identity,
-            Arc::new(MemoryStore::new()),
+            MemoryStore::new().into_crypto_store(),
         );
 
         let first = Device {
@@ -1146,7 +1146,7 @@ pub(crate) mod tests {
         let verification_machine = VerificationMachine::new(
             ReadOnlyAccount::new(device.user_id(), device.device_id()),
             id.clone(),
-            Arc::new(MemoryStore::new()),
+            MemoryStore::new().into_crypto_store(),
         );
 
         let public_identity = identity.to_public_identity().await.unwrap();

crates/matrix-sdk-crypto/src/machine.rs

@@ -66,7 +66,7 @@ use crate::{
     requests::{IncomingResponse, OutgoingRequest, UploadSigningKeysRequest},
     session_manager::{GroupSessionManager, SessionManager},
     store::{
-        Changes, CryptoStore, DeviceChanges, IdentityChanges, IntoCryptoStore, MemoryStore,
+        Changes, DeviceChanges, DynCryptoStore, IdentityChanges, IntoCryptoStore, MemoryStore,
         Result as StoreResult, SecretImportError, Store,
     },
     types::{
@@ -153,7 +153,7 @@ impl OlmMachine {
     fn new_helper(
         user_id: &UserId,
         device_id: &DeviceId,
-        store: Arc<dyn CryptoStore>,
+        store: Arc<DynCryptoStore>,
         account: ReadOnlyAccount,
         user_identity: PrivateCrossSigningIdentity,
     ) -> Self {

crates/matrix-sdk-crypto/src/session_manager/sessions.rs

@@ -415,7 +415,7 @@ mod tests {
         identities::{KeysQueryListener, ReadOnlyDevice},
         olm::{Account, PrivateCrossSigningIdentity, ReadOnlyAccount},
         session_manager::GroupSessionCache,
-        store::{CryptoStore, MemoryStore, Store},
+        store::{IntoCryptoStore, MemoryStore, Store},
         verification::VerificationMachine,
     };
 
@@ -464,7 +464,7 @@ mod tests {
 
         let users_for_key_claim = Arc::new(DashMap::new());
         let account = ReadOnlyAccount::new(user_id, device_id);
-        let store: Arc<dyn CryptoStore> = Arc::new(MemoryStore::new());
+        let store = MemoryStore::new().into_crypto_store();
         store.save_account(account.clone()).await.unwrap();
         let identity = Arc::new(Mutex::new(PrivateCrossSigningIdentity::empty(user_id)));
         let verification =

crates/matrix-sdk-crypto/src/store/error.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{fmt::Debug, io::Error as IoError};
+use std::{convert::Infallible, fmt::Debug, io::Error as IoError};
 
 use ruma::{IdParseError, OwnedDeviceId, OwnedUserId};
 use serde_json::Error as SerdeError;
@@ -92,3 +92,9 @@ impl CryptoStoreError {
         Self::Backend(Box::new(error))
     }
 }
+
+impl From<Infallible> for CryptoStoreError {
+    fn from(never: Infallible) -> Self {
+        match never {}
+    }
+}

crates/matrix-sdk-crypto/src/store/memorystore.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, convert::Infallible, sync::Arc};
 
 use async_trait::async_trait;
 use dashmap::{DashMap, DashSet};
@@ -23,8 +23,7 @@ use ruma::{
 
 use super::{
     caches::{DeviceStore, GroupSessionStore, SessionStore},
-    BackupKeys, Changes, CryptoStore, InboundGroupSession, ReadOnlyAccount, Result, RoomKeyCounts,
-    Session,
+    BackupKeys, Changes, CryptoStore, InboundGroupSession, ReadOnlyAccount, RoomKeyCounts, Session,
 };
 use crate::{
     gossiping::{GossipRequest, SecretInfo},
@@ -99,9 +98,13 @@ impl MemoryStore {
     }
 }
 
+type Result<T> = std::result::Result<T, Infallible>;
+
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl CryptoStore for MemoryStore {
+    type Error = Infallible;
+
     async fn load_account(&self) -> Result<Option<ReadOnlyAccount>> {
         Ok(None)
     }