feat(base): Add EncryptionState::Encrypted { encrypt_state_events } flag

Add `EncryptionState::is_state_encrypted()`, similar to
`::is_encrypted()` but requires the `encrypt_state_events` flag is
false.

Signed-off-by: Skye Elliot <[email protected]>

Author: kaylendog

crates/matrix-sdk-base/CHANGELOG.md

@@ -7,6 +7,10 @@ All notable changes to this project will be documented in this file.
 ## [Unreleased] - ReleaseDate
 
 ### Features
+
+- Add `EncryptionState::StateEncrypted` to represent rooms supporting encrypted
+  state events. Feature-gated behind `experimental-encrypted-state-events`.
+  ([#5523](https://github.com/matrix-org/matrix-rust-sdk/pull/5523))
 - [**breaking**] The `state` field of `JoinedRoomUpdate` and `LeftRoomUpdate`
   now uses the `State` enum, depending on whether the state changes were
   received in the `state` field or the `state_after` field.

crates/matrix-sdk-base/Cargo.toml

@@ -31,6 +31,9 @@ automatic-room-key-forwarding = [
 experimental-send-custom-to-device = [
     "matrix-sdk-crypto?/experimental-send-custom-to-device",
 ]
+experimental-encrypted-state-events = [
+    "ruma/unstable-msc3414",
+]
 uniffi = ["dep:uniffi", "matrix-sdk-crypto?/uniffi", "matrix-sdk-common/uniffi"]
 
 # Private feature, see

crates/matrix-sdk-base/src/room/encryption.rs

@@ -33,8 +33,11 @@ impl Room {
 #[derive(Debug)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
 pub enum EncryptionState {
-    /// The room is encrypted.
-    Encrypted,
+    /// The room is encrypted, possibly including state events.
+    Encrypted {
+        /// Determines whether experimental state encryption is enabled.
+        encrypt_state_events: bool,
+    },
 
     /// The room is not encrypted.
     NotEncrypted,
@@ -47,7 +50,13 @@ pub enum EncryptionState {
 impl EncryptionState {
     /// Check whether `EncryptionState` is [`Encrypted`][Self::Encrypted].
     pub fn is_encrypted(&self) -> bool {
-        matches!(self, Self::Encrypted)
+        matches!(self, Self::Encrypted { .. })
+    }
+
+    /// Check whether `EncryptionState` is [`Encrypted`][Self::Encrypted] with
+    /// state encryption enabled.
+    pub fn is_state_encrypted(&self) -> bool {
+        matches!(self, Self::Encrypted { encrypt_state_events: true })
     }
 
     /// Check whether `EncryptionState` is [`Unknown`][Self::Unknown].
@@ -129,7 +138,7 @@ mod tests {
         ));
         receive_state_events(&room, vec![&encryption_event]);
 
-        assert_matches!(room.encryption_state(), EncryptionState::Encrypted);
+        assert_matches!(room.encryption_state(), EncryptionState::Encrypted { .. });
     }
 
     #[test]
@@ -149,11 +158,20 @@ mod tests {
     #[test]
     fn test_encryption_state() {
         assert!(EncryptionState::Unknown.is_unknown());
-        assert!(EncryptionState::Encrypted.is_unknown().not());
+        assert!(EncryptionState::Encrypted { encrypt_state_events: false }.is_unknown().not());
+        assert!(EncryptionState::Encrypted { encrypt_state_events: true }.is_unknown().not());
         assert!(EncryptionState::NotEncrypted.is_unknown().not());
 
         assert!(EncryptionState::Unknown.is_encrypted().not());
-        assert!(EncryptionState::Encrypted.is_encrypted());
+        assert!(EncryptionState::Encrypted { encrypt_state_events: false }.is_encrypted());
+        assert!(EncryptionState::Encrypted { encrypt_state_events: true }.is_encrypted());
         assert!(EncryptionState::NotEncrypted.is_encrypted().not());
+
+        assert!(EncryptionState::Unknown.is_state_encrypted().not());
+        assert!(
+            EncryptionState::Encrypted { encrypt_state_events: false }.is_state_encrypted().not()
+        );
+        assert!(EncryptionState::Encrypted { encrypt_state_events: true }.is_state_encrypted());
+        assert!(EncryptionState::NotEncrypted.is_state_encrypted().not());
     }
 }

crates/matrix-sdk-base/src/room/room_info.rs

@@ -616,13 +616,21 @@ impl RoomInfo {
     }
 
     /// Returns the encryption state of this room.
+    #[allow(unused_variables)] // `state` only unused when state encryption disabled
     pub fn encryption_state(&self) -> EncryptionState {
         if !self.encryption_state_synced {
             EncryptionState::Unknown
-        } else if self.base_info.encryption.is_some() {
-            EncryptionState::Encrypted
         } else {
-            EncryptionState::NotEncrypted
+            self.base_info
+                .encryption
+                .as_ref()
+                .map(|state| EncryptionState::Encrypted {
+                    #[cfg(not(feature = "experimental-encrypted-state-events"))]
+                    encrypt_state_events: false,
+                    #[cfg(feature = "experimental-encrypted-state-events")]
+                    encrypt_state_events: state.encrypt_state_events,
+                })
+                .unwrap_or(EncryptionState::NotEncrypted)
         }
     }
 

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

@@ -2437,11 +2437,11 @@ mod tests {
         // They are both encrypted, yepee.
         assert_matches!(
             client.get_room(room_id_0).unwrap().encryption_state(),
-            EncryptionState::Encrypted
+            EncryptionState::Encrypted { .. }
         );
         assert_matches!(
             client.get_room(room_id_1).unwrap().encryption_state(),
-            EncryptionState::Encrypted
+            EncryptionState::Encrypted { .. }
         );
         // This one is not encrypted because it has received nothing.
         assert_matches!(
@@ -2492,7 +2492,7 @@ mod tests {
         // is encrypted.
         assert_matches!(
             client.get_room(room_id_0).unwrap().encryption_state(),
-            EncryptionState::Encrypted
+            EncryptionState::Encrypted { .. }
         );
         // Unknown, because the absence of `m.room.encryption` when not requested
         // means we don't know what the state is.

crates/matrix-sdk/tests/integration/room/joined.rs

@@ -1084,7 +1084,7 @@ async fn test_enable_encryption_doesnt_stay_unknown() {
     assert_matches!(room.encryption_state(), EncryptionState::Unknown);
 
     assert!(room.latest_encryption_state().await.unwrap().is_encrypted());
-    assert_matches!(room.encryption_state(), EncryptionState::Encrypted);
+    assert_matches!(room.encryption_state(), EncryptionState::Encrypted { .. });
 }
 
 #[async_test]