Support ProcessedToDeviceEvent variants returned by receiveSyncChanges

Author: BillCarsonFr

CHANGELOG.md

@@ -1,8 +1,17 @@
 # UNRELEASED
 
+-   Update matrix-rusk-sdk to `35a2ce9`, which includes:
+
+    -   Add variants for plain text and encrypted to-device events ([#4935](https://github.com/matrix-org/matrix-rust-sdk/pull/4935))
+
+-   **BREAKING**: `OlmMachine.receiveSyncChanges` now returns a list of
+    `ProcessedToDeviceEvent` instead of a json encoded list of json encoded events.
+    This allows to make the difference between an event that was sent in clear and
+    the same event successfully decrypted.
+
 # matrix-sdk-crypto-wasm v14.1.0
 
--   Update matrix-rusk-sdk to `0.11.0`, which includees:
+-   Update matrix-rusk-sdk to `0.11.0`, which includes:
 
     -   Add support for the shared history flag defined in
         [MSC3061](https://github.com/matrix-org/matrix-spec-proposals/pull/3061).

Cargo.lock

@@ -65,9 +65,9 @@ futures-util = "0.3.27"
 getrandom = { version = "0.3.0", features = ["wasm_js"] }
 http = "1.1.0"
 js-sys = "0.3.49"
-matrix-sdk-common = { version = "0.11.0", features = ["js"] }
-matrix-sdk-indexeddb = { version = "0.11.0", default-features = false, features = ["e2e-encryption"] }
-matrix-sdk-qrcode = { version = "0.11.0", optional = true }
+matrix-sdk-common = { git = "https://github.com/matrix-org/matrix-rust-sdk", rev = "35a2ce97d84af8cea6b9e1850a8ff4ff5c66d712", features = ["js"] }
+matrix-sdk-indexeddb = { git = "https://github.com/matrix-org/matrix-rust-sdk", rev = "35a2ce97d84af8cea6b9e1850a8ff4ff5c66d712", default-features = false, features = ["e2e-encryption"] }
+matrix-sdk-qrcode = { git = "https://github.com/matrix-org/matrix-rust-sdk", rev = "35a2ce97d84af8cea6b9e1850a8ff4ff5c66d712", optional = true }
 serde = "1.0.91"
 serde_json = "1.0.91"
 serde-wasm-bindgen = "0.6.5"
@@ -83,7 +83,8 @@ wasm-bindgen-test = "0.3.37"
 vergen-gitcl = { version = "1.0.0", features = ["build"] }
 
 [dependencies.matrix-sdk-crypto]
-version = "0.11.0"
+git = "https://github.com/matrix-org/matrix-rust-sdk"
+rev = "35a2ce97d84af8cea6b9e1850a8ff4ff5c66d712"
 default-features = false
 features = ["js", "automatic-room-key-forwarding"]
 

Cargo.toml

@@ -69,7 +69,7 @@ declare module "./pkg/matrix_sdk_crypto_wasm.js" {
             changed_devices: DeviceLists,
             one_time_keys_counts: Map<string, number>,
             unused_fallback_keys?: Set<string> | null,
-        ): Promise<string>;
+        ): Promise<Array<ProcessedToDeviceEvent>>;
         outgoingRequests(): Promise<Array<OutgoingRequest>>;
         markRequestAsSent(request_id: string, request_type: RequestType, response: string): Promise<boolean>;
         encryptRoomEvent(room_id: RoomId, event_type: string, content: string): Promise<string>;

index.d.ts

@@ -42,7 +42,9 @@ use crate::{
     store,
     store::{RoomKeyInfo, RoomKeyWithheldInfo, StoreHandle},
     sync_events,
-    types::{self, RoomKeyImportResult, RoomSettings, SignatureVerification},
+    types::{
+        self, ProcessedToDeviceEvent, RoomKeyImportResult, RoomSettings, SignatureVerification,
+    },
     verification, vodozemac,
 };
 
@@ -298,7 +300,9 @@ impl OlmMachine {
     ///
     /// # Returns
     ///
-    /// A list of JSON strings, containing the decrypted to-device events.
+    /// A list of {@link ProcessedToDeviceEvent} object, containing the
+    /// serialized processed event and if it was successfully decrypted, sent in
+    /// clear, unable to decrypt or invalid.
     #[wasm_bindgen(js_name = "receiveSyncChanges")]
     pub fn receive_sync_changes(
         &self,
@@ -341,7 +345,7 @@ impl OlmMachine {
             // we discard the list of updated room keys in the result; JS applications are
             // expected to use register_room_key_updated_callback to receive updated room
             // keys.
-            let (decrypted_to_device_events, _) = me
+            let (processed_to_device_events, _) = me
                 .receive_sync_changes(EncryptionSyncChanges {
                     to_device_events,
                     changed_devices: &changed_devices,
@@ -353,7 +357,9 @@ impl OlmMachine {
                 })
                 .await?;
 
-            Ok(serde_json::to_string(&decrypted_to_device_events)?)
+            let processed_to_device_events: Vec<ProcessedToDeviceEvent> =
+                processed_to_device_events.into_iter().map(ProcessedToDeviceEvent::from).collect();
+            Ok(processed_to_device_events)
         }))
     }
 

src/machine.rs

@@ -362,3 +362,70 @@ impl From<&RoomSettings> for matrix_sdk_crypto::store::RoomSettings {
         }
     }
 }
+
+/// Represent the type of {@link ProcessedToDeviceEvent}.
+#[wasm_bindgen]
+#[derive(Debug, Clone)]
+pub enum ProcessedToDeviceEventType {
+    /// A successfully-decrypted encrypted event.
+    Decrypted,
+
+    /// An encrypted event which could not be decrypted.
+    UnableToDecrypt,
+
+    /// An unencrypted event (sent in clear).
+    PlainText,
+
+    /// An invalid to device event that was ignored because it is missing some
+    /// required information to be processed (like no event `type` for
+    /// example)
+    Invalid,
+}
+
+/// Represent a ToDevice event after it has been processed by {@link
+/// OlmMachine#receiveSyncChanges}.
+#[wasm_bindgen(getter_with_clone)]
+#[derive(Debug, Clone)]
+pub struct ProcessedToDeviceEvent {
+    /// The type of processed event
+    #[wasm_bindgen(getter_with_clone, js_name = "type")]
+    pub processed_type: ProcessedToDeviceEventType,
+
+    /// A JSON-encoded string containing the processed event.
+    /// For the `Decrypted` type this will be the decrypted event as if it was
+    /// sent in clear (For room keys or secrets some part of the content might
+    /// have been zeroize'd).
+    #[wasm_bindgen(readonly, js_name = "wireEvent")]
+    pub wire_event: JsString,
+}
+
+impl From<matrix_sdk_crypto::types::ProcessedToDeviceEvent> for ProcessedToDeviceEvent {
+    fn from(value: matrix_sdk_crypto::types::ProcessedToDeviceEvent) -> Self {
+        match value {
+            matrix_sdk_crypto::types::ProcessedToDeviceEvent::Decrypted(decrypted_event) => {
+                ProcessedToDeviceEvent {
+                    processed_type: ProcessedToDeviceEventType::Decrypted,
+                    wire_event: decrypted_event.json().get().to_owned().into(),
+                }
+            }
+            matrix_sdk_crypto::types::ProcessedToDeviceEvent::UnableToDecrypt(utd) => {
+                ProcessedToDeviceEvent {
+                    processed_type: ProcessedToDeviceEventType::UnableToDecrypt,
+                    wire_event: utd.json().get().to_owned().into(),
+                }
+            }
+            matrix_sdk_crypto::types::ProcessedToDeviceEvent::PlainText(plain) => {
+                ProcessedToDeviceEvent {
+                    processed_type: ProcessedToDeviceEventType::PlainText,
+                    wire_event: plain.json().get().to_owned().into(),
+                }
+            }
+            matrix_sdk_crypto::types::ProcessedToDeviceEvent::Invalid(invalid) => {
+                ProcessedToDeviceEvent {
+                    processed_type: ProcessedToDeviceEventType::Invalid,
+                    wire_event: invalid.json().get().to_owned().into(),
+                }
+            }
+        }
+    }
+}

src/types.rs

@@ -16,8 +16,11 @@ async function addMachineToMachine(machineToAdd, machine) {
     const oneTimeKeyCounts = new Map();
     const unusedFallbackKeys = new Set();
 
-    const receiveSyncChanges = JSON.parse(
-        await machineToAdd.receiveSyncChanges(toDeviceEvents, changedDevices, oneTimeKeyCounts, unusedFallbackKeys),
+    const receiveSyncChanges = await machineToAdd.receiveSyncChanges(
+        toDeviceEvents,
+        changedDevices,
+        oneTimeKeyCounts,
+        unusedFallbackKeys,
     );
 
     expect(receiveSyncChanges).toEqual([]);