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.4.0"
+version = "0.4.1"
 
 [package.metadata.docs.rs]
 features = ["docs"]

matrix_sdk/src/client.rs

@@ -2134,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: _,
@@ -2191,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 {
@@ -3179,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,
     };
 
@@ -3216,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"),
@@ -3487,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

@@ -47,7 +47,7 @@ pub enum EventKind {
     EphemeralRoomData,
     Message { redacted: bool },
     State { redacted: bool },
-    StrippedState { redacted: bool },
+    StrippedState,
     InitialState,
     ToDevice,
     Presence,
@@ -398,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>
@@ -433,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_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(),
             }),