crypto: Add a method to check if a user identity is verified

matrix_sdk_crypto/src/identities/user.rs

@@ -169,6 +169,7 @@ impl OwnUserIdentity {
 #[derive(Debug, Clone)]
 pub struct UserIdentity {
     pub(crate) inner: ReadOnlyUserIdentity,
+    pub(crate) own_identity: Option<ReadOnlyOwnUserIdentity>,
     pub(crate) verification_machine: VerificationMachine,
 }
 
@@ -181,6 +182,14 @@ impl Deref for UserIdentity {
 }
 
 impl UserIdentity {
+    /// Is this user identity verified.
+    pub fn verified(&self) -> bool {
+        self.own_identity
+            .as_ref()
+            .map(|o| o.is_identity_signed(&self.inner).is_ok())
+            .unwrap_or(false)
+    }
+
     /// Create a `VerificationRequest` object after the verification request
     /// content has been sent out.
     pub async fn request_verification(

matrix_sdk_crypto/src/store/mod.rs

@@ -290,31 +290,57 @@ impl Store {
         user_id: &UserId,
         device_id: &DeviceId,
     ) -> Result<Option<Device>> {
-        let own_identity =
+        if user_id == self.user_id() && device_id == self.device_id() {
-            self.inner.get_user_identity(&self.user_id).await?.map(|i| i.own().cloned()).flatten();
+            Ok(None)
-        let device_owner_identity = self.inner.get_user_identity(user_id).await?;
+        } else {
+            let own_identity = self
+                .inner
+                .get_user_identity(&self.user_id)
+                .await?
+                .map(|i| i.own().cloned())
+                .flatten();
+            let device_owner_identity = self.inner.get_user_identity(user_id).await?;
 
-        Ok(self.inner.get_device(user_id, device_id).await?.map(|d| Device {
+            Ok(self.inner.get_device(user_id, device_id).await?.map(|d| Device {
-            inner: d,
+                inner: d,
-            private_identity: self.identity.clone(),
+                private_identity: self.identity.clone(),
-            verification_machine: self.verification_machine.clone(),
+                verification_machine: self.verification_machine.clone(),
-            own_identity,
+                own_identity,
-            device_owner_identity,
+                device_owner_identity,
-        }))
+            }))
+        }
     }
 
     pub async fn get_identity(&self, user_id: &UserId) -> Result<Option<UserIdentities>> {
-        Ok(self.inner.get_user_identity(user_id).await?.map(|i| match i {
+        // let own_identity =
-            ReadOnlyUserIdentities::Own(i) => OwnUserIdentity {
+        // self.inner.get_user_identity(self.user_id()).await?.and_then(|i| i.own());
-                inner: i,
+        Ok(if let Some(identity) = self.inner.get_user_identity(user_id).await? {
-                verification_machine: self.verification_machine.clone(),
+            Some(match identity {
-            }
+                ReadOnlyUserIdentities::Own(i) => OwnUserIdentity {
-            .into(),
+                    inner: i,
-            ReadOnlyUserIdentities::Other(i) => {
+                    verification_machine: self.verification_machine.clone(),
-                UserIdentity { inner: i, verification_machine: self.verification_machine.clone() }
+                }
+                .into(),
+                ReadOnlyUserIdentities::Other(i) => {
+                    let own_identity =
+                        self.inner.get_user_identity(self.user_id()).await?.and_then(|i| {
+                            if let ReadOnlyUserIdentities::Own(i) = i {
+                                Some(i)
+                            } else {
+                                None
+                            }
+                        });
+                    UserIdentity {
+                        inner: i,
+                        verification_machine: self.verification_machine.clone(),
+                        own_identity,
+                    }
                     .into()
-            }
+                }
-        }))
+            })
+        } else {
+            None
+        })
     }
 
     /// Try to export the secret with the given secret name.

matrix_sdk_crypto/src/store/sled.rs

@@ -665,12 +665,7 @@ impl CryptoStore for SledStore {
         device_id: &DeviceId,
     ) -> Result<Option<ReadOnlyDevice>> {
         let key = (user_id.as_str(), device_id.as_str()).encode();
-
+        Ok(self.devices.get(key)?.map(|d| serde_json::from_slice(&d)).transpose()?)
-        if let Some(d) = self.devices.get(key)? {
-            Ok(Some(serde_json::from_slice(&d)?))
-        } else {
-            Ok(None)
-        }
     }
 
     async fn get_user_devices(