diff --git a/bindings/matrix-sdk-crypto-ffi/src/machine.rs b/bindings/matrix-sdk-crypto-ffi/src/machine.rs
index e9a36ecff..65ed31b0d 100644
--- a/bindings/matrix-sdk-crypto-ffi/src/machine.rs
+++ b/bindings/matrix-sdk-crypto-ffi/src/machine.rs
@@ -173,7 +173,7 @@ impl OlmMachine {
             {
                 match identity {
                     UserIdentities::Own(i) => i.is_verified(),
-                    UserIdentities::Other(i) => i.verified(),
+                    UserIdentities::Other(i) => i.is_verified(),
                 }
             } else {
                 false
diff --git a/bindings/matrix-sdk-ffi/src/session_verification.rs b/bindings/matrix-sdk-ffi/src/session_verification.rs
index 88b39e836..52434a5be 100644
--- a/bindings/matrix-sdk-ffi/src/session_verification.rs
+++ b/bindings/matrix-sdk-ffi/src/session_verification.rs
@@ -58,7 +58,7 @@ impl SessionVerificationController {
     }
 
     pub fn is_verified(&self) -> bool {
-        self.user_identity.verified()
+        self.user_identity.is_verified()
     }
 
     pub fn request_verification(&self) -> anyhow::Result<()> {
diff --git a/crates/matrix-sdk-crypto/src/backups/mod.rs b/crates/matrix-sdk-crypto/src/backups/mod.rs
index b8383c3bd..d77c12424 100644
--- a/crates/matrix-sdk-crypto/src/backups/mod.rs
+++ b/crates/matrix-sdk-crypto/src/backups/mod.rs
@@ -224,7 +224,7 @@ impl BackupMachine {
         auth_data: &str,
     ) -> SignatureState {
         if device.has_signed_raw(signatures, auth_data).is_ok() {
-            if device.verified() {
+            if device.is_verified() {
                 SignatureState::ValidAndTrusted
             } else {
                 SignatureState::ValidButNotTrusted
diff --git a/crates/matrix-sdk-crypto/src/gossiping/machine.rs b/crates/matrix-sdk-crypto/src/gossiping/machine.rs
index 25b9c4aef..12bc5333a 100644
--- a/crates/matrix-sdk-crypto/src/gossiping/machine.rs
+++ b/crates/matrix-sdk-crypto/src/gossiping/machine.rs
@@ -252,7 +252,7 @@ impl GossipMachine {
 
         Ok(if let Some(device) = device {
             if device.user_id() == self.user_id() {
-                if device.verified() {
+                if device.is_verified() {
                     info!(
                         user_id = device.user_id().as_str(),
                         device_id = device.device_id().as_str(),
@@ -536,7 +536,7 @@ impl GossipMachine {
 
         // If this is our own, verified device, we share the entire session from the
         // earliest known index.
-        if device.user_id() == self.user_id() && device.verified() {
+        if device.user_id() == self.user_id() && device.is_verified() {
             Ok(None)
         // Otherwise, if the records show we previously shared with this device,
         // we'll reshare the session from the index we previously shared
@@ -834,7 +834,7 @@ impl GossipMachine {
             self.store.get_device_from_curve_key(&event.sender, sender_key).await?
         {
             // Only accept secrets from one of our own trusted devices.
-            if device.user_id() == self.user_id() && device.verified() {
+            if device.user_id() == self.user_id() && device.is_verified() {
                 self.accept_secret(event, request, secret_name).await?;
             } else {
                 warn!(
diff --git a/crates/matrix-sdk-crypto/src/identities/device.rs b/crates/matrix-sdk-crypto/src/identities/device.rs
index 64a6fc7e9..65cb364f9 100644
--- a/crates/matrix-sdk-crypto/src/identities/device.rs
+++ b/crates/matrix-sdk-crypto/src/identities/device.rs
@@ -222,8 +222,8 @@ impl Device {
     ///
     /// [`is_locally_trusted()`]: #method.is_locally_trusted
     /// [`is_cross_signing_trusted()`]: #method.is_cross_signing_trusted
-    pub fn verified(&self) -> bool {
-        self.inner.verified(&self.own_identity, &self.device_owner_identity)
+    pub fn is_verified(&self) -> bool {
+        self.inner.is_verified(&self.own_identity, &self.device_owner_identity)
     }
 
     /// Is this device considered to be verified using cross signing.
@@ -352,7 +352,7 @@ impl UserDevices {
             .filter(|d| {
                 !(d.user_id() == self.own_user_id() && d.device_id() == self.own_device_id())
             })
-            .any(|d| d.verified(&self.own_identity, &self.device_owner_identity))
+            .any(|d| d.is_verified(&self.own_identity, &self.device_owner_identity))
     }
 
     /// Iterator over all the device ids of the user devices.
@@ -525,11 +525,11 @@ impl ReadOnlyDevice {
     }
 
     /// Is the device deleted.
-    pub fn deleted(&self) -> bool {
+    pub fn is_deleted(&self) -> bool {
         self.deleted.load(Ordering::Relaxed)
     }
 
-    pub(crate) fn verified(
+    pub(crate) fn is_verified(
         &self,
         own_identity: &Option<ReadOnlyOwnUserIdentity>,
         device_owner: &Option<ReadOnlyUserIdentities>,
@@ -809,12 +809,12 @@ pub(crate) mod tests {
     #[test]
     fn delete_a_device() {
         let device = get_device();
-        assert!(!device.deleted());
+        assert!(!device.is_deleted());
 
         let device_clone = device.clone();
 
         device.mark_as_deleted();
-        assert!(device.deleted());
-        assert!(device_clone.deleted());
+        assert!(device.is_deleted());
+        assert!(device_clone.is_deleted());
     }
 }
diff --git a/crates/matrix-sdk-crypto/src/identities/user.rs b/crates/matrix-sdk-crypto/src/identities/user.rs
index d38d8fb2e..55f78019d 100644
--- a/crates/matrix-sdk-crypto/src/identities/user.rs
+++ b/crates/matrix-sdk-crypto/src/identities/user.rs
@@ -207,7 +207,7 @@ impl Deref for UserIdentity {
 
 impl UserIdentity {
     /// Is this user identity verified.
-    pub fn verified(&self) -> bool {
+    pub fn is_verified(&self) -> bool {
         self.own_identity
             .as_ref()
             .map(|o| o.is_identity_signed(&self.inner).is_ok())
@@ -1046,8 +1046,8 @@ pub(crate) mod tests {
         assert!(!first.is_cross_signing_trusted());
 
         identity.mark_as_verified();
-        assert!(second.verified());
-        assert!(!first.verified());
+        assert!(second.is_verified());
+        assert!(!first.is_verified());
     }
 
     #[async_test]
@@ -1075,12 +1075,12 @@ pub(crate) mod tests {
             device_owner_identity: Some(public_identity.clone().into()),
         };
 
-        assert!(!device.verified());
+        assert!(!device.is_verified());
 
         let mut device_keys = device.as_device_keys().to_owned();
 
         identity.sign_device_keys(&mut device_keys).await.unwrap();
         device.inner.update_device(&device_keys).expect("Couldn't update newly signed device keys");
-        assert!(device.verified());
+        assert!(device.is_verified());
     }
 }
diff --git a/crates/matrix-sdk-crypto/src/machine.rs b/crates/matrix-sdk-crypto/src/machine.rs
index 3c92f711a..d753e5d20 100644
--- a/crates/matrix-sdk-crypto/src/machine.rs
+++ b/crates/matrix-sdk-crypto/src/machine.rs
@@ -1045,7 +1045,7 @@ impl OlmMachine {
                 //     a) This is our own device, or
                 //     b) The device itself is considered to be trusted.
                 if device.is_owner_of_session(session)
-                    && (device.is_our_own_device() || device.verified())
+                    && (device.is_our_own_device() || device.is_verified())
                 {
                     VerificationState::Trusted
                 } else {
@@ -2118,7 +2118,7 @@ pub(crate) mod tests {
         let bob_device =
             alice.get_device(bob.user_id(), bob.device_id(), None).await.unwrap().unwrap();
 
-        assert!(!bob_device.verified());
+        assert!(!bob_device.is_verified());
 
         let (alice_sas, request) = bob_device.start_verification().await.unwrap();
 
@@ -2173,15 +2173,15 @@ pub(crate) mod tests {
         let event = request_to_event(alice.user_id(), &contents[0]);
 
         assert!(alice_sas.is_done());
-        assert!(bob_device.verified());
+        assert!(bob_device.is_verified());
 
         let alice_device =
             bob.get_device(alice.user_id(), alice.device_id(), None).await.unwrap().unwrap();
 
-        assert!(!alice_device.verified());
+        assert!(!alice_device.is_verified());
         bob.handle_verification_event(&event).await;
         assert!(bob_sas.is_done());
-        assert!(alice_device.verified());
+        assert!(alice_device.is_verified());
     }
 
     #[async_test]
@@ -2193,7 +2193,7 @@ pub(crate) mod tests {
         let bob_device =
             alice.get_device(bob.user_id(), bob.device_id(), None).await.unwrap().unwrap();
 
-        assert!(!bob_device.verified());
+        assert!(!bob_device.is_verified());
 
         // Alice sends a verification request with her desired methods to Bob
         let (alice_ver_req, request) =
@@ -2333,23 +2333,23 @@ pub(crate) mod tests {
             bob.get_device(alice.user_id(), alice.device_id(), None).await.unwrap().unwrap();
 
         assert!(!bob_sas.is_done());
-        assert!(!alice_device.verified());
+        assert!(!alice_device.is_verified());
         // And Bob receives the Done message of alice.
         bob.handle_verification_event(&event_done).await;
 
         assert!(bob_sas.is_done());
-        assert!(alice_device.verified());
+        assert!(alice_device.is_verified());
 
         // ----------------------------------------------------------------------------
         // On Alice's device:
 
         assert!(!alice_sas.is_done());
-        assert!(!bob_device.verified());
+        assert!(!bob_device.is_verified());
         // Alices receives the done message
         eprintln!("{:?}", event);
         alice.handle_verification_event(&event).await;
 
         assert!(alice_sas.is_done());
-        assert!(bob_device.verified());
+        assert!(bob_device.is_verified());
     }
 }
diff --git a/crates/matrix-sdk-crypto/src/session_manager/group_sessions.rs b/crates/matrix-sdk-crypto/src/session_manager/group_sessions.rs
index c1211f1c0..e4e47b72d 100644
--- a/crates/matrix-sdk-crypto/src/session_manager/group_sessions.rs
+++ b/crates/matrix-sdk-crypto/src/session_manager/group_sessions.rs
@@ -369,7 +369,7 @@ impl GroupSessionManager {
                 .devices()
                 .filter(|d| {
                     if settings.only_allow_trusted_devices {
-                        !d.is_blacklisted() && d.verified()
+                        !d.is_blacklisted() && d.is_verified()
                     } else {
                         !d.is_blacklisted()
                     }
diff --git a/crates/matrix-sdk/src/docs/encryption.md b/crates/matrix-sdk/src/docs/encryption.md
index 2010ee0a5..90c78eb5d 100644
--- a/crates/matrix-sdk/src/docs/encryption.md
+++ b/crates/matrix-sdk/src/docs/encryption.md
@@ -150,8 +150,8 @@ module.
 
 To add interactive verification support to your client please see the
 [`verification`] module, also check out the documentation for the
-[`Device::verified()`] method, which explains in more detail what it means
-for a [`Device`] to be verified.
+[`Device::is_verified()`] method, which explains in more detail what
+it means for a [`Device`] to be verified.
 
 # Client setup
 
diff --git a/crates/matrix-sdk/src/encryption/identities/devices.rs b/crates/matrix-sdk/src/encryption/identities/devices.rs
index a090bc622..7e232e7de 100644
--- a/crates/matrix-sdk/src/encryption/identities/devices.rs
+++ b/crates/matrix-sdk/src/encryption/identities/devices.rs
@@ -362,7 +362,7 @@ impl Device {
     ///     client.encryption().get_device(alice, device_id!("DEVICEID")).await?;
     ///
     /// if let Some(device) = device {
-    ///     if device.verified() {
+    ///     if device.is_verified() {
     ///         println!(
     ///             "Device {} of user {} is verified",
     ///             device.device_id().as_str(),
@@ -381,9 +381,9 @@ impl Device {
     ///
     /// [`UserIdentity::verify()`]:
     /// crate::encryption::identities::UserIdentity::verify
-    /// [verified]: crate::encryption::identities::UserIdentity::verified
-    pub fn verified(&self) -> bool {
-        self.inner.verified()
+    /// [verified]: crate::encryption::identities::UserIdentity::is_verified
+    pub fn is_verified(&self) -> bool {
+        self.inner.is_verified()
     }
 
     /// Set the local trust state of the device to the given state.
diff --git a/crates/matrix-sdk/src/encryption/identities/users.rs b/crates/matrix-sdk/src/encryption/identities/users.rs
index f3e8eb11f..9e8d27248 100644
--- a/crates/matrix-sdk/src/encryption/identities/users.rs
+++ b/crates/matrix-sdk/src/encryption/identities/users.rs
@@ -331,7 +331,7 @@ impl UserIdentity {
     /// let user = client.encryption().get_user_identity(alice).await?;
     ///
     /// if let Some(user) = user {
-    ///     if user.verified() {
+    ///     if user.is_verified() {
     ///         println!("User {} is verified", user.user_id().as_str());
     ///     } else {
     ///         println!("User {} is not verified", user.user_id().as_str());
@@ -339,10 +339,10 @@ impl UserIdentity {
     /// }
     /// # anyhow::Ok(()) });
     /// ```
-    pub fn verified(&self) -> bool {
+    pub fn is_verified(&self) -> bool {
         match &self.inner {
             UserIdentities::Own(i) => i.inner.is_verified(),
-            UserIdentities::Other(i) => i.inner.verified(),
+            UserIdentities::Other(i) => i.inner.is_verified(),
         }
     }
 
diff --git a/crates/matrix-sdk/src/encryption/mod.rs b/crates/matrix-sdk/src/encryption/mod.rs
index 8d9849bfb..4e17c5368 100644
--- a/crates/matrix-sdk/src/encryption/mod.rs
+++ b/crates/matrix-sdk/src/encryption/mod.rs
@@ -546,9 +546,9 @@ impl Encryption {
     /// if let Some(device) =
     ///     client.encryption().get_device(alice, device_id!("DEVICEID")).await?
     /// {
-    ///     println!("{:?}", device.verified());
+    ///     println!("{:?}", device.is_verified());
     ///
-    ///     if !device.verified() {
+    ///     if !device.is_verified() {
     ///         let verification = device.request_verification().await?;
     ///     }
     /// }
@@ -628,7 +628,7 @@ impl Encryption {
     /// let user = client.encryption().get_user_identity(alice).await?;
     ///
     /// if let Some(user) = user {
-    ///     println!("{:?}", user.verified());
+    ///     println!("{:?}", user.is_verified());
     ///
     ///     let verification = user.request_verification().await?;
     /// }
diff --git a/crates/matrix-sdk/src/room/common.rs b/crates/matrix-sdk/src/room/common.rs
index f32a2044b..bbdf0ee6f 100644
--- a/crates/matrix-sdk/src/room/common.rs
+++ b/crates/matrix-sdk/src/room/common.rs
@@ -920,7 +920,7 @@ impl Common {
 
         for user_id in user_ids {
             let devices = self.client.encryption().get_user_devices(&user_id).await?;
-            let any_unverified = devices.devices().any(|d| !d.verified());
+            let any_unverified = devices.devices().any(|d| !d.is_verified());
 
             if any_unverified {
                 return Ok(false);
diff --git a/examples/emoji_verification/src/main.rs b/examples/emoji_verification/src/main.rs
index 5bad61f10..c8af97759 100644
--- a/examples/emoji_verification/src/main.rs
+++ b/examples/emoji_verification/src/main.rs
@@ -60,7 +60,7 @@ async fn print_devices(user_id: &UserId, client: &Client) {
             "   {:<10} {:<30} {:<}",
             device.device_id(),
             device.display_name().unwrap_or("-"),
-            device.verified()
+            device.is_verified()
         );
     }
 }