chore(sdk): Bump the version

instant doesn't need wasm_bindgen on non wasm targets

matrix_sdk/Cargo.toml

@@ -8,7 +8,7 @@ license = "Apache-2.0"
 name = "matrix-sdk"
 readme = "README.md"
 repository = "https://github.com/matrix-org/matrix-rust-sdk"
-version = "0.3.0"
+version = "0.4.1"
 
 [package.metadata.docs.rs]
 features = ["docs"]

matrix_sdk/src/client.rs

@@ -927,6 +927,7 @@ impl Client {
     /// # let homeserver = Url::parse("http://localhost:8080").unwrap();
     /// # let client = Client::new(homeserver).unwrap();
     /// use matrix_sdk::{
+    ///     deserialized_responses::EncryptionInfo,
     ///     room::Room,
     ///     ruma::{
     ///         events::{
@@ -952,10 +953,20 @@ impl Client {
     ///     )
     ///     .await
     ///     .register_event_handler(
+    ///         |ev: SyncMessageEvent<MessageEventContent>,
+    ///          room: Room,
+    ///          encryption_info: Option<EncryptionInfo>| async move {
+    ///             // An `Option<EncryptionInfo>` parameter lets you distinguish between
+    ///             // unencrypted events and events that were decrypted by the SDK.
+    ///         },
+    ///     )
+    ///     .await
+    ///     .register_event_handler(
     ///         |ev: SyncStateEvent<TopicEventContent>| async move {
-    ///             // Also possible: Omit any or all arguments after the first.
+    ///             // You can omit any or all arguments after the first.
     ///         }
-    ///     ).await;
+    ///     )
+    ///     .await;
     ///
     /// // Custom events work exactly the same way, you just need to declare
     /// // the content struct and use the EventContent derive macro on it.
@@ -2123,7 +2134,10 @@ impl Client {
         self.process_sync(response).await
     }
 
-    async fn process_sync(&self, response: sync_events::Response) -> Result<SyncResponse> {
+    pub(crate) async fn process_sync(
+        &self,
+        response: sync_events::Response,
+    ) -> Result<SyncResponse> {
         let response = self.base_client.receive_sync_response(response).await?;
         let SyncResponse {
             next_batch: _,
@@ -2180,8 +2194,12 @@ impl Client {
             }
 
             // FIXME: Destructure room_info
-            self.handle_sync_events(EventKind::InitialState, &room, &room_info.invite_state.events)
-                .await?;
+            self.handle_sync_events(
+                EventKind::StrippedState,
+                &room,
+                &room_info.invite_state.events,
+            )
+            .await?;
         }
 
         for handler in &*self.notification_handlers.read().await {
@@ -3168,14 +3186,12 @@ impl Client {
 }
 
 #[cfg(test)]
-mod test {
+pub(crate) mod test {
     use std::{
         collections::BTreeMap,
         convert::{TryFrom, TryInto},
-        future,
         io::Cursor,
         str::FromStr,
-        sync::Arc,
         time::Duration,
     };
 
@@ -3205,20 +3221,19 @@ mod test {
         event_id,
         events::{
             room::{
-                member::MemberEventContent,
                 message::{ImageMessageEventContent, MessageEventContent},
                 ImageInfo,
             },
-            AnyMessageEventContent, AnySyncStateEvent, EventType, SyncStateEvent,
+            AnyMessageEventContent, AnySyncStateEvent, EventType,
         },
         mxc_uri, room_id, thirdparty, uint, user_id, UserId,
     };
     use serde_json::json;
 
     use super::{Client, Session, SyncSettings, Url};
-    use crate::{room, ClientConfig, HttpError, RequestConfig, RoomMember};
+    use crate::{ClientConfig, HttpError, RequestConfig, RoomMember};
 
-    async fn logged_in_client() -> Client {
+    pub(crate) async fn logged_in_client() -> Client {
         let session = Session {
             access_token: "1234".to_owned(),
             user_id: user_id!("@example:localhost"),
@@ -3476,56 +3491,6 @@ mod test {
         // assert_eq!(1, ignored_users.len())
     }
 
-    #[tokio::test]
-    async fn event_handler() {
-        use std::sync::atomic::{AtomicU8, Ordering::SeqCst};
-
-        let client = logged_in_client().await;
-
-        let member_count = Arc::new(AtomicU8::new(0));
-        let typing_count = Arc::new(AtomicU8::new(0));
-        let power_levels_count = Arc::new(AtomicU8::new(0));
-
-        client
-            .register_event_handler({
-                let member_count = member_count.clone();
-                move |_ev: SyncStateEvent<MemberEventContent>, _room: room::Room| {
-                    member_count.fetch_add(1, SeqCst);
-                    future::ready(())
-                }
-            })
-            .await
-            .register_event_handler({
-                let typing_count = typing_count.clone();
-                move |_ev: SyncStateEvent<MemberEventContent>| {
-                    typing_count.fetch_add(1, SeqCst);
-                    future::ready(())
-                }
-            })
-            .await
-            .register_event_handler({
-                let power_levels_count = power_levels_count.clone();
-                move |_ev: SyncStateEvent<MemberEventContent>,
-                      _client: Client,
-                      _room: room::Room| {
-                    power_levels_count.fetch_add(1, SeqCst);
-                    future::ready(())
-                }
-            })
-            .await;
-
-        let response = EventBuilder::default()
-            .add_room_event(EventsJson::Member)
-            .add_ephemeral(EventsJson::Typing)
-            .add_state_event(EventsJson::PowerLevels)
-            .build_sync_response();
-        client.process_sync(response).await.unwrap();
-
-        assert_eq!(member_count.load(SeqCst), 1);
-        assert_eq!(typing_count.load(SeqCst), 1);
-        assert_eq!(power_levels_count.load(SeqCst), 1);
-    }
-
     #[tokio::test]
     async fn room_creation() {
         let client = logged_in_client().await;

matrix_sdk/src/event_handler.rs

@@ -32,7 +32,7 @@
 
 use std::{borrow::Cow, future::Future, ops::Deref};
 
-use matrix_sdk_base::deserialized_responses::SyncRoomEvent;
+use matrix_sdk_base::deserialized_responses::{EncryptionInfo, SyncRoomEvent};
 use ruma::{events::AnySyncStateEvent, serde::Raw};
 use serde::Deserialize;
 use serde_json::value::RawValue as RawJsonValue;
@@ -47,7 +47,7 @@ pub enum EventKind {
     EphemeralRoomData,
     Message { redacted: bool },
     State { redacted: bool },
-    StrippedState { redacted: bool },
+    StrippedState,
     InitialState,
     ToDevice,
     Presence,
@@ -117,6 +117,7 @@ pub struct EventHandlerData<'a> {
     pub client: Client,
     pub room: Option<room::Room>,
     pub raw: &'a RawJsonValue,
+    pub encryption_info: Option<&'a EncryptionInfo>,
 }
 
 /// Context for an event handler.
@@ -169,6 +170,12 @@ impl EventHandlerContext for RawEvent {
     }
 }
 
+impl EventHandlerContext for Option<EncryptionInfo> {
+    fn from_data(data: &EventHandlerData<'_>) -> Option<Self> {
+        Some(data.encryption_info.cloned())
+    }
+}
+
 /// Return types supported for event handlers implement this trait.
 ///
 /// It is not meant to be implemented outside of matrix-sdk.
@@ -211,7 +218,19 @@ impl Client {
         room: &Option<room::Room>,
         events: &[Raw<T>],
     ) -> serde_json::Result<()> {
-        self.handle_sync_events_wrapped(kind, room, events, |x| x).await
+        #[derive(Deserialize)]
+        struct ExtractType<'a> {
+            #[serde(borrow, rename = "type")]
+            event_type: Cow<'a, str>,
+        }
+
+        self.handle_sync_events_wrapped_with(
+            room,
+            events,
+            |ev| (ev, None),
+            |raw| Ok((kind, raw.deserialize_as::<ExtractType>()?.event_type)),
+        )
+        .await
     }
 
     pub(crate) async fn handle_sync_state_events(
@@ -226,11 +245,16 @@ impl Client {
             unsigned: Option<UnsignedDetails>,
         }
 
-        self.handle_sync_events_wrapped_with(room, state_events, std::convert::identity, |raw| {
-            let StateEventDetails { event_type, unsigned } = raw.deserialize_as()?;
-            let redacted = unsigned.and_then(|u| u.redacted_because).is_some();
-            Ok((EventKind::State { redacted }, event_type))
-        })
+        self.handle_sync_events_wrapped_with(
+            room,
+            state_events,
+            |ev| (ev, None),
+            |raw| {
+                let StateEventDetails { event_type, unsigned } = raw.deserialize_as()?;
+                let redacted = unsigned.and_then(|u| u.redacted_because).is_some();
+                Ok((EventKind::State { redacted }, event_type))
+            },
+        )
         .await
     }
 
@@ -239,7 +263,6 @@ impl Client {
         room: &Option<room::Room>,
         timeline_events: &[SyncRoomEvent],
     ) -> serde_json::Result<()> {
-        // FIXME: add EncryptionInfo to context
         #[derive(Deserialize)]
         struct TimelineEventDetails<'a> {
             #[serde(borrow, rename = "type")]
@@ -251,7 +274,7 @@ impl Client {
         self.handle_sync_events_wrapped_with(
             room,
             timeline_events,
-            |e| &e.event,
+            |e| (&e.event, e.encryption_info.as_ref()),
             |raw| {
                 let TimelineEventDetails { event_type, state_key, unsigned } =
                     raw.deserialize_as()?;
@@ -268,35 +291,16 @@ impl Client {
         .await
     }
 
-    async fn handle_sync_events_wrapped<'a, T: 'a, U: 'a>(
-        &self,
-        kind: EventKind,
-        room: &Option<room::Room>,
-        events: &'a [U],
-        get_event: impl Fn(&'a U) -> &'a Raw<T>,
-    ) -> Result<(), serde_json::Error> {
-        #[derive(Deserialize)]
-        struct ExtractType<'a> {
-            #[serde(borrow, rename = "type")]
-            event_type: Cow<'a, str>,
-        }
-
-        self.handle_sync_events_wrapped_with(room, events, get_event, |raw| {
-            Ok((kind, raw.deserialize_as::<ExtractType>()?.event_type))
-        })
-        .await
-    }
-
     async fn handle_sync_events_wrapped_with<'a, T: 'a, U: 'a>(
         &self,
         room: &Option<room::Room>,
         list: &'a [U],
-        get_event: impl Fn(&'a U) -> &'a Raw<T>,
+        get_event_details: impl Fn(&'a U) -> (&'a Raw<T>, Option<&'a EncryptionInfo>),
         get_id: impl Fn(&Raw<T>) -> serde_json::Result<(EventKind, Cow<'_, str>)>,
     ) -> serde_json::Result<()> {
         for x in list {
-            let event = get_event(x);
-            let (ev_kind, ev_type) = get_id(event)?;
+            let (raw_event, encryption_info) = get_event_details(x);
+            let (ev_kind, ev_type) = get_id(raw_event)?;
             let event_handler_id = (ev_kind, &*ev_type);
 
             if let Some(handlers) = self.event_handlers.read().await.get(&event_handler_id) {
@@ -304,7 +308,8 @@ impl Client {
                     let data = EventHandlerData {
                         client: self.clone(),
                         room: room.clone(),
-                        raw: event.json(),
+                        raw: raw_event.json(),
+                        encryption_info,
                     };
                     matrix_sdk_common::executor::spawn((handler)(data));
                 }
@@ -393,8 +398,7 @@ mod static_events {
     where
         C: StaticEventContent + events::StateEventContent,
     {
-        const ID: (EventKind, &'static str) =
-            (EventKind::StrippedState { redacted: false }, C::TYPE);
+        const ID: (EventKind, &'static str) = (EventKind::StrippedState, C::TYPE);
     }
 
     impl<C> SyncEvent for events::InitialStateEvent<C>
@@ -428,12 +432,117 @@ mod static_events {
     {
         const ID: (EventKind, &'static str) = (EventKind::State { redacted: true }, C::TYPE);
     }
+}
 
-    impl<C> SyncEvent for events::RedactedStrippedStateEvent<C>
-    where
-        C: StaticEventContent + events::RedactedStateEventContent,
-    {
-        const ID: (EventKind, &'static str) =
-            (EventKind::StrippedState { redacted: true }, C::TYPE);
+#[cfg(test)]
+mod test {
+    use std::{future, sync::Arc};
+
+    use matrix_sdk_test::{EventBuilder, EventsJson};
+    use ruma::{
+        events::{room::member::MemberEventContent, StrippedStateEvent, SyncStateEvent},
+        room_id,
+    };
+    use serde_json::json;
+
+    use crate::{room, Client};
+
+    #[tokio::test]
+    async fn event_handler() -> crate::Result<()> {
+        use std::sync::atomic::{AtomicU8, Ordering::SeqCst};
+
+        let client = crate::client::test::logged_in_client().await;
+
+        let member_count = Arc::new(AtomicU8::new(0));
+        let typing_count = Arc::new(AtomicU8::new(0));
+        let power_levels_count = Arc::new(AtomicU8::new(0));
+        let invited_member_count = Arc::new(AtomicU8::new(0));
+
+        client
+            .register_event_handler({
+                let member_count = member_count.clone();
+                move |_ev: SyncStateEvent<MemberEventContent>, _room: room::Room| {
+                    member_count.fetch_add(1, SeqCst);
+                    future::ready(())
+                }
+            })
+            .await
+            .register_event_handler({
+                let typing_count = typing_count.clone();
+                move |_ev: SyncStateEvent<MemberEventContent>| {
+                    typing_count.fetch_add(1, SeqCst);
+                    future::ready(())
+                }
+            })
+            .await
+            .register_event_handler({
+                let power_levels_count = power_levels_count.clone();
+                move |_ev: SyncStateEvent<MemberEventContent>,
+                      _client: Client,
+                      _room: room::Room| {
+                    power_levels_count.fetch_add(1, SeqCst);
+                    future::ready(())
+                }
+            })
+            .await
+            .register_event_handler({
+                let invited_member_count = invited_member_count.clone();
+                move |_ev: StrippedStateEvent<MemberEventContent>| {
+                    invited_member_count.fetch_add(1, SeqCst);
+                    future::ready(())
+                }
+            })
+            .await;
+
+        let response = EventBuilder::default()
+            .add_room_event(EventsJson::Member)
+            .add_ephemeral(EventsJson::Typing)
+            .add_state_event(EventsJson::PowerLevels)
+            .add_custom_invited_event(
+                &room_id!("!test_invited:example.org"),
+                json!({
+                "content": {
+                  "avatar_url": "mxc://example.org/SEsfnsuifSDFSSEF",
+                  "displayname": "Alice",
+                  "membership": "invite",
+                },
+                "event_id": "$143273582443PhrSn:example.org",
+                "origin_server_ts": 1432735824653u64,
+                "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
+                "sender": "@example:example.org",
+                "state_key": "@alice:example.org",
+                "type": "m.room.member",
+                "unsigned": {
+                  "age": 1234,
+                  "invite_room_state": [
+                    {
+                      "content": {
+                        "name": "Example Room"
+                      },
+                      "sender": "@bob:example.org",
+                      "state_key": "",
+                      "type": "m.room.name"
+                    },
+                    {
+                      "content": {
+                        "join_rule": "invite"
+                      },
+                      "sender": "@bob:example.org",
+                      "state_key": "",
+                      "type": "m.room.join_rules"
+                    }
+                  ]
+                }
+                          }),
+            )
+            .build_sync_response();
+        client.process_sync(response).await?;
+
+        assert_eq!(member_count.load(SeqCst), 1);
+        assert_eq!(typing_count.load(SeqCst), 1);
+        assert_eq!(power_levels_count.load(SeqCst), 1);
+        assert_eq!(invited_member_count.load(SeqCst), 1);
+
+        Ok(())
     }
 }

matrix_sdk_appservice/Cargo.toml

@@ -36,7 +36,7 @@ tracing = "0.1"
 url = "2"
 warp = { git = "https://github.com/seanmonstar/warp.git", rev = "629405", optional = true, default-features = false }
 
-matrix-sdk = { version = "0.3", path = "../matrix_sdk", default-features = false, features = ["appservice"] }
+matrix-sdk = { version = "0.4", path = "../matrix_sdk", default-features = false, features = ["appservice"] }
 
 [dependencies.ruma]
 version = "0.4.0"

matrix_sdk_base/Cargo.toml

@@ -8,7 +8,7 @@ license = "Apache-2.0"
 name = "matrix-sdk-base"
 readme = "README.md"
 repository = "https://github.com/matrix-org/matrix-rust-sdk"
-version = "0.4.0"
+version = "0.4.1"
 
 [package.metadata.docs.rs]
 features = ["docs"]

matrix_sdk_base/src/rooms/members.rs

@@ -30,6 +30,7 @@ use crate::deserialized_responses::MemberEvent;
 pub struct RoomMember {
     pub(crate) event: Arc<MemberEvent>,
     pub(crate) profile: Arc<Option<MemberEventContent>>,
+    #[allow(dead_code)]
     pub(crate) presence: Arc<Option<PresenceEvent>>,
     pub(crate) power_levels: Arc<Option<SyncStateEvent<PowerLevelsEventContent>>>,
     pub(crate) max_power_level: i64,

matrix_sdk_common/Cargo.toml

@@ -8,11 +8,10 @@ license = "Apache-2.0"
 name = "matrix-sdk-common"
 readme = "README.md"
 repository = "https://github.com/matrix-org/matrix-rust-sdk"
-version = "0.4.0"
+version = "0.4.1"
 
 [dependencies]
 async-trait = "0.1.50"
-instant = { version = "0.1.9", features = ["wasm-bindgen", "now"] }
 ruma = { version = "0.4.0", features = ["client-api-c"] }
 serde = "1.0.126"
 
@@ -24,6 +23,14 @@ version = "1.7.1"
 default-features = false
 features = ["rt", "sync"]
 
+[target.'cfg(target_arch = "wasm32")'.dependencies.instant]
+version = "0.1.9"
+features = ["wasm-bindgen", "now"]
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies.instant]
+version = "0.1.9"
+features = ["now"]
+
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 futures = "0.3.15"
 futures-locks = { version = "0.6.0", default-features = false }

matrix_sdk_crypto/Cargo.toml

@@ -8,7 +8,7 @@ license = "Apache-2.0"
 name = "matrix-sdk-crypto"
 readme = "README.md"
 repository = "https://github.com/matrix-org/matrix-rust-sdk"
-version = "0.4.0"
+version = "0.4.1"
 
 [package.metadata.docs.rs]
 features = ["docs"]

matrix_sdk_crypto/src/identities/device.rs

@@ -42,7 +42,7 @@ use super::{atomic_bool_deserializer, atomic_bool_serializer};
 use crate::{
     error::{EventError, OlmError, OlmResult, SignatureError},
     identities::{ReadOnlyOwnUserIdentity, ReadOnlyUserIdentities},
-    olm::{InboundGroupSession, PrivateCrossSigningIdentity, Session, Utility},
+    olm::{InboundGroupSession, Session, Utility},
     store::{Changes, CryptoStore, DeviceChanges, Result as StoreResult},
     verification::VerificationMachine,
     OutgoingVerificationRequest, Sas, ToDeviceRequest, VerificationRequest,
@@ -296,7 +296,6 @@ impl Device {
 #[derive(Debug)]
 pub struct UserDevices {
     pub(crate) inner: HashMap<DeviceIdBox, ReadOnlyDevice>,
-    pub(crate) private_identity: Arc<Mutex<PrivateCrossSigningIdentity>>,
     pub(crate) verification_machine: VerificationMachine,
     pub(crate) own_identity: Option<ReadOnlyOwnUserIdentity>,
     pub(crate) device_owner_identity: Option<ReadOnlyUserIdentities>,

matrix_sdk_crypto/src/store/mod.rs

@@ -309,7 +309,6 @@ impl Store {
 
         Ok(UserDevices {
             inner: devices,
-            private_identity: self.identity.clone(),
             verification_machine: self.verification_machine.clone(),
             own_identity,
             device_owner_identity,

matrix_sdk_crypto/src/store/sled.rs

@@ -164,7 +164,6 @@ pub struct SledStore {
     identities: Tree,
 
     tracked_users: Tree,
-    users_for_key_query: Tree,
 }
 
 impl std::fmt::Debug for SledStore {
@@ -246,7 +245,6 @@ impl SledStore {
         let outbound_group_sessions = db.open_tree("outbound_group_sessions")?;
 
         let tracked_users = db.open_tree("tracked_users")?;
-        let users_for_key_query = db.open_tree("users_for_key_query")?;
         let olm_hashes = db.open_tree("olm_hashes")?;
 
         let devices = db.open_tree("devices")?;
@@ -283,7 +281,6 @@ impl SledStore {
             secret_requests_by_info,
             devices,
             tracked_users,
-            users_for_key_query,
             olm_hashes,
             identities,
         })

matrix_sdk_crypto/src/verification/qrcode.rs

@@ -80,7 +80,6 @@ pub enum ScanError {
 #[derive(Clone)]
 pub struct QrVerification {
     flow_id: FlowId,
-    store: VerificationStore,
     inner: Arc<QrVerificationData>,
     state: Arc<Mutex<InnerState>>,
     identities: IdentitiesBeingVerified,
@@ -429,7 +428,6 @@ impl QrVerification {
     }
 
     pub(crate) fn new_self(
-        store: VerificationStore,
         flow_id: FlowId,
         own_master_key: String,
         other_device_key: String,
@@ -447,7 +445,7 @@ impl QrVerification {
         )
         .into();
 
-        Self::new_helper(store, flow_id, inner, identities, we_started, request_handle)
+        Self::new_helper(flow_id, inner, identities, we_started, request_handle)
     }
 
     pub(crate) fn new_self_no_master(
@@ -468,11 +466,10 @@ impl QrVerification {
         )
         .into();
 
-        Self::new_helper(store, flow_id, inner, identities, we_started, request_handle)
+        Self::new_helper(flow_id, inner, identities, we_started, request_handle)
     }
 
     pub(crate) fn new_cross(
-        store: VerificationStore,
         flow_id: FlowId,
         own_master_key: String,
         other_master_key: String,
@@ -491,7 +488,7 @@ impl QrVerification {
         let inner: QrVerificationData =
             VerificationData::new(event_id, own_master_key, other_master_key, secret).into();
 
-        Self::new_helper(store, flow_id, inner, identities, we_started, request_handle)
+        Self::new_helper(flow_id, inner, identities, we_started, request_handle)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -585,7 +582,6 @@ impl QrVerification {
         let own_device_id = store.account.device_id().to_owned();
 
         Ok(Self {
-            store,
             flow_id,
             inner: qr_code.into(),
             state: Mutex::new(InnerState::Reciprocated(QrState {
@@ -599,7 +595,6 @@ impl QrVerification {
     }
 
     fn new_helper(
-        store: VerificationStore,
         flow_id: FlowId,
         inner: QrVerificationData,
         identities: IdentitiesBeingVerified,
@@ -609,7 +604,6 @@ impl QrVerification {
         let secret = inner.secret().to_owned();
 
         Self {
-            store,
             flow_id,
             inner: inner.into(),
             state: Mutex::new(InnerState::Created(QrState { state: Created { secret } })).into(),
@@ -851,7 +845,6 @@ mod test {
         assert_eq!(verification.inner.second_key(), &master_key);
 
         let verification = QrVerification::new_self(
-            store.clone(),
             flow_id,
             master_key.clone(),
             device_key.clone(),
@@ -870,7 +863,6 @@ mod test {
         let flow_id = FlowId::InRoom(room_id!("!test:example"), event_id!("$EVENTID"));
 
         let verification = QrVerification::new_cross(
-            store.clone(),
             flow_id,
             master_key.clone(),
             bob_master_key.clone(),
@@ -972,6 +964,7 @@ mod test {
             assert!(bob_verification.is_done());
 
             let identity = alice_verification
+                .identities
                 .store
                 .get_user_identity(alice_account.user_id())
                 .await

matrix_sdk_crypto/src/verification/requests.rs

@@ -999,7 +999,6 @@ impl RequestState<Ready> {
                                 identites.other_device().get_key(DeviceKeyAlgorithm::Ed25519)
                             {
                                 Some(QrVerification::new_self(
-                                    self.store.clone(),
                                     self.flow_id.as_ref().to_owned(),
                                     master_key.to_owned(),
                                     device_key.to_owned(),
@@ -1048,7 +1047,6 @@ impl RequestState<Ready> {
                             .and_then(|m| m.get_first_key().map(|m| m.to_owned()))
                         {
                             Some(QrVerification::new_cross(
-                                self.store.clone(),
                                 self.flow_id.as_ref().to_owned(),
                                 own_master,
                                 other_master.to_owned(),
@@ -1251,6 +1249,7 @@ impl RequestState<Ready> {
 #[derive(Clone, Debug)]
 struct Passive {
     /// The device id of the device that responded to the verification request.
+    #[allow(dead_code)]
     pub other_device_id: DeviceIdBox,
 }
 

matrix_sdk_crypto/src/verification/sas/sas_state.rs

@@ -665,7 +665,7 @@ impl SasState<WeAccepted> {
             last_event_time: Instant::now().into(),
             started_from_request: self.started_from_request,
             state: Arc::new(KeyReceived {
-                we_started: false,
+                we_started: self.state.we_started,
                 their_pubkey,
                 accepted_protocols: self.state.accepted_protocols.clone(),
             }),