From 93ad810f31dff19594ef03b007a9db185f8361d4 Mon Sep 17 00:00:00 2001
From: Kevin Boos <kevinaboos@gmail.com>
Date: Fri, 4 Oct 2024 23:50:43 -0700
Subject: [PATCH 1/4] Device verification is almost fully implemented.
 Untested.

A background async task runs a sync loop that adds event handlers
to the Client and then listens for incoming verification requests.
When it receives one asynchronously, it posts a `VerificationAction`
to the main UI thread, which is then handled by the top-level `App`.
The top-level `App` opens up and populates a `VerificationModal`,
which uses a tokio async channel that was sent along with the
`VerificationAction` to send user interactive responses back to the
async task.
The background async task uses those responses to communicate with
to the other device participating in the verificaiton via
standard Matrix SDK calls.
So basically, there are two state machines that get kept in lockstep
based on user-side actions and SDK-side actions,
and the async task and main UI thread communicate with each other
by posting actions to the main UI thread and then sending responses
back to the async task over a tokio channel.

Other changes:
* Consolidate Robrix-styled icon buttons into a separate widget,
  extracting it out of `user_profile`rs.
* Add a checkmark SVG icon to be used for Ok/Accept buttons.
---
 resources/icons/checkmark.svg |   9 +
 src/app.rs                    |  41 +++-
 src/lib.rs                    |   3 +
 src/profile/user_profile.rs   | 103 +---------
 src/shared/icon_button.rs     |  96 +++++++++
 src/shared/mod.rs             |   2 +
 src/shared/styles.rs          |   7 +
 src/sliding_sync.rs           |   8 +-
 src/verification.rs           | 296 +++++++++++++++++++++++++++
 src/verification_modal.rs     | 367 ++++++++++++++++++++++++++++++++++
 10 files changed, 831 insertions(+), 101 deletions(-)
 create mode 100644 resources/icons/checkmark.svg
 create mode 100644 src/shared/icon_button.rs
 create mode 100644 src/verification.rs
 create mode 100644 src/verification_modal.rs

diff --git a/resources/icons/checkmark.svg b/resources/icons/checkmark.svg
new file mode 100644
index 00000000..1e8e409e
--- /dev/null
+++ b/resources/icons/checkmark.svg
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path
+    fill-rule="evenodd"
+    clip-rule="evenodd"
+    d="M11.4669 3.72684C11.7558 3.91574 11.8369 4.30308 11.648 4.59198L7.39799 11.092C7.29783 11.2452 7.13556 11.3467 6.95402 11.3699C6.77247 11.3931 6.58989 11.3355 6.45446 11.2124L3.70446 8.71241C3.44905 8.48022 3.43023 8.08494 3.66242 7.82953C3.89461 7.57412 4.28989 7.55529 4.5453 7.78749L6.75292 9.79441L10.6018 3.90792C10.7907 3.61902 11.178 3.53795 11.4669 3.72684Z"
+    fill="#000000"
+  />
+</svg>
\ No newline at end of file
diff --git a/src/app.rs b/src/app.rs
index 77cd32ba..6dcdc44e 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,7 +1,11 @@
 use makepad_widgets::*;
 use matrix_sdk::ruma::OwnedRoomId;
 
-use crate::home::rooms_list::RoomListAction;
+use crate::{
+    home::rooms_list::RoomListAction,
+    verification::VerificationAction,
+    verification_modal::{VerificationModalAction, VerificationModalWidgetRefExt},
+};
 
 live_design! {
     import makepad_widgets::base::*;
@@ -103,7 +107,19 @@ live_design! {
             pass: {clear_color: #2A}
 
             body = {
-                home_screen = <HomeScreen> {}
+                // A wrapper view for showing top-level app modals/dialogs/popups
+                <View> {
+                    width: Fill, height: Fill,
+                    flow: Overlay,
+
+                    home_screen = <HomeScreen> {}
+
+                    verification_modal = <Modal> {
+                        content: {
+                            verification_modal_inner = <VerificationModal> {}
+                        }
+                    }
+                }
             } // end of body
         }
     }
@@ -128,6 +144,7 @@ impl LiveRegister for App {
         // then other modules widgets.
         makepad_widgets::live_design(cx);
         crate::shared::live_design(cx);
+        crate::verification_modal::live_design(cx);
         crate::home::live_design(cx);
         crate::profile::live_design(cx);
     }
@@ -168,7 +185,24 @@ impl MatchEvent for App {
                     );
                     self.ui.redraw(cx);
                 }
-                _ => (),
+                RoomListAction::None => { }
+            }
+
+            // TODO FIXME: need to add a cast_ref() method to WidgetAction
+            //             that doesn't require the action to be clonable.
+            match action.as_widget_action().cast() {
+                VerificationAction::RequestReceived { request, response_sender } => {
+                    log!("Received a new verification request: {:?}", request);
+                    self.ui.verification_modal(id!(verification_modal_inner))
+                        .initialize_with_data(request, response_sender);
+                    self.ui.modal(id!(verification_modal)).open(cx);
+                }
+                // other verification actions are handled by the verification modal itself.
+                _ => { }
+            }
+
+            if let VerificationModalAction::Close = action.as_widget_action().cast() {
+                self.ui.modal(id!(verification_modal)).close(cx);
             }
         }
     }
@@ -222,3 +256,4 @@ pub struct SelectedRoom {
     pub id: OwnedRoomId,
     pub name: Option<String>,
 }
+
diff --git a/src/lib.rs b/src/lib.rs
index 7c9b8df1..1b4ecf74 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,6 +10,8 @@ pub mod persistent_state;
 pub mod home;
 /// User profile info and a user profile sliding pane.
 mod profile;
+/// A modal/dialog popup for interactive verification of users/devices.
+mod verification_modal;
 /// Shared UI components.
 pub mod shared;
 /// Generating text previews of timeline events/messages.
@@ -20,6 +22,7 @@ mod event_preview;
 pub mod sliding_sync;
 pub mod avatar_cache;
 pub mod media_cache;
+pub mod verification;
 
 pub mod utils;
 pub mod temp_storage;
diff --git a/src/profile/user_profile.rs b/src/profile/user_profile.rs
index 35f68e5b..6818fd20 100644
--- a/src/profile/user_profile.rs
+++ b/src/profile/user_profile.rs
@@ -100,6 +100,7 @@ live_design! {
     import crate::shared::helpers::*;
     import crate::shared::styles::*;
     import crate::shared::avatar::*;
+    import crate::shared::icon_button::*;
 
     // Copied from Moxin
     FadeView = <CachedView> {
@@ -113,98 +114,6 @@ live_design! {
         }
     }
 
-    // Copied from Moxin
-    //
-    // Customized button widget, based on the RoundedView shaders with some modifications
-    // which is a better fit with our application UI design
-    UserProfileActionButton = <Button> {
-        width: Fit,
-        height: Fit,
-        spacing: 10,
-        padding: {top: 10, bottom: 10, left: 8, right: 15}
-
-        draw_bg: {
-            instance color: (COLOR_PRIMARY)
-            instance color_hover: #A
-            instance border_width: 0.0
-            instance border_color: #D0D5DD
-            instance radius: 3.0
-
-            fn get_color(self) -> vec4 {
-                return mix(self.color, mix(self.color, self.color_hover, 0.2), self.hover)
-            }
-
-            fn pixel(self) -> vec4 {
-                let sdf = Sdf2d::viewport(self.pos * self.rect_size)
-                sdf.box(
-                    self.border_width,
-                    self.border_width,
-                    self.rect_size.x - (self.border_width * 2.0),
-                    self.rect_size.y - (self.border_width * 2.0),
-                    max(1.0, self.radius)
-                )
-                sdf.fill_keep(self.get_color())
-                if self.border_width > 0.0 {
-                    sdf.stroke(self.border_color, self.border_width)
-                }
-                return sdf.result;
-            }
-        }
-
-        draw_icon: {
-            instance color: #000
-            instance color_hover: #000
-            uniform rotation_angle: 0.0,
-
-            fn get_color(self) -> vec4 {
-                return mix(self.color, mix(self.color, self.color_hover, 0.2), self.hover)
-            }
-
-            // Support rotation of the icon
-            fn clip_and_transform_vertex(self, rect_pos: vec2, rect_size: vec2) -> vec4 {
-                let clipped: vec2 = clamp(
-                    self.geom_pos * rect_size + rect_pos,
-                    self.draw_clip.xy,
-                    self.draw_clip.zw
-                )
-                self.pos = (clipped - rect_pos) / rect_size
-
-                // Calculate the texture coordinates based on the rotation angle
-                let angle_rad = self.rotation_angle * 3.14159265359 / 180.0;
-                let cos_angle = cos(angle_rad);
-                let sin_angle = sin(angle_rad);
-                let rot_matrix = mat2(
-                    cos_angle, -sin_angle,
-                    sin_angle, cos_angle
-                );
-                self.tex_coord1 = mix(
-                    self.icon_t1.xy,
-                    self.icon_t2.xy,
-                    (rot_matrix * (self.pos.xy - vec2(0.5))) + vec2(0.5)
-                );
-
-                return self.camera_projection * (self.camera_view * (self.view_transform * vec4(
-                    clipped.x,
-                    clipped.y,
-                    self.draw_depth + self.draw_zbias,
-                    1.
-                )))
-            }
-        }
-        icon_walk: {width: 16, height: 16}
-
-        draw_text: {
-            text_style: <REGULAR_TEXT>{font_size: 10},
-            color: #000
-            fn get_color(self) -> vec4 {
-                return self.color;
-            }
-        }
-    }
-
-
-    ICON_BLOCK_USER  = dep("crate://self/resources/icons/forbidden.svg")
-    ICON_CLOSE       = dep("crate://self/resources/icons/close.svg")
     ICON_DOUBLE_CHAT = dep("crate://self/resources/icons/double_chat.svg")
     ICON_COPY        = dep("crate://self/resources/icons/copy.svg")
     ICON_JUMP        = dep("crate://self/resources/icons/go_back.svg")
@@ -319,7 +228,7 @@ live_design! {
                 text: "Actions"
             }
 
-            direct_message_button = <UserProfileActionButton> {
+            direct_message_button = <RobrixIconButton> {
                 // TODO: support this button. Once this is implemented, uncomment the line in draw_walk()
                 enabled: false,
                 draw_icon: {
@@ -329,7 +238,7 @@ live_design! {
                 text: "Direct Message"
             }
 
-            copy_link_to_user_button = <UserProfileActionButton> {
+            copy_link_to_user_button = <RobrixIconButton> {
                 draw_icon: {
                     svg_file: (ICON_COPY)
                 }
@@ -337,7 +246,7 @@ live_design! {
                 text: "Copy Link to User"
             }
 
-            jump_to_read_receipt_button = <UserProfileActionButton> {
+            jump_to_read_receipt_button = <RobrixIconButton> {
                 enabled: false, // TODO: support this button
                 draw_icon: {
                     svg_file: (ICON_JUMP)
@@ -346,7 +255,7 @@ live_design! {
                 text: "Jump to Read Receipt"
             }
 
-            ignore_user_button = <UserProfileActionButton> {
+            ignore_user_button = <RobrixIconButton> {
                 draw_icon: {
                     svg_file: (ICON_BLOCK_USER)
                     color: (COLOR_DANGER_RED),
@@ -392,7 +301,7 @@ live_design! {
             user_profile_view = <UserProfileView> { }
 
             // The "X" close button on the top left
-            close_button = <UserProfileActionButton> {
+            close_button = <RobrixIconButton> {
                 width: Fit,
                 height: Fit,
                 align: {x: 0.0, y: 0.0},
diff --git a/src/shared/icon_button.rs b/src/shared/icon_button.rs
new file mode 100644
index 00000000..2fe91272
--- /dev/null
+++ b/src/shared/icon_button.rs
@@ -0,0 +1,96 @@
+use makepad_widgets::*;
+
+live_design! {
+    import makepad_draw::shader::std::*;
+    import makepad_widgets::base::*;
+    import makepad_widgets::theme_desktop_dark::*;
+
+    import crate::shared::styles::*;
+
+    // Customized button widget, based on the RoundedView shaders with some modifications
+    // which is a better fit with our application UI design
+    RobrixIconButton = <Button> {
+        width: Fit,
+        height: Fit,
+        spacing: 10,
+        padding: {top: 10, bottom: 10, left: 8, right: 15}
+
+        draw_bg: {
+            instance color: (COLOR_PRIMARY)
+            instance color_hover: #A
+            instance border_width: 0.0
+            instance border_color: #D0D5DD
+            instance radius: 3.0
+
+            fn get_color(self) -> vec4 {
+                return mix(self.color, mix(self.color, self.color_hover, 0.2), self.hover)
+            }
+
+            fn pixel(self) -> vec4 {
+                let sdf = Sdf2d::viewport(self.pos * self.rect_size)
+                sdf.box(
+                    self.border_width,
+                    self.border_width,
+                    self.rect_size.x - (self.border_width * 2.0),
+                    self.rect_size.y - (self.border_width * 2.0),
+                    max(1.0, self.radius)
+                )
+                sdf.fill_keep(self.get_color())
+                if self.border_width > 0.0 {
+                    sdf.stroke(self.border_color, self.border_width)
+                }
+                return sdf.result;
+            }
+        }
+
+        draw_icon: {
+            instance color: #000
+            instance color_hover: #000
+            uniform rotation_angle: 0.0,
+
+            fn get_color(self) -> vec4 {
+                return mix(self.color, mix(self.color, self.color_hover, 0.2), self.hover)
+            }
+
+            // Support rotation of the icon
+            fn clip_and_transform_vertex(self, rect_pos: vec2, rect_size: vec2) -> vec4 {
+                let clipped: vec2 = clamp(
+                    self.geom_pos * rect_size + rect_pos,
+                    self.draw_clip.xy,
+                    self.draw_clip.zw
+                )
+                self.pos = (clipped - rect_pos) / rect_size
+
+                // Calculate the texture coordinates based on the rotation angle
+                let angle_rad = self.rotation_angle * 3.14159265359 / 180.0;
+                let cos_angle = cos(angle_rad);
+                let sin_angle = sin(angle_rad);
+                let rot_matrix = mat2(
+                    cos_angle, -sin_angle,
+                    sin_angle, cos_angle
+                );
+                self.tex_coord1 = mix(
+                    self.icon_t1.xy,
+                    self.icon_t2.xy,
+                    (rot_matrix * (self.pos.xy - vec2(0.5))) + vec2(0.5)
+                );
+
+                return self.camera_projection * (self.camera_view * (self.view_transform * vec4(
+                    clipped.x,
+                    clipped.y,
+                    self.draw_depth + self.draw_zbias,
+                    1.
+                )))
+            }
+        }
+        icon_walk: {width: 16, height: 16}
+
+        draw_text: {
+            text_style: <REGULAR_TEXT>{font_size: 10},
+            color: #000
+            fn get_color(self) -> vec4 {
+                return self.color;
+            }
+        }
+    }
+}
diff --git a/src/shared/mod.rs b/src/shared/mod.rs
index daa1e993..ebbd8378 100644
--- a/src/shared/mod.rs
+++ b/src/shared/mod.rs
@@ -6,6 +6,7 @@ pub mod cached_widget;
 pub mod clickable_view;
 pub mod helpers;
 pub mod html_or_plaintext;
+pub mod icon_button;
 pub mod search_bar;
 pub mod styles;
 pub mod text_or_image;
@@ -15,6 +16,7 @@ pub fn live_design(cx: &mut Cx) {
     // Order matters here, as some widget definitions depend on others.
     styles::live_design(cx);
     helpers::live_design(cx);
+    icon_button::live_design(cx);
     search_bar::live_design(cx);
     clickable_view::live_design(cx);
     avatar::live_design(cx);
diff --git a/src/shared/styles.rs b/src/shared/styles.rs
index 8d1ced89..9dbb27a4 100644
--- a/src/shared/styles.rs
+++ b/src/shared/styles.rs
@@ -1,6 +1,12 @@
 use makepad_widgets::*;
 
 live_design! {
+
+    ICON_BLOCK_USER  = dep("crate://self/resources/icons/forbidden.svg")
+    ICON_CHECKMARK   = dep("crate://self/resources/icons/checkmark.svg")
+    ICON_CLOSE       = dep("crate://self/resources/icons/close.svg")
+
+
     TITLE_TEXT = {
         font_size: (13),
         font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
@@ -62,6 +68,7 @@ live_design! {
     COLOR_DIVIDER_DARK = #x00000044
 
     COLOR_DANGER_RED = #xDC0005
+    COLOR_ACCEPT_GREEN = #x138808
 
     COLOR_PRIMARY = #ffffff
     COLOR_PRIMARY_DARKER = #fefefe
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 0720090c..f7a9f707 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -43,7 +43,7 @@ use crate::{
     }, media_cache::MediaCacheEntry, persistent_state::{self, ClientSessionPersisted}, profile::{
         user_profile::{AvatarState, UserProfile},
         user_profile_cache::{enqueue_user_profile_update, UserProfileUpdate},
-    }, utils::MEDIA_THUMBNAIL_FORMAT
+    }, utils::MEDIA_THUMBNAIL_FORMAT, verification::add_verification_event_handlers_and_sync_client
 };
 
 
@@ -911,6 +911,8 @@ async fn async_main_loop() -> Result<()> {
 
     CLIENT.set(client.clone()).expect("BUG: CLIENT already set!");
 
+    add_verification_event_handlers_and_sync_client(client.clone());
+
     // Listen for updates to the ignored user list.
     handle_ignore_user_list_subscriber(client.clone());
 
@@ -1132,6 +1134,7 @@ async fn current_ignore_user_list(client: &Client) -> Option<BTreeSet<OwnedUserI
 
 fn handle_ignore_user_list_subscriber(client: Client) {
     let mut subscriber = client.subscribe_to_ignore_user_list_changes();
+    log!("Initial ignored-user list is: {:?}", subscriber.get());
     Handle::current().spawn(async move {
         let mut first_update = true;
         while let Some(ignore_list) = subscriber.next().await {
@@ -1167,6 +1170,7 @@ fn handle_ignore_user_list_subscriber(client: Client) {
 
 
 fn handle_sync_service_state_subscriber(mut subscriber: Subscriber<sync_service::State>) {
+    log!("Initial sync service state is {:?}", subscriber.get());
     Handle::current().spawn(async move {
         while let Some(state) = subscriber.next().await {
             log!("Received a sync service state update: {state:?}");
@@ -1182,6 +1186,7 @@ fn handle_sync_service_state_subscriber(mut subscriber: Subscriber<sync_service:
 
 
 fn handle_room_list_service_loading_state(mut loading_state: Subscriber<RoomListLoadingState>) {
+    log!("Initial room list loading state is {:?}", loading_state.get());
     Handle::current().spawn(async move {
         while let Some(state) = loading_state.next().await {
             log!("Received a room list loading state update: {state:?}");
@@ -1197,6 +1202,7 @@ fn handle_room_list_service_loading_state(mut loading_state: Subscriber<RoomList
     });
 }
 
+
 const LOG_TIMELINE_DIFFS: bool = false;
 
 async fn timeline_subscriber_handler(
diff --git a/src/verification.rs b/src/verification.rs
new file mode 100644
index 00000000..4246f8aa
--- /dev/null
+++ b/src/verification.rs
@@ -0,0 +1,296 @@
+use futures_util::StreamExt;
+use makepad_widgets::{error, log, Cx, DefaultNone};
+use matrix_sdk::{
+    config::SyncSettings, crypto::{AcceptedProtocols, CancelInfo, EmojiShortAuthString}, encryption::verification::{
+        SasState, SasVerification, Verification, VerificationRequest,
+        VerificationRequestState,
+    }, ruma::{
+        events::{
+            key::verification::{request::ToDeviceKeyVerificationRequestEvent, VerificationMethod},
+            room::message::{MessageType, OriginalSyncRoomMessageEvent},
+        },
+        UserId,
+    }, Client
+};
+use tokio::{runtime::Handle, sync::mpsc::{UnboundedReceiver, UnboundedSender}};
+
+
+
+pub fn add_verification_event_handlers_and_sync_client(client: Client) {
+    let mut verficiation_state_subscriber = client.encryption().verification_state();
+    log!("Initial verification state is {:?}", verficiation_state_subscriber.get());
+    Handle::current().spawn(async move {
+        while let Some(state) = verficiation_state_subscriber.next().await {
+            log!("Received a verification state update: {state:?}");
+            // TODO: send an update to the main top-level app instance
+            //       such that we can display the verification state as an icon badge
+            //       atop the user's profile avatar.
+        }
+    });
+
+    client.add_event_handler(
+        |ev: ToDeviceKeyVerificationRequestEvent, client: Client| async move {
+            let request = client
+                .encryption()
+                .get_verification_request(&ev.sender, &ev.content.transaction_id)
+                .await
+                .expect("Request object wasn't created");
+
+            Handle::current().spawn(request_verification_handler(client, request));
+        },
+    );
+
+    client.add_event_handler(
+        |ev: OriginalSyncRoomMessageEvent, client: Client| async move {
+            if let MessageType::VerificationRequest(_) = &ev.content.msgtype {
+                let request = client
+                    .encryption()
+                    .get_verification_request(&ev.sender, &ev.event_id)
+                    .await
+                    .expect("Request object wasn't created");
+
+                Handle::current().spawn(request_verification_handler(client, request));
+            }
+        }
+    );
+
+    Handle::current().spawn(async move {
+        client.sync(SyncSettings::new()).await
+            .expect("Client sync loop failed");
+    });
+
+}
+
+
+async fn dump_devices(user_id: &UserId, client: &Client) -> String {
+    let mut devices = String::new();
+    for device in client.encryption().get_user_devices(user_id).await.unwrap().devices() {
+        let current = client.device_id().is_some_and(|id| id == device.device_id());
+        devices.push_str(&format!(
+            "    {:<10} {:<30} {:<}{}\n",
+            device.device_id(),
+            device.display_name().unwrap_or("(unknown name)"),
+            if device.is_verified() { "✅" } else { "❌" },
+            if current { " <-- this device" } else { "" },
+        ));
+    }
+    format!("Currently-known devices of user {user_id}:\n{}",
+        if devices.is_empty() { "    (none)" } else { &devices },
+    )
+}
+
+
+async fn sas_verification_handler(
+    client: Client,
+    sas: SasVerification,
+    response_receiver: UnboundedReceiver<VerificationUserResponse>,
+) {
+    log!(
+        "Starting verification with {} {}",
+        &sas.other_device().user_id(),
+        &sas.other_device().device_id()
+    );
+    log!("[Pre-verification] {}", dump_devices(sas.other_device().user_id(), &client).await);
+
+    let mut stream = sas.changes();
+    // Accept the SAS verification with both default methods: emoji and decimal.
+    if let Err(e) = sas.accept().await {
+        log!("Error accepting SAS verification request: {:?}", e);
+        Cx::post_action(VerificationAction::RequestAcceptError(e));
+        return;
+    }
+
+    // A little trick to allow us to move the response_receiver into the async block below.
+    let mut receiver_opt = Some(response_receiver);
+
+    while let Some(state) = stream.next().await {
+        match state {
+            SasState::Created { .. }
+            | SasState::Started { .. } => { } // we've already passed these states
+
+            SasState::Accepted { accepted_protocols } => Cx::post_action(
+                VerificationAction::SasAccepted(accepted_protocols)
+            ),
+
+            SasState::KeysExchanged { emojis, decimals } => {
+                Cx::post_action(VerificationAction::KeysExchanged { emojis, decimals });
+                let Some(mut receiver) = receiver_opt.take() else {
+                    error!("BUG: SasState::KeysExchanged occurred more than once!");
+                    let _ = sas.cancel().await;
+                    Cx::post_action(
+                        VerificationAction::RequestCancelError(
+                            matrix_sdk::Error::Io(std::io::Error::new(
+                                std::io::ErrorKind::Other,
+                                "BUG: SasState::KeysExchanged occurred more than once!",
+                            ))
+                        )
+                    );
+                    return;
+                };
+                let sas2 = sas.clone();
+                Handle::current().spawn(async move {
+                    log!("Waiting for user to confirm SAS verification keys...");
+                    match receiver.recv().await {
+                        Some(VerificationUserResponse::Accept) => {
+                            log!("User confirmed SAS verification keys");
+                            if let Err(e) = sas2.confirm().await {
+                                log!("Failed to confirm SAS verification keys; error: {:?}", e);
+                                Cx::post_action(VerificationAction::SasConfirmationError(e));
+                            }
+                            // If successful, SAS verification will now transition to the Confirmed state,
+                            // which will be sent to the main UI thread in the `SasState::Confirmed` match arm below.
+                        }
+                        Some(VerificationUserResponse::Cancel) | None => {
+                            log!("User did not confirm SAS verification keys");
+                            let _ = sas2.cancel().await;
+                        }
+                    }
+
+                });
+            }
+
+            SasState::Confirmed => Cx::post_action(VerificationAction::SasConfirmed),
+
+            SasState::Done { verified_devices, verified_identities } => {
+                let device = sas.other_device();
+                log!("SAS verification done.
+                    Devices: {verified_devices:?}
+                    Identities: {verified_identities:?}",
+                );
+                log!(
+                    "Successfully verified device {} {} {:?}",
+                    device.user_id(),
+                    device.device_id(),
+                    device.local_trust_state()
+                );
+                log!("[Post-verification] {}", dump_devices(sas.other_device().user_id(), &client).await);
+                // No need to send a specific action here, the VerificationRequestState stream loop 
+                // will handle the Done state and send a RequestCompleted action.
+                break;
+            }
+            SasState::Cancelled(cancel_info) => {
+                log!("SAS verification has been cancelled, reason: {}", cancel_info.reason());
+                // No need to send a specific action here, the VerificationRequestState stream loop 
+                // will handle the Cancelled state and send a RequestCancelled action.
+                break;
+            }
+        }
+    }
+}
+
+async fn request_verification_handler(client: Client, request: VerificationRequest) {
+    log!("Received a verification request in room {:?}: {:?}", request.room_id(), request.state());
+    let (sender, mut response_receiver) = tokio::sync::mpsc::unbounded_channel::<VerificationUserResponse>();
+    Cx::post_action(
+        VerificationAction::RequestReceived {
+            request: request.clone(),
+            response_sender: sender.clone(),
+        }
+    );
+
+    let mut stream = request.changes();
+
+    // We currently only support SAS verification.
+    let supported_methods = vec![VerificationMethod::SasV1];
+    match response_receiver.recv().await {
+        Some(VerificationUserResponse::Accept) => match request.accept_with_methods(supported_methods).await {
+            Ok(()) => {
+                Cx::post_action(VerificationAction::RequestAccepted);
+                // Fall through to the stream loop below.
+            }
+            Err(e) => {
+                Cx::post_action(VerificationAction::RequestAcceptError(e));
+                return;
+            }
+        }
+        Some(VerificationUserResponse::Cancel) | None => match request.cancel().await {
+            Ok(()) => { } // response will be sent in the stream loop below
+            Err(e) => {
+                Cx::post_action(VerificationAction::RequestCancelError(e));
+                return;
+            }
+        }
+    };
+
+    while let Some(state) = stream.next().await {
+        match state {
+            VerificationRequestState::Created { .. }
+            | VerificationRequestState::Requested { .. }
+            | VerificationRequestState::Ready { .. } => { }
+            VerificationRequestState::Transitioned { verification } => match verification {
+                // We only support SAS verification.
+                Verification::SasV1(sas) => {
+                    log!("Verification request transitioned to SAS V1.");
+                    Handle::current().spawn(sas_verification_handler(client, sas, response_receiver));
+                    return;
+                }
+                unsupported => {
+                    log!("Verification request transitioned to unsupported method: {:?}", unsupported);
+                    Cx::post_action(VerificationAction::RequestTransitionedToUnsupportedMethod(unsupported));
+                    return;
+                }
+            }
+            VerificationRequestState::Cancelled(info) => {
+                log!("Verification request was cancelled, reason: {}", info.reason());
+                Cx::post_action(VerificationAction::RequestCancelled(info));
+            }
+            VerificationRequestState::Done => {
+                log!("Verification request is done!");
+                Cx::post_action(VerificationAction::RequestCompleted);
+                return;
+            }
+        }
+    }
+}
+
+
+/// Actions related to verification that should be handled by the top-level app context.
+#[derive(Debug, DefaultNone)]
+pub enum VerificationAction {
+    /// Informs the main UI thread that a verification request has been received.
+    RequestReceived {
+        request: VerificationRequest,
+        response_sender: UnboundedSender<VerificationUserResponse>,
+    },
+    /// Informs the main UI thread that a verification request was cancelled successfully.
+    RequestCancelled(CancelInfo),
+    /// Informs the main UI thread that a verification request was accepted successfully.
+    /// This is effectively just a status update for the sake of user awareness;
+    /// the user doesn't need to do anything to respond to this, but rather only needs
+    /// to wait for the verification to proceed to the next step.
+    RequestAccepted,
+    /// Informs the main UI thread that an error occurred while accepting a verification request.
+    RequestAcceptError(matrix_sdk::Error),
+    /// Informs the main UI thread that an error occurred while cancelling a verification request.
+    RequestCancelError(matrix_sdk::Error),
+    /// Informs the main UI thread that a verification request transitioned to an unsupported method.
+    RequestTransitionedToUnsupportedMethod(Verification),
+    /// Informs the main UI thread that the given SAS verification protocols
+    /// have been accepted by both sides.
+    /// This is effectively just a status update for the sake of user awareness;
+    /// the user doesn't need to do anything to respond to this, but rather only needs
+    /// to wait for the verification to proceed to the next step, i.e., KeysExchanged.
+    SasAccepted(AcceptedProtocols),
+    /// Informs the main UI thread that the SAS verification has exchanged keys with the other side.
+    /// The UI should display the given keys to the user for interactive confirmation.
+    KeysExchanged {
+        emojis: Option<EmojiShortAuthString>,
+        decimals: (u16, u16, u16),
+    },
+    /// Informs the main UI thread that SAS verification keys have been confirmed by the current user,
+    /// and that we're just waiting for the other side to confirm too.
+    SasConfirmed,
+    /// Informs the main UI thread that an error occurred while confirming SAS verification keys.
+    SasConfirmationError(matrix_sdk::Error),
+    /// Informs the main UI thread that a verification request has been fully completed.
+    RequestCompleted,
+    None,
+}
+
+/// Responses that the user can make to a verification request,
+/// which are then sent from the main UI thread to the background async task
+/// that originally received the verification request.
+pub enum VerificationUserResponse {
+    Accept,
+    Cancel,
+}
diff --git a/src/verification_modal.rs b/src/verification_modal.rs
new file mode 100644
index 00000000..e6df7195
--- /dev/null
+++ b/src/verification_modal.rs
@@ -0,0 +1,367 @@
+use makepad_widgets::*;
+use matrix_sdk::encryption::verification::{Verification, VerificationRequest};
+use tokio::sync::mpsc::UnboundedSender;
+
+use crate::verification::{VerificationAction, VerificationUserResponse};
+
+live_design! {
+    import makepad_widgets::base::*;
+    import makepad_widgets::theme_desktop_dark::*;
+    import makepad_draw::shader::std::*;
+
+    import crate::shared::styles::*;
+    import crate::shared::widgets::MolyButton;
+
+    VerificationModal = {{VerificationModal}} {
+        width: Fit
+        height: Fit
+
+        wrapper = <RoundedView> {
+            flow: Down
+            width: 600
+            height: Fit
+            padding: {top: 44, right: 30 bottom: 30 left: 50}
+            spacing: 10
+
+            show_bg: true
+            draw_bg: {
+                color: #fff
+                radius: 3
+            }
+
+            <View> {
+                width: Fill,
+                height: Fit,
+                flow: Right
+
+                padding: {top: 8, bottom: 20}
+
+                title = <View> {
+                    width: Fit,
+                    height: Fit,
+
+                    <Label> {
+                        text: "Verification Request"
+                        draw_text: {
+                            text_style: <TITLE_TEXT>{font_size: 13},
+                            color: #000
+                        }
+                    }
+                }
+
+                filler_x = <View> {width: Fill, height: Fit}
+
+                // The "X" close button on the top right corner.
+                close_button = <RobrixIconButton> {
+                    width: Fit,
+                    height: Fit,
+                    align: {x: 1.0, y: 0.0},
+                    margin: 7,
+                    padding: 15,
+
+                    draw_icon: {
+                        svg_file: (ICON_CLOSE),
+                        fn get_color(self) -> vec4 {
+                            return #x0;
+                        }
+                    }
+                    icon_walk: {width: 14, height: 14}
+                }
+            }
+
+            body = <View> {
+                width: Fill,
+                height: Fit,
+                flow: Down,
+                spacing: 40,
+
+                prompt = <Label> {
+                    width: Fill
+                    draw_text: {
+                        text_style: <REGULAR_TEXT>{
+                            font_size: 10,
+                            height_factor: 1.3
+                        },
+                        color: #000
+                        wrap: Word
+                    }
+                }
+
+                actions = <View> {
+                    width: Fill, height: Fit
+                    flow: Right,
+                    align: {x: 1.0, y: 0.5}
+                    spacing: 20
+
+                    cancel_button = <RobrixIconButton> {
+                        draw_icon: {
+                            svg_file: (ICON_BLOCK_USER)
+                            color: (COLOR_DANGER_RED),
+                        }
+                        icon_walk: {width: 16, height: 16, margin: {left: -2, right: -1} }
+        
+                        draw_bg: {
+                            border_color: (COLOR_DANGER_RED),
+                            color: #fff0f0 // light red
+                        }
+                        text: "Cancel"
+                        draw_text:{
+                            color: (COLOR_DANGER_RED),
+                        }
+                    }
+
+                    accept_button = <RobrixIconButton> {
+                        draw_icon: {
+                            svg_file: (ICON_CHECKMARK)
+                            color: (COLOR_ACCEPT_GREEN),
+                        }
+                        icon_walk: {width: 16, height: 16, margin: {left: -2, right: -1} }
+        
+                        draw_bg: {
+                            border_color: (COLOR_ACCEPT_GREEN),
+                            color: #f0fff0 // light green
+                        }
+                        text: "Yes"
+                        draw_text:{
+                            color: (COLOR_ACCEPT_GREEN),
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Live, LiveHook, Widget)]
+pub struct VerificationModal {
+    #[deref] view: View,
+    #[rust] state: Option<VerificationModalState>,
+    /// Whether the modal is in a "final" state,
+    /// meaning that the verification process has ended
+    /// and that any further interaction with it should close the modal.
+    #[rust(false)] is_final: bool,
+}
+
+struct VerificationModalState {
+    request: VerificationRequest,
+    response_sender: UnboundedSender<VerificationUserResponse>,
+}
+
+#[derive(Clone, Debug, DefaultNone)]
+pub enum VerificationModalAction {
+    None,
+    Close,
+}
+
+impl Widget for VerificationModal {
+    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
+        self.view.handle_event(cx, event, scope);
+        self.widget_match_event(cx, event, scope);
+    }
+
+    fn draw_walk(&mut self, cx: &mut Cx2d, scope: &mut Scope, walk: Walk) -> DrawStep {
+        self.view.draw_walk(cx, scope, walk.with_abs_pos(DVec2 { x: 0., y: 0. }))
+    }
+}
+
+impl WidgetMatchEvent for VerificationModal {
+    fn handle_actions(&mut self, cx: &mut Cx, actions: &Actions, scope: &mut Scope) {
+        let widget_uid = self.widget_uid();
+        let accept_button = self.button(id!(accept_button));
+        let cancel_button = self.button(id!(cancel_button));
+
+        if cancel_button.clicked(actions)
+            || self.button(id!(close_button)).clicked(actions)
+            || actions.iter().find(|a| matches!(a.downcast_ref(), Some(ModalAction::Dismissed))).is_some()
+        {
+            if let Some(state) = self.state.as_ref() {
+                let _ = state.response_sender.send(VerificationUserResponse::Cancel);
+            }
+            cx.widget_action(widget_uid, &scope.path, VerificationModalAction::Close);
+            self.reset_state();
+        }
+
+        if self.button(id!(accept_button)).clicked(actions) {
+            if self.is_final {
+                cx.widget_action(widget_uid, &scope.path, VerificationModalAction::Close);
+                self.reset_state();
+            } else {
+                if let Some(state) = self.state.as_ref() {
+                    let _ = state.response_sender.send(VerificationUserResponse::Accept);
+                }
+            }
+        }
+
+        for action in actions {
+            match action.as_widget_action().cast() {
+                VerificationAction::None => { }
+            
+                VerificationAction::RequestReceived { request, response_sender } => {
+                    log!("Shouldn't happen - received a redundant verification request: {:?}", request);
+                }
+
+                VerificationAction::RequestCancelled(cancel_info) => {
+                    self.label(id!(prompt)).set_text(
+                        &format!("Verification request was cancelled: {}", cancel_info.reason())
+                    );
+                    accept_button.set_enabled(true);
+                    accept_button.set_text("Ok");
+                    cancel_button.set_visible(false);
+                    self.is_final = true;
+                }
+
+                VerificationAction::RequestAccepted => {
+                    self.label(id!(prompt)).set_text(
+                        "You successfully accepted the verification request.\n\n\
+                        Waiting for the other device to agree on verification methods..."
+                    );
+                    accept_button.set_enabled(false);
+                    accept_button.set_text("Waiting...");
+                    cancel_button.set_text("Cancel");
+                    cancel_button.set_enabled(true);
+                    cancel_button.set_visible(true);
+                }
+
+                VerificationAction::RequestAcceptError(error) => {
+                    self.label(id!(prompt)).set_text(&format!(
+                        "Error accepting verification request: {}\n\n\
+                        Please try the verification process again.",
+                        error,
+                    ));
+                    accept_button.set_enabled(true);
+                    accept_button.set_text("Ok");
+                    cancel_button.set_visible(false);
+                    self.is_final = true;
+                }
+
+                VerificationAction::RequestCancelError(error) => {
+                    self.label(id!(prompt)).set_text(
+                        &format!("Error cancelling verification request: {}.", error)
+                    );
+                    accept_button.set_enabled(true);
+                    accept_button.set_text("Ok");
+                    cancel_button.set_visible(false);
+                    self.is_final = true;
+                }
+
+                VerificationAction::RequestTransitionedToUnsupportedMethod(method) => {
+                    self.label(id!(prompt)).set_text(
+                        &format!(
+                            "Verification request transitioned to unsupported method: {}\n\nPlease try the verification process again.",
+                            match method {
+                                Verification::SasV1(_) => "Short Authentication String",
+                                // Verification::QrV1(_) => "QR Code",
+                                other => "Unknown",
+                            },
+                        )
+                    );
+                    accept_button.set_enabled(true);
+                    accept_button.set_text("Ok");
+                    cancel_button.set_visible(false);
+                    self.is_final = true;
+                }
+
+                VerificationAction::SasAccepted(accepted_protocols) => {
+                    self.label(id!(prompt)).set_text(&format!(
+                        "Both sides have accepted the same verification method(s).\n\n\
+                        Waiting for both devices to exchange keys..."
+                    ));
+                    accept_button.set_enabled(false);
+                    accept_button.set_text("Waiting...");
+                    cancel_button.set_text("Cancel");
+                    cancel_button.set_enabled(true);
+                    cancel_button.set_visible(true);
+                }
+
+                VerificationAction::KeysExchanged { emojis, decimals } => {
+                    self.label(id!(prompt)).set_text(&format!(
+                        "Keys have been exchanged. Please verify the following:\n\n\
+                        - Emojis: {:?}\n\
+                        - Decimals: {:?}\n\n\
+                        Do these keys match?",
+                        emojis, decimals
+                    ));
+                    accept_button.set_enabled(true);
+                    accept_button.set_text("Yes");
+                    cancel_button.set_text("No");
+                    cancel_button.set_enabled(true);
+                    cancel_button.set_visible(true);
+                }
+
+                VerificationAction::SasConfirmed => {
+                    self.label(id!(prompt)).set_text(
+                        "You successfully confirmed the Short Auth Strings.\n\n\
+                        Waiting for the other device to confirm..."
+                    );
+                    accept_button.set_enabled(false);
+                    accept_button.set_text("Waiting...");
+                    cancel_button.set_text("Cancel");
+                    cancel_button.set_enabled(true);
+                    cancel_button.set_visible(true);
+                }
+
+                VerificationAction::SasConfirmationError(error) => {
+                    self.label(id!(prompt)).set_text(
+                        &format!("Error confirming keys: {}\n\nPlease try the verification process again.", error)
+                    );
+                    accept_button.set_text("Ok");
+                    accept_button.set_enabled(true);
+                    cancel_button.set_visible(false);
+                    self.is_final = true;
+                }
+
+                VerificationAction::RequestCompleted => {
+                    self.label(id!(prompt)).set_text("Verification completed successfully!");
+                    accept_button.set_text("Ok");
+                    accept_button.set_enabled(true);
+                    cancel_button.set_visible(false);
+                }
+            }
+        }
+    }
+}
+
+impl VerificationModal {
+    fn reset_state(&mut self) {
+        self.state = None;
+        self.is_final = false;
+    }
+}
+
+impl VerificationModalRef {
+    pub fn initialize_with_data(
+        &self,
+        request: VerificationRequest,
+        response_sender: UnboundedSender<VerificationUserResponse>,
+    ) {
+        if let Some(mut inner) = self.borrow_mut() {
+            let prompt_text = if request.is_self_verification() {
+                format!("Do you wish to verify your own device?")
+            } else {
+                if let Some(room_id) = request.room_id() {
+                    format!("Do you wish to verify user {} in room {}?",
+                        request.other_user_id(),
+                        room_id,
+                    )
+                } else {
+                    format!("Do you wish to verify user {}?",
+                        request.other_user_id()
+                    )
+                }
+            };
+            self.label(id!(prompt)).set_text(&prompt_text);
+
+            let accept_button = self.button(id!(accept_button));
+            let cancel_button = self.button(id!(cancel_button));
+            accept_button.set_text("Yes");
+            accept_button.set_enabled(true);
+            accept_button.set_visible(true);
+            cancel_button.set_text("Cancel");
+            cancel_button.set_enabled(true);
+            cancel_button.set_visible(true);
+
+            inner.state = Some(VerificationModalState { request, response_sender });
+            inner.is_final = false;
+        }
+    }
+}

From 1364e58001e2f6929085919afd0d36a70fa06607 Mon Sep 17 00:00:00 2001
From: Kevin Boos <kevinaboos@gmail.com>
Date: Sun, 6 Oct 2024 16:00:42 -0700
Subject: [PATCH 2/4] Interactive user verification is working fully!

---
 Cargo.lock                      |  37 +---
 Cargo.toml                      |   4 +-
 src/app.rs                      |  20 +-
 src/home/room_preview.rs        |  14 +-
 src/home/room_screen.rs         |  35 ++--
 src/home/rooms_list.rs          |   6 +-
 src/home/spaces_dock.rs         |   2 +-
 src/shared/helpers.rs           |   3 +-
 src/shared/html_or_plaintext.rs |  24 ++-
 src/shared/styles.rs            |  14 +-
 src/sliding_sync.rs             |   4 +-
 src/verification.rs             | 114 ++++++-----
 src/verification_modal.rs       | 324 ++++++++++++++++----------------
 13 files changed, 294 insertions(+), 307 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7459b559..ba6fd353 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1723,7 +1723,6 @@ dependencies = [
 [[package]]
 name = "makepad-derive-live"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-id",
  "makepad-micro-proc-macro",
@@ -1732,7 +1731,6 @@ dependencies = [
 [[package]]
 name = "makepad-derive-wasm-bridge"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-micro-proc-macro",
 ]
@@ -1740,7 +1738,6 @@ dependencies = [
 [[package]]
 name = "makepad-derive-widget"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-id",
  "makepad-micro-proc-macro",
@@ -1749,7 +1746,6 @@ dependencies = [
 [[package]]
 name = "makepad-draw"
 version = "0.6.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "ab_glyph_rasterizer",
  "fxhash",
@@ -1766,17 +1762,14 @@ dependencies = [
 [[package]]
 name = "makepad-futures"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 
 [[package]]
 name = "makepad-futures-legacy"
 version = "0.7.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 
 [[package]]
 name = "makepad-html"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-id",
 ]
@@ -1784,7 +1777,6 @@ dependencies = [
 [[package]]
 name = "makepad-http"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 
 [[package]]
 name = "makepad-jni-sys"
@@ -1795,7 +1787,6 @@ checksum = "9775cbec5fa0647500c3e5de7c850280a88335d1d2d770e5aa2332b801ba7064"
 [[package]]
 name = "makepad-live-compiler"
 version = "0.5.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-derive-live",
  "makepad-live-tokenizer",
@@ -1805,7 +1796,6 @@ dependencies = [
 [[package]]
 name = "makepad-live-id"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-id-macros",
 ]
@@ -1813,7 +1803,6 @@ dependencies = [
 [[package]]
 name = "makepad-live-id-macros"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-micro-proc-macro",
 ]
@@ -1821,7 +1810,6 @@ dependencies = [
 [[package]]
 name = "makepad-live-tokenizer"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-id",
  "makepad-math",
@@ -1831,7 +1819,6 @@ dependencies = [
 [[package]]
 name = "makepad-markdown"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-id",
 ]
@@ -1839,17 +1826,14 @@ dependencies = [
 [[package]]
 name = "makepad-math"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 
 [[package]]
 name = "makepad-micro-proc-macro"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 
 [[package]]
 name = "makepad-micro-serde"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-id",
  "makepad-micro-serde-derive",
@@ -1858,7 +1842,6 @@ dependencies = [
 [[package]]
 name = "makepad-micro-serde-derive"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-micro-proc-macro",
 ]
@@ -1866,12 +1849,10 @@ dependencies = [
 [[package]]
 name = "makepad-objc-sys"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 
 [[package]]
 name = "makepad-platform"
 version = "0.6.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "hilog-sys",
  "makepad-android-state",
@@ -1893,7 +1874,6 @@ dependencies = [
 [[package]]
 name = "makepad-rustybuzz"
 version = "0.8.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "bitflags 1.3.2",
  "bytemuck",
@@ -1908,7 +1888,6 @@ dependencies = [
 [[package]]
 name = "makepad-shader-compiler"
 version = "0.5.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-live-compiler",
 ]
@@ -1916,7 +1895,6 @@ dependencies = [
 [[package]]
 name = "makepad-vector"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "resvg",
  "ttf-parser",
@@ -1925,7 +1903,6 @@ dependencies = [
 [[package]]
 name = "makepad-wasm-bridge"
 version = "0.4.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-derive-wasm-bridge",
  "makepad-live-id",
@@ -1934,7 +1911,6 @@ dependencies = [
 [[package]]
 name = "makepad-widgets"
 version = "0.6.0"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-derive-widget",
  "makepad-draw",
@@ -1948,16 +1924,14 @@ dependencies = [
 [[package]]
 name = "makepad-windows"
 version = "0.51.1"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
- "windows-core 0.51.1 (git+https://github.com/makepad/makepad?branch=rik)",
+ "windows-core 0.51.1",
  "windows-targets 0.48.5",
 ]
 
 [[package]]
 name = "makepad-zune-core"
 version = "0.2.14"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "bitflags 2.4.1",
 ]
@@ -1965,7 +1939,6 @@ dependencies = [
 [[package]]
 name = "makepad-zune-inflate"
 version = "0.2.54"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "simd-adler32",
 ]
@@ -1973,7 +1946,6 @@ dependencies = [
 [[package]]
 name = "makepad-zune-jpeg"
 version = "0.3.17"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-zune-core",
 ]
@@ -1981,7 +1953,6 @@ dependencies = [
 [[package]]
 name = "makepad-zune-png"
 version = "0.2.1"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 dependencies = [
  "makepad-zune-core",
  "makepad-zune-inflate",
@@ -3967,7 +3938,6 @@ checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
 [[package]]
 name = "ttf-parser"
 version = "0.21.1"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
 
 [[package]]
 name = "typenum"
@@ -4364,8 +4334,6 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 [[package]]
 name = "windows-core"
 version = "0.51.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
 dependencies = [
  "windows-targets 0.48.5",
 ]
@@ -4373,7 +4341,8 @@ dependencies = [
 [[package]]
 name = "windows-core"
 version = "0.51.1"
-source = "git+https://github.com/makepad/makepad?branch=rik#98cc605647409a95c60405837ff1fbeb35100a4b"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
 dependencies = [
  "windows-targets 0.48.5",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 48e47290..28f991c7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,7 +16,9 @@ version = "0.0.1-pre-alpha"
 metadata.makepad-auto-version = "zqpv-Yj-K7WNVK2I8h5Okhho46Q="
 
 [dependencies]
-makepad-widgets = { git = "https://github.com/makepad/makepad", branch = "rik" }
+# makepad-widgets = { git = "https://github.com/makepad/makepad", branch = "rik" }
+makepad-widgets = { path = "../makepad/widgets" }
+
 ## Including this crate automatically configures all `robius-*` crates to work with Makepad.
 robius-use-makepad = "0.1.0"
 robius-open = "0.1.0"
diff --git a/src/app.rs b/src/app.rs
index 6dcdc44e..04fae7b9 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -13,10 +13,11 @@ live_design! {
     import makepad_draw::shader::std::*;
 
     import crate::shared::styles::*;
-    import crate::shared::clickable_view::ClickableView
-    import crate::home::home_screen::HomeScreen
-    import crate::home::room_screen::RoomScreen
-    import crate::profile::my_profile_screen::MyProfileScreen
+    import crate::shared::clickable_view::ClickableView;
+    import crate::home::home_screen::HomeScreen;
+    import crate::home::room_screen::RoomScreen;
+    import crate::profile::my_profile_screen::MyProfileScreen;
+    import crate::verification_modal::VerificationModal;
 
     ICON_CHAT = dep("crate://self/resources/icons/chat.svg")
     ICON_CONTACTS = dep("crate://self/resources/icons/contacts.svg")
@@ -188,13 +189,12 @@ impl MatchEvent for App {
                 RoomListAction::None => { }
             }
 
-            // TODO FIXME: need to add a cast_ref() method to WidgetAction
-            //             that doesn't require the action to be clonable.
-            match action.as_widget_action().cast() {
-                VerificationAction::RequestReceived { request, response_sender } => {
-                    log!("Received a new verification request: {:?}", request);
+            // `VerificationAction`s come from a background thread, so they are NOT widget actions.
+            // Therefore, we cannot use `as_widget_action().cast()` to match them.
+            match action.downcast_ref() {
+                Some(VerificationAction::RequestReceived(state)) => {
                     self.ui.verification_modal(id!(verification_modal_inner))
-                        .initialize_with_data(request, response_sender);
+                        .initialize_with_data(state.clone());
                     self.ui.modal(id!(verification_modal)).open(cx);
                 }
                 // other verification actions are handled by the verification modal itself.
diff --git a/src/home/room_preview.rs b/src/home/room_preview.rs
index b8212b41..cb559e39 100644
--- a/src/home/room_preview.rs
+++ b/src/home/room_preview.rs
@@ -50,16 +50,16 @@ live_design! {
         latest_message = <HtmlOrPlaintext> {
             padding: {top: 3.0}
             html_view = { html = {
-                font_size: 9.3, line_spacing: 1.,
-                draw_normal:      { text_style: { font_size: 9.3, line_spacing: 1. } },
-                draw_italic:      { text_style: { font_size: 9.3, line_spacing: 1. } },
-                draw_bold:        { text_style: { font_size: 9.3, line_spacing: 1. } },
-                draw_bold_italic: { text_style: { font_size: 9.3, line_spacing: 1. } },
-                draw_fixed:       { text_style: { font_size: 9.3, line_spacing: 1. } },
+                font_size: 9.3,
+                draw_normal:      { text_style: { font_size: 9.3 } },
+                draw_italic:      { text_style: { font_size: 9.3 } },
+                draw_bold:        { text_style: { font_size: 9.3 } },
+                draw_bold_italic: { text_style: { font_size: 9.3 } },
+                draw_fixed:       { text_style: { font_size: 9.3 } },
             } }
             plaintext_view = { pt_label = {
                 draw_text: {
-                    text_style: { font_size: 9.5, line_spacing: 1. },
+                    text_style: { font_size: 9.5 },
                 }
                 text: "[Loading latest message]"
             } }
diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index a836df4f..0f8ad193 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -65,13 +65,13 @@ live_design! {
 
     TEXT_SUB = {
         font_size: (10),
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
     }
 
     TEXT_P = {
         font_size: (12),
         height_factor: 1.65,
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
     }
 
     COLOR_BG = #xfff8ee
@@ -262,7 +262,7 @@ live_design! {
         draw_bg: {
             border_width: 0.0,
             border_color: #000,
-            radius: 2
+            radius: 2.0
         }
 
         reply_button = <IconButton> {
@@ -560,20 +560,18 @@ live_design! {
     DayDivider = <View> {
         width: Fill,
         height: Fit,
-        margin: 0.0,
+        margin: {top: 7.0, bottom: 7.0}
         flow: Right,
-        padding: 0.0,
+        padding: {left: 7.0, right: 7.0},
         spacing: 0.0,
         align: {x: 0.5, y: 0.5} // center horizontally and vertically
 
         left_line = <LineH> {
-            margin: {top: 10.0, bottom: 10.0}
             draw_bg: {color: (COLOR_DIVIDER_DARK)}
         }
 
         date = <Label> {
             padding: {left: 7.0, right: 7.0}
-            margin: {bottom: 10.0, top: 10.0}
             draw_text: {
                 text_style: <TEXT_SUB> {},
                 color: (COLOR_DIVIDER_DARK)
@@ -582,7 +580,6 @@ live_design! {
         }
 
         right_line = <LineH> {
-            margin: {top: 10.0, bottom: 10.0}
             draw_bg: {color: (COLOR_DIVIDER_DARK)}
         }
     }
@@ -1313,7 +1310,7 @@ impl Widget for RoomScreen {
                     let Some(timeline_item) = tl_items.get(tl_idx) else {
                         // This shouldn't happen (unless the timeline gets corrupted or some other weird error),
                         // but we can always safely fill the item with an empty widget that takes up no space.
-                        list.item(cx, item_id, live_id!(Empty)).unwrap();
+                        list.item(cx, item_id, live_id!(Empty));
                         continue;
                     };
 
@@ -1378,13 +1375,13 @@ impl Widget for RoomScreen {
                                 item_drawn_status,
                             ),
                             unhandled => {
-                                let item = list.item(cx, item_id, live_id!(SmallStateEvent)).unwrap();
+                                let item = list.item(cx, item_id, live_id!(SmallStateEvent));
                                 item.label(id!(content)).set_text(&format!("[TODO] {:?}", unhandled));
                                 (item, ItemDrawnStatus::both_drawn())
                             }
                         }
                         TimelineItemKind::Virtual(VirtualTimelineItem::DayDivider(millis)) => {
-                            let item = list.item(cx, item_id, live_id!(DayDivider)).unwrap();
+                            let item = list.item(cx, item_id, live_id!(DayDivider));
                             let text = unix_time_millis_to_datetime(&millis)
                                 // format the time as a shortened date (Sat, Sept 5, 2021)
                                 .map(|dt| format!("{}", dt.date_naive().format("%a %b %-d, %Y")))
@@ -1393,7 +1390,7 @@ impl Widget for RoomScreen {
                             (item, ItemDrawnStatus::both_drawn())
                         }
                         TimelineItemKind::Virtual(VirtualTimelineItem::ReadMarker) => {
-                            let item = list.item(cx, item_id, live_id!(ReadMarker)).unwrap();
+                            let item = list.item(cx, item_id, live_id!(ReadMarker));
                             (item, ItemDrawnStatus::both_drawn())
                         }
                     };
@@ -2096,7 +2093,7 @@ fn populate_message_view(
             } else {
                 live_id!(Message)
             };
-            let (item, existed) = list.item_with_existed(cx, item_id, template).unwrap();
+            let (item, existed) = list.item_with_existed(cx, item_id, template);
             if existed && item_drawn_status.content_drawn {
                 (item, true)
             } else {
@@ -2114,7 +2111,7 @@ fn populate_message_view(
             } else {
                 live_id!(ImageMessage)
             };
-            let (item, existed) = list.item_with_existed(cx, item_id, template).unwrap();
+            let (item, existed) = list.item_with_existed(cx, item_id, template);
             if existed && item_drawn_status.content_drawn {
                 (item, true)
             } else {
@@ -2129,7 +2126,7 @@ fn populate_message_view(
             }
         }
         other => {
-            let (item, existed) = list.item_with_existed(cx, item_id, live_id!(Message)).unwrap();
+            let (item, existed) = list.item_with_existed(cx, item_id, live_id!(Message));
             if existed && item_drawn_status.content_drawn {
                 (item, true)
             } else {
@@ -2513,7 +2510,7 @@ impl SmallStateEventContent for timeline::OtherState {
             new_drawn_status.content_drawn = true;
             item
         } else {
-            let item = list.item(cx, item_id, live_id!(Empty)).unwrap();
+            let item = list.item(cx, item_id, live_id!(Empty));
             new_drawn_status = ItemDrawnStatus::new();
             item
         };
@@ -2555,7 +2552,7 @@ impl SmallStateEventContent for RoomMembershipChange {
         let Some(preview) = text_preview_of_room_membership_change(self) else {
             // Don't actually display anything for nonexistent/unimportant membership changes.
             return (
-                list.item(cx, item_id, live_id!(Empty)).unwrap(),
+                list.item(cx, item_id, live_id!(Empty)),
                 ItemDrawnStatus::new(),
             );
         };
@@ -2582,9 +2579,7 @@ fn populate_small_state_event(
     item_drawn_status: ItemDrawnStatus,
 ) -> (WidgetRef, ItemDrawnStatus) {
     let mut new_drawn_status = item_drawn_status;
-    let (item, existed) = list
-        .item_with_existed(cx, item_id, live_id!(SmallStateEvent))
-        .unwrap();
+    let (item, existed) = list.item_with_existed(cx, item_id, live_id!(SmallStateEvent));
 
     // The content of a small state event view may depend on the profile info,
     // so we can only mark the content as drawn after the profile has been fully drawn and cached.
diff --git a/src/home/rooms_list.rs b/src/home/rooms_list.rs
index 90669931..e29e5113 100644
--- a/src/home/rooms_list.rs
+++ b/src/home/rooms_list.rs
@@ -295,7 +295,7 @@ impl Widget for RoomsList {
 
                 // Draw the room preview for each room.
                 let item = if let Some(room_info) = self.all_rooms.get_mut(item_id) {
-                    let item = list.item(cx, item_id, live_id!(room_preview)).unwrap();
+                    let item = list.item(cx, item_id, live_id!(room_preview));
                     self.rooms_list_map.insert(item.widget_uid().0, item_id);
                     room_info.is_selected = self.current_active_room_index == Some(item_id);
 
@@ -316,7 +316,7 @@ impl Widget for RoomsList {
                 }
                 // Draw the status label as the bottom entry.
                 else if item_id == status_label_id {
-                    let item = list.item(cx, item_id, live_id!(status_label)).unwrap();
+                    let item = list.item(cx, item_id, live_id!(status_label));
                     item.as_view().apply_over(cx, live!{
                         height: Fit,
                         label = { text: (&self.status) }
@@ -325,7 +325,7 @@ impl Widget for RoomsList {
                 }
                 // Draw a filler entry to take up space at the bottom of the portal list.
                 else {
-                    list.item(cx, item_id, live_id!(bottom_filler)).unwrap()
+                    list.item(cx, item_id, live_id!(bottom_filler))
                 };
 
                 item.draw_all(cx, &mut scope);
diff --git a/src/home/spaces_dock.rs b/src/home/spaces_dock.rs
index 8b4d8f03..c6273420 100644
--- a/src/home/spaces_dock.rs
+++ b/src/home/spaces_dock.rs
@@ -60,7 +60,7 @@ live_design! {
         show_bg: true
         draw_bg: {
             color: (COLOR_PRIMARY_DARKER)
-            radius: 4
+            radius: 4.0
             border_color: (COLOR_SELECTED_PRIMARY)
             border_width: 1.5
         }
diff --git a/src/shared/helpers.rs b/src/shared/helpers.rs
index 098f7720..95082d05 100644
--- a/src/shared/helpers.rs
+++ b/src/shared/helpers.rs
@@ -17,9 +17,10 @@ live_design! {
 
     LineH = <RoundedView> {
         width: Fill,
-        height: 2,
+        height: 2.0,
         margin: 0.0,
         padding: 0.0, spacing: 0.0
+        show_bg: true
         draw_bg: {color: (COLOR_DIVIDER)}
     }
 
diff --git a/src/shared/html_or_plaintext.rs b/src/shared/html_or_plaintext.rs
index 03b44e17..aae62292 100644
--- a/src/shared/html_or_plaintext.rs
+++ b/src/shared/html_or_plaintext.rs
@@ -11,9 +11,8 @@ live_design! {
 
     // These match the `MESSAGE_*` styles defined in `styles.rs`.
     // For some reason, they're not the same. That's TBD.
-    HTML_LINE_SPACING = 6.0
-    HTML_TEXT_HEIGHT_FACTOR = 1.1
-    HTML_BLOCK_LINE_SPACING = 5.0
+    // HTML_LINE_SPACING = 6.0
+    // HTML_TEXT_HEIGHT_FACTOR = 1.1
 
 
     // This is an HTML subwidget used to handle `<font>` and `<span>` tags,
@@ -25,7 +24,7 @@ live_design! {
         draw_text: {
             wrap: Word,
             color: (MESSAGE_TEXT_COLOR),
-            text_style: <MESSAGE_TEXT_STYLE> { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) },
+            text_style: <MESSAGE_TEXT_STYLE> { } //height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) },
         }
         text: "MatrixHtmlSpan placeholder",
 
@@ -35,15 +34,14 @@ live_design! {
     // message content. This is a wrapper around Makepad's built-in `Html` widget.
     RobrixHtml = <Html> {
         padding: 0.0,
-        line_spacing: (HTML_LINE_SPACING),
         width: Fill, height: Fit, // see comment in `HtmlOrPlaintext`
         font_size: (MESSAGE_FONT_SIZE),
         font_color: (MESSAGE_TEXT_COLOR),
-        draw_normal:      { color: (MESSAGE_TEXT_COLOR), text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
-        draw_italic:      { color: (MESSAGE_TEXT_COLOR), text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
-        draw_bold:        { color: (MESSAGE_TEXT_COLOR), text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
-        draw_bold_italic: { color: (MESSAGE_TEXT_COLOR), text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
-        draw_fixed:       { color: (MESSAGE_TEXT_COLOR), text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
+        draw_normal:      { color: (MESSAGE_TEXT_COLOR), } // text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
+        draw_italic:      { color: (MESSAGE_TEXT_COLOR), } // text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
+        draw_bold:        { color: (MESSAGE_TEXT_COLOR), } // text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
+        draw_bold_italic: { color: (MESSAGE_TEXT_COLOR), } // text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
+        draw_fixed:       { color: (MESSAGE_TEXT_COLOR), } // text_style: { height_factor: (HTML_TEXT_HEIGHT_FACTOR), line_spacing: (HTML_LINE_SPACING) } }
         draw_block: {
             line_color: (MESSAGE_TEXT_COLOR)
             sep_color: (MESSAGE_TEXT_COLOR)
@@ -51,9 +49,9 @@ live_design! {
             quote_bg_color: (#EDEDED)
             quote_fg_color: (MESSAGE_TEXT_COLOR)
         }
-        list_item_layout: { line_spacing: (HTML_BLOCK_LINE_SPACING), padding: {left: 5.0, top: 1.0, bottom: 1.0}, }
-        code_layout: { line_spacing: (HTML_BLOCK_LINE_SPACING), padding: {left: 7.0, right: 7.0, top: 8.0, bottom: 0.0}, }
-        quote_layout: { line_spacing: (HTML_BLOCK_LINE_SPACING), padding: {top: 0.0, bottom: 0.0}, }
+        list_item_layout: { padding: {left: 5.0, top: 1.0, bottom: 1.0}, }
+        code_layout: { padding: {left: 7.0, right: 7.0, top: 8.0, bottom: 0.0}, }
+        quote_layout: { padding: {top: 0.0, bottom: 0.0}, }
         inline_code_padding: { left: 5.0, right: 5.0, top: 7.0, bottom: 0.0 }
 
         font = <MatrixHtmlSpan> { }
diff --git a/src/shared/styles.rs b/src/shared/styles.rs
index 9dbb27a4..43686f40 100644
--- a/src/shared/styles.rs
+++ b/src/shared/styles.rs
@@ -9,24 +9,24 @@ live_design! {
 
     TITLE_TEXT = {
         font_size: (13),
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
     }
 
     REGULAR_TEXT = {
         font_size: (10),
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
     }
 
     TEXT_SUB = {
         font_size: (8),
         height_factor: 1.5,
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
     }
 
     USERNAME_FONT_SIZE = 11
     USERNAME_TEXT_COLOR = #x2
     USERNAME_TEXT_STYLE = {
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Bold.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-SemiBold.ttf")}
         font_size: (USERNAME_FONT_SIZE),
         // height_factor: 1.5,
     }
@@ -40,7 +40,7 @@ live_design! {
     // This font should only be used for plaintext labels. Don't use this for Html content,
     // as the Html widget sets different fonts for different text styles (e.g., bold, italic).
     MESSAGE_TEXT_STYLE = {
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
         font_size: (MESSAGE_FONT_SIZE),
         height_factor: (MESSAGE_TEXT_HEIGHT_FACTOR),
         line_spacing: (MESSAGE_TEXT_LINE_SPACING),
@@ -51,7 +51,7 @@ live_design! {
     SMALL_STATE_FONT_SIZE = 9.0
     SMALL_STATE_TEXT_COLOR = #x888
     SMALL_STATE_TEXT_STYLE = {
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
         font_size: (SMALL_STATE_FONT_SIZE),
         height_factor: 1.3,
     }
@@ -59,7 +59,7 @@ live_design! {
     TIMESTAMP_FONT_SIZE = 8.5
     TIMESTAMP_TEXT_COLOR = #x999
     TIMESTAMP_TEXT_STYLE = {
-        font: {path: dep("crate://makepad-widgets/resources/GoNotoKurrent-Regular.ttf")}
+        font: {path: dep("crate://makepad-widgets/resources/IBMPlexSans-Text.ttf")}
         font_size: (TIMESTAMP_FONT_SIZE),
     }
 
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index f7a9f707..32d5b064 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -1219,7 +1219,9 @@ async fn timeline_subscriber_handler(
         new_items: timeline_items.clone(),
         changed_indices: usize::MIN..usize::MAX,
         clear_cache: true,
-    }).expect("Error: timeline update sender couldn't send update with initial items!");
+    }).unwrap_or_else(
+        |_e| panic!("Error: timeline update sender couldn't send update to room {room_id} with initial items!")
+    );
 
     let mut latest_event = timeline.latest_event().await;
 
diff --git a/src/verification.rs b/src/verification.rs
index 4246f8aa..b39af77d 100644
--- a/src/verification.rs
+++ b/src/verification.rs
@@ -1,7 +1,8 @@
+use std::sync::Arc;
 use futures_util::StreamExt;
-use makepad_widgets::{error, log, Cx, DefaultNone};
+use makepad_widgets::{Cx, DefaultNone, log};
 use matrix_sdk::{
-    config::SyncSettings, crypto::{AcceptedProtocols, CancelInfo, EmojiShortAuthString}, encryption::verification::{
+    crypto::{AcceptedProtocols, CancelInfo, EmojiShortAuthString}, encryption::verification::{
         SasState, SasVerification, Verification, VerificationRequest,
         VerificationRequestState,
     }, ruma::{
@@ -54,11 +55,16 @@ pub fn add_verification_event_handlers_and_sync_client(client: Client) {
         }
     );
 
+    // This doesn't seem to be necessary, as we do receive verification requests
+    // without this block. 
+    // The sliding sync service must be handling the synchronization already.
+    //
+    /*
     Handle::current().spawn(async move {
         client.sync(SyncSettings::new()).await
             .expect("Client sync loop failed");
     });
-
+    */
 }
 
 
@@ -96,13 +102,12 @@ async fn sas_verification_handler(
     // Accept the SAS verification with both default methods: emoji and decimal.
     if let Err(e) = sas.accept().await {
         log!("Error accepting SAS verification request: {:?}", e);
-        Cx::post_action(VerificationAction::RequestAcceptError(e));
+        Cx::post_action(VerificationAction::RequestAcceptError(Arc::new(e)));
         return;
     }
 
     // A little trick to allow us to move the response_receiver into the async block below.
     let mut receiver_opt = Some(response_receiver);
-
     while let Some(state) = stream.next().await {
         match state {
             SasState::Created { .. }
@@ -114,39 +119,32 @@ async fn sas_verification_handler(
 
             SasState::KeysExchanged { emojis, decimals } => {
                 Cx::post_action(VerificationAction::KeysExchanged { emojis, decimals });
-                let Some(mut receiver) = receiver_opt.take() else {
-                    error!("BUG: SasState::KeysExchanged occurred more than once!");
-                    let _ = sas.cancel().await;
-                    Cx::post_action(
-                        VerificationAction::RequestCancelError(
-                            matrix_sdk::Error::Io(std::io::Error::new(
-                                std::io::ErrorKind::Other,
-                                "BUG: SasState::KeysExchanged occurred more than once!",
-                            ))
-                        )
-                    );
-                    return;
-                };
-                let sas2 = sas.clone();
-                Handle::current().spawn(async move {
-                    log!("Waiting for user to confirm SAS verification keys...");
-                    match receiver.recv().await {
-                        Some(VerificationUserResponse::Accept) => {
-                            log!("User confirmed SAS verification keys");
-                            if let Err(e) = sas2.confirm().await {
-                                log!("Failed to confirm SAS verification keys; error: {:?}", e);
-                                Cx::post_action(VerificationAction::SasConfirmationError(e));
+                if let Some(mut receiver) = receiver_opt.take() {
+                    let sas2 = sas.clone();
+                    Handle::current().spawn(async move {
+                        log!("Waiting for user to confirm SAS verification keys...");
+                        match receiver.recv().await {
+                            Some(VerificationUserResponse::Accept) => {
+                                log!("User confirmed SAS verification keys");
+                                if let Err(e) = sas2.confirm().await {
+                                    log!("Failed to confirm SAS verification keys; error: {:?}", e);
+                                    Cx::post_action(VerificationAction::SasConfirmationError(Arc::new(e)));
+                                }
+                                // If successful, SAS verification will now transition to the Confirmed state,
+                                // which will be sent to the main UI thread in the `SasState::Confirmed` match arm below.
+                            }
+                            Some(VerificationUserResponse::Cancel) | None => {
+                                log!("User did not confirm SAS verification keys");
+                                let _ = sas2.cancel().await;
                             }
-                            // If successful, SAS verification will now transition to the Confirmed state,
-                            // which will be sent to the main UI thread in the `SasState::Confirmed` match arm below.
-                        }
-                        Some(VerificationUserResponse::Cancel) | None => {
-                            log!("User did not confirm SAS verification keys");
-                            let _ = sas2.cancel().await;
                         }
-                    }
-
-                });
+                    });
+                } else {
+                    // Receiving a second `KeysExchanged` state indicates that the other device
+                    // confirmed their keys match the ones we have *before* we confirmed them.
+                    log!("The other side confirmed that the displayed keys matched.");
+                };
+                
             }
 
             SasState::Confirmed => Cx::post_action(VerificationAction::SasConfirmed),
@@ -164,8 +162,10 @@ async fn sas_verification_handler(
                     device.local_trust_state()
                 );
                 log!("[Post-verification] {}", dump_devices(sas.other_device().user_id(), &client).await);
-                // No need to send a specific action here, the VerificationRequestState stream loop 
-                // will handle the Done state and send a RequestCompleted action.
+                // We go ahead and send the RequestCompleted action here,
+                // because it is not guaranteed that the VerificationRequestState stream loop 
+                // will receive an update an enter the `Done` state.
+                Cx::post_action(VerificationAction::RequestCompleted);
                 break;
             }
             SasState::Cancelled(cancel_info) => {
@@ -182,10 +182,12 @@ async fn request_verification_handler(client: Client, request: VerificationReque
     log!("Received a verification request in room {:?}: {:?}", request.room_id(), request.state());
     let (sender, mut response_receiver) = tokio::sync::mpsc::unbounded_channel::<VerificationUserResponse>();
     Cx::post_action(
-        VerificationAction::RequestReceived {
-            request: request.clone(),
-            response_sender: sender.clone(),
-        }
+        VerificationAction::RequestReceived(
+            VerificationRequestActionState {
+                request: request.clone(),
+                response_sender: sender.clone(),
+            }
+        )
     );
 
     let mut stream = request.changes();
@@ -199,14 +201,14 @@ async fn request_verification_handler(client: Client, request: VerificationReque
                 // Fall through to the stream loop below.
             }
             Err(e) => {
-                Cx::post_action(VerificationAction::RequestAcceptError(e));
+                Cx::post_action(VerificationAction::RequestAcceptError(Arc::new(e)));
                 return;
             }
         }
         Some(VerificationUserResponse::Cancel) | None => match request.cancel().await {
             Ok(()) => { } // response will be sent in the stream loop below
             Err(e) => {
-                Cx::post_action(VerificationAction::RequestCancelError(e));
+                Cx::post_action(VerificationAction::RequestCancelError(Arc::new(e)));
                 return;
             }
         }
@@ -245,13 +247,10 @@ async fn request_verification_handler(client: Client, request: VerificationReque
 
 
 /// Actions related to verification that should be handled by the top-level app context.
-#[derive(Debug, DefaultNone)]
+#[derive(Clone, Debug, DefaultNone)]
 pub enum VerificationAction {
     /// Informs the main UI thread that a verification request has been received.
-    RequestReceived {
-        request: VerificationRequest,
-        response_sender: UnboundedSender<VerificationUserResponse>,
-    },
+    RequestReceived(VerificationRequestActionState),
     /// Informs the main UI thread that a verification request was cancelled successfully.
     RequestCancelled(CancelInfo),
     /// Informs the main UI thread that a verification request was accepted successfully.
@@ -260,9 +259,9 @@ pub enum VerificationAction {
     /// to wait for the verification to proceed to the next step.
     RequestAccepted,
     /// Informs the main UI thread that an error occurred while accepting a verification request.
-    RequestAcceptError(matrix_sdk::Error),
+    RequestAcceptError(Arc<matrix_sdk::Error>),
     /// Informs the main UI thread that an error occurred while cancelling a verification request.
-    RequestCancelError(matrix_sdk::Error),
+    RequestCancelError(Arc<matrix_sdk::Error>),
     /// Informs the main UI thread that a verification request transitioned to an unsupported method.
     RequestTransitionedToUnsupportedMethod(Verification),
     /// Informs the main UI thread that the given SAS verification protocols
@@ -281,12 +280,23 @@ pub enum VerificationAction {
     /// and that we're just waiting for the other side to confirm too.
     SasConfirmed,
     /// Informs the main UI thread that an error occurred while confirming SAS verification keys.
-    SasConfirmationError(matrix_sdk::Error),
+    SasConfirmationError(Arc<matrix_sdk::Error>),
     /// Informs the main UI thread that a verification request has been fully completed.
     RequestCompleted,
     None,
 }
 
+/// The state included in a verification request action.
+/// 
+/// This is passed from the background async task to the main UI thread,
+/// where it is extracted from the `VerificationAction` and then stored
+/// in the `VerificationModal`` widget.
+#[derive(Clone, Debug)]
+pub struct VerificationRequestActionState {
+    pub request: VerificationRequest,
+    pub response_sender: UnboundedSender<VerificationUserResponse>,
+}
+
 /// Responses that the user can make to a verification request,
 /// which are then sent from the main UI thread to the background async task
 /// that originally received the verification request.
diff --git a/src/verification_modal.rs b/src/verification_modal.rs
index e6df7195..f4f228b3 100644
--- a/src/verification_modal.rs
+++ b/src/verification_modal.rs
@@ -1,8 +1,7 @@
 use makepad_widgets::*;
-use matrix_sdk::encryption::verification::{Verification, VerificationRequest};
-use tokio::sync::mpsc::UnboundedSender;
+use matrix_sdk::encryption::verification::Verification;
 
-use crate::verification::{VerificationAction, VerificationUserResponse};
+use crate::verification::{VerificationAction, VerificationRequestActionState, VerificationUserResponse};
 
 live_design! {
     import makepad_widgets::base::*;
@@ -10,7 +9,7 @@ live_design! {
     import makepad_draw::shader::std::*;
 
     import crate::shared::styles::*;
-    import crate::shared::widgets::MolyButton;
+    import crate::shared::icon_button::RobrixIconButton;
 
     VerificationModal = {{VerificationModal}} {
         width: Fit
@@ -26,7 +25,7 @@ live_design! {
             show_bg: true
             draw_bg: {
                 color: #fff
-                radius: 3
+                radius: 3.0
             }
 
             <View> {
@@ -135,18 +134,13 @@ live_design! {
 #[derive(Live, LiveHook, Widget)]
 pub struct VerificationModal {
     #[deref] view: View,
-    #[rust] state: Option<VerificationModalState>,
+    #[rust] state: Option<VerificationRequestActionState>,
     /// Whether the modal is in a "final" state,
     /// meaning that the verification process has ended
     /// and that any further interaction with it should close the modal.
     #[rust(false)] is_final: bool,
 }
 
-struct VerificationModalState {
-    request: VerificationRequest,
-    response_sender: UnboundedSender<VerificationUserResponse>,
-}
-
 #[derive(Clone, Debug, DefaultNone)]
 pub enum VerificationModalAction {
     None,
@@ -172,7 +166,6 @@ impl WidgetMatchEvent for VerificationModal {
 
         if cancel_button.clicked(actions)
             || self.button(id!(close_button)).clicked(actions)
-            || actions.iter().find(|a| matches!(a.downcast_ref(), Some(ModalAction::Dismissed))).is_some()
         {
             if let Some(state) = self.state.as_ref() {
                 let _ = state.response_sender.send(VerificationUserResponse::Cancel);
@@ -181,6 +174,14 @@ impl WidgetMatchEvent for VerificationModal {
             self.reset_state();
         }
 
+        if actions.iter().find(|a| matches!(a.downcast_ref(), Some(ModalAction::Dismissed))).is_some() {
+            // The modal was dismissed by clicking outside of it, so we do NOT need
+            // to emit a `VerificationModalAction::Close` action, as that would cause
+            // an infinite action feedback loop.
+            self.reset_state();
+        }
+
+
         if self.button(id!(accept_button)).clicked(actions) {
             if self.is_final {
                 cx.widget_action(widget_uid, &scope.path, VerificationModalAction::Close);
@@ -192,132 +193,139 @@ impl WidgetMatchEvent for VerificationModal {
             }
         }
 
+        let mut needs_redraw = false;
         for action in actions {
-            match action.as_widget_action().cast() {
-                VerificationAction::None => { }
-            
-                VerificationAction::RequestReceived { request, response_sender } => {
-                    log!("Shouldn't happen - received a redundant verification request: {:?}", request);
-                }
-
-                VerificationAction::RequestCancelled(cancel_info) => {
-                    self.label(id!(prompt)).set_text(
-                        &format!("Verification request was cancelled: {}", cancel_info.reason())
-                    );
-                    accept_button.set_enabled(true);
-                    accept_button.set_text("Ok");
-                    cancel_button.set_visible(false);
-                    self.is_final = true;
-                }
+            // `VerificationAction`s come from a background thread, so they are NOT widget actions.
+            // Therefore, we cannot use `as_widget_action().cast()` to match them.
+            if let Some(verification_action) = action.downcast_ref::<VerificationAction>() {
+                match verification_action {
+                    VerificationAction::RequestCancelled(cancel_info) => {
+                        self.label(id!(prompt)).set_text(
+                            &format!("Verification request was cancelled: {}", cancel_info.reason())
+                        );
+                        accept_button.set_enabled(true);
+                        accept_button.set_text("Ok");
+                        cancel_button.set_visible(false);
+                        self.is_final = true;
+                    }
 
-                VerificationAction::RequestAccepted => {
-                    self.label(id!(prompt)).set_text(
-                        "You successfully accepted the verification request.\n\n\
-                        Waiting for the other device to agree on verification methods..."
-                    );
-                    accept_button.set_enabled(false);
-                    accept_button.set_text("Waiting...");
-                    cancel_button.set_text("Cancel");
-                    cancel_button.set_enabled(true);
-                    cancel_button.set_visible(true);
-                }
+                    VerificationAction::RequestAccepted => {
+                        self.label(id!(prompt)).set_text(
+                            "You successfully accepted the verification request.\n\n\
+                            Waiting for the other device to agree on verification methods..."
+                        );
+                        accept_button.set_enabled(false);
+                        accept_button.set_text("Waiting...");
+                        cancel_button.set_text("Cancel");
+                        cancel_button.set_enabled(true);
+                        cancel_button.set_visible(true);
+                    }
 
-                VerificationAction::RequestAcceptError(error) => {
-                    self.label(id!(prompt)).set_text(&format!(
-                        "Error accepting verification request: {}\n\n\
-                        Please try the verification process again.",
-                        error,
-                    ));
-                    accept_button.set_enabled(true);
-                    accept_button.set_text("Ok");
-                    cancel_button.set_visible(false);
-                    self.is_final = true;
-                }
+                    VerificationAction::RequestAcceptError(error) => {
+                        self.label(id!(prompt)).set_text(&format!(
+                            "Error accepting verification request: {}\n\n\
+                            Please try the verification process again.",
+                            error,
+                        ));
+                        accept_button.set_enabled(true);
+                        accept_button.set_text("Ok");
+                        cancel_button.set_visible(false);
+                        self.is_final = true;
+                    }
 
-                VerificationAction::RequestCancelError(error) => {
-                    self.label(id!(prompt)).set_text(
-                        &format!("Error cancelling verification request: {}.", error)
-                    );
-                    accept_button.set_enabled(true);
-                    accept_button.set_text("Ok");
-                    cancel_button.set_visible(false);
-                    self.is_final = true;
-                }
+                    VerificationAction::RequestCancelError(error) => {
+                        self.label(id!(prompt)).set_text(
+                            &format!("Error cancelling verification request: {}.", error)
+                        );
+                        accept_button.set_enabled(true);
+                        accept_button.set_text("Ok");
+                        cancel_button.set_visible(false);
+                        self.is_final = true;
+                    }
 
-                VerificationAction::RequestTransitionedToUnsupportedMethod(method) => {
-                    self.label(id!(prompt)).set_text(
-                        &format!(
-                            "Verification request transitioned to unsupported method: {}\n\nPlease try the verification process again.",
-                            match method {
-                                Verification::SasV1(_) => "Short Authentication String",
-                                // Verification::QrV1(_) => "QR Code",
-                                other => "Unknown",
-                            },
-                        )
-                    );
-                    accept_button.set_enabled(true);
-                    accept_button.set_text("Ok");
-                    cancel_button.set_visible(false);
-                    self.is_final = true;
-                }
+                    VerificationAction::RequestTransitionedToUnsupportedMethod(method) => {
+                        self.label(id!(prompt)).set_text(
+                            &format!(
+                                "Verification request transitioned to unsupported method: {}\n\nPlease try the verification process again.",
+                                match method {
+                                    Verification::SasV1(_) => "Short Authentication String",
+                                    // Verification::QrV1(_) => "QR Code",
+                                    _other => "Unknown",
+                                },
+                            )
+                        );
+                        accept_button.set_enabled(true);
+                        accept_button.set_text("Ok");
+                        cancel_button.set_visible(false);
+                        self.is_final = true;
+                    }
 
-                VerificationAction::SasAccepted(accepted_protocols) => {
-                    self.label(id!(prompt)).set_text(&format!(
-                        "Both sides have accepted the same verification method(s).\n\n\
-                        Waiting for both devices to exchange keys..."
-                    ));
-                    accept_button.set_enabled(false);
-                    accept_button.set_text("Waiting...");
-                    cancel_button.set_text("Cancel");
-                    cancel_button.set_enabled(true);
-                    cancel_button.set_visible(true);
-                }
+                    VerificationAction::SasAccepted(_accepted_protocols) => {
+                        self.label(id!(prompt)).set_text(&format!(
+                            "Both sides have accepted the same verification method(s).\n\n\
+                            Waiting for both devices to exchange keys..."
+                        ));
+                        accept_button.set_enabled(false);
+                        accept_button.set_text("Waiting...");
+                        cancel_button.set_text("Cancel");
+                        cancel_button.set_enabled(true);
+                        cancel_button.set_visible(true);
+                    }
 
-                VerificationAction::KeysExchanged { emojis, decimals } => {
-                    self.label(id!(prompt)).set_text(&format!(
-                        "Keys have been exchanged. Please verify the following:\n\n\
-                        - Emojis: {:?}\n\
-                        - Decimals: {:?}\n\n\
-                        Do these keys match?",
-                        emojis, decimals
-                    ));
-                    accept_button.set_enabled(true);
-                    accept_button.set_text("Yes");
-                    cancel_button.set_text("No");
-                    cancel_button.set_enabled(true);
-                    cancel_button.set_visible(true);
-                }
+                    VerificationAction::KeysExchanged { emojis, decimals } => {
+                        self.label(id!(prompt)).set_text(&format!(
+                            "Keys have been exchanged. Please verify the following:\n\n\
+                            - Emojis: {:?}\n\
+                            - Decimals: {:?}\n\n\
+                            Do these keys match?",
+                            emojis, decimals
+                        ));
+                        accept_button.set_enabled(true);
+                        accept_button.set_text("Yes");
+                        cancel_button.set_text("No");
+                        cancel_button.set_enabled(true);
+                        cancel_button.set_visible(true);
+                    }
 
-                VerificationAction::SasConfirmed => {
-                    self.label(id!(prompt)).set_text(
-                        "You successfully confirmed the Short Auth Strings.\n\n\
-                        Waiting for the other device to confirm..."
-                    );
-                    accept_button.set_enabled(false);
-                    accept_button.set_text("Waiting...");
-                    cancel_button.set_text("Cancel");
-                    cancel_button.set_enabled(true);
-                    cancel_button.set_visible(true);
-                }
+                    VerificationAction::SasConfirmed => {
+                        self.label(id!(prompt)).set_text(
+                            "You successfully confirmed the Short Auth Strings.\n\n\
+                            Waiting for the other device to confirm..."
+                        );
+                        accept_button.set_enabled(false);
+                        accept_button.set_text("Waiting...");
+                        cancel_button.set_text("Cancel");
+                        cancel_button.set_enabled(true);
+                        cancel_button.set_visible(true);
+                    }
 
-                VerificationAction::SasConfirmationError(error) => {
-                    self.label(id!(prompt)).set_text(
-                        &format!("Error confirming keys: {}\n\nPlease try the verification process again.", error)
-                    );
-                    accept_button.set_text("Ok");
-                    accept_button.set_enabled(true);
-                    cancel_button.set_visible(false);
-                    self.is_final = true;
-                }
+                    VerificationAction::SasConfirmationError(error) => {
+                        self.label(id!(prompt)).set_text(
+                            &format!("Error confirming keys: {}\n\nPlease try the verification process again.", error)
+                        );
+                        accept_button.set_text("Ok");
+                        accept_button.set_enabled(true);
+                        cancel_button.set_visible(false);
+                        self.is_final = true;
+                    }
 
-                VerificationAction::RequestCompleted => {
-                    self.label(id!(prompt)).set_text("Verification completed successfully!");
-                    accept_button.set_text("Ok");
-                    accept_button.set_enabled(true);
-                    cancel_button.set_visible(false);
+                    VerificationAction::RequestCompleted => {
+                        self.label(id!(prompt)).set_text("Verification completed successfully!");
+                        accept_button.set_text("Ok");
+                        accept_button.set_enabled(true);
+                        cancel_button.set_visible(false);
+                        self.is_final = true;
+                    }
+                    _ => { }
                 }
+                // If we received a `VerificationAction`, we need to redraw the modal content.
+                needs_redraw = true;
             }
         }
+
+        if needs_redraw {
+            self.redraw(cx);
+        }
     }
 }
 
@@ -326,42 +334,44 @@ impl VerificationModal {
         self.state = None;
         self.is_final = false;
     }
+
+    fn initialize_with_data(&mut self, state: VerificationRequestActionState) {
+        log!("Initializing verification modal with state: {:?}", state);
+        let request = &state.request;
+        let prompt_text = if request.is_self_verification() {
+            format!("Do you wish to verify your own device?")
+        } else {
+            if let Some(room_id) = request.room_id() {
+                format!("Do you wish to verify user {} in room {}?",
+                    request.other_user_id(),
+                    room_id,
+                )
+            } else {
+                format!("Do you wish to verify user {}?",
+                    request.other_user_id()
+                )
+            }
+        };
+        self.label(id!(prompt)).set_text(&prompt_text);
+
+        let accept_button = self.button(id!(accept_button));
+        let cancel_button = self.button(id!(cancel_button));
+        accept_button.set_text("Yes");
+        accept_button.set_enabled(true);
+        accept_button.set_visible(true);
+        cancel_button.set_text("Cancel");
+        cancel_button.set_enabled(true);
+        cancel_button.set_visible(true);
+
+        self.state = Some(state);
+        self.is_final = false;
+    }
 }
 
 impl VerificationModalRef {
-    pub fn initialize_with_data(
-        &self,
-        request: VerificationRequest,
-        response_sender: UnboundedSender<VerificationUserResponse>,
-    ) {
+    pub fn initialize_with_data(&self, state: VerificationRequestActionState) {
         if let Some(mut inner) = self.borrow_mut() {
-            let prompt_text = if request.is_self_verification() {
-                format!("Do you wish to verify your own device?")
-            } else {
-                if let Some(room_id) = request.room_id() {
-                    format!("Do you wish to verify user {} in room {}?",
-                        request.other_user_id(),
-                        room_id,
-                    )
-                } else {
-                    format!("Do you wish to verify user {}?",
-                        request.other_user_id()
-                    )
-                }
-            };
-            self.label(id!(prompt)).set_text(&prompt_text);
-
-            let accept_button = self.button(id!(accept_button));
-            let cancel_button = self.button(id!(cancel_button));
-            accept_button.set_text("Yes");
-            accept_button.set_enabled(true);
-            accept_button.set_visible(true);
-            cancel_button.set_text("Cancel");
-            cancel_button.set_enabled(true);
-            cancel_button.set_visible(true);
-
-            inner.state = Some(VerificationModalState { request, response_sender });
-            inner.is_final = false;
+            inner.initialize_with_data(state);
         }
     }
 }

From 129cc4feec381787d569444c5a571f2d59f675df Mon Sep 17 00:00:00 2001
From: Kevin Boos <kevinaboos@gmail.com>
Date: Mon, 7 Oct 2024 00:40:11 -0700
Subject: [PATCH 3/4] Tested verification process more. Cleaned up and tweaked
 verification UI

Everything works beautifully now and is ready for merge.

Post-merge, there are some improvements we can make:
* If we're transitioning from an unverified/unknown device state
  to a verififed state, then we need to do two things for rooms
  that are E2EE:
  1. Re-request/re-render all of the latest messages
  2. Clear the drawn cache in those timelines.
---
 Cargo.lock                |  37 ++++++++++++--
 Cargo.toml                |   2 +-
 src/verification.rs       |   6 ++-
 src/verification_modal.rs | 101 +++++++++++++++++---------------------
 4 files changed, 84 insertions(+), 62 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ba6fd353..18306a9d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1723,6 +1723,7 @@ dependencies = [
 [[package]]
 name = "makepad-derive-live"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-id",
  "makepad-micro-proc-macro",
@@ -1731,6 +1732,7 @@ dependencies = [
 [[package]]
 name = "makepad-derive-wasm-bridge"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-micro-proc-macro",
 ]
@@ -1738,6 +1740,7 @@ dependencies = [
 [[package]]
 name = "makepad-derive-widget"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-id",
  "makepad-micro-proc-macro",
@@ -1746,6 +1749,7 @@ dependencies = [
 [[package]]
 name = "makepad-draw"
 version = "0.6.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "ab_glyph_rasterizer",
  "fxhash",
@@ -1762,14 +1766,17 @@ dependencies = [
 [[package]]
 name = "makepad-futures"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 
 [[package]]
 name = "makepad-futures-legacy"
 version = "0.7.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 
 [[package]]
 name = "makepad-html"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-id",
 ]
@@ -1777,6 +1784,7 @@ dependencies = [
 [[package]]
 name = "makepad-http"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 
 [[package]]
 name = "makepad-jni-sys"
@@ -1787,6 +1795,7 @@ checksum = "9775cbec5fa0647500c3e5de7c850280a88335d1d2d770e5aa2332b801ba7064"
 [[package]]
 name = "makepad-live-compiler"
 version = "0.5.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-derive-live",
  "makepad-live-tokenizer",
@@ -1796,6 +1805,7 @@ dependencies = [
 [[package]]
 name = "makepad-live-id"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-id-macros",
 ]
@@ -1803,6 +1813,7 @@ dependencies = [
 [[package]]
 name = "makepad-live-id-macros"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-micro-proc-macro",
 ]
@@ -1810,6 +1821,7 @@ dependencies = [
 [[package]]
 name = "makepad-live-tokenizer"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-id",
  "makepad-math",
@@ -1819,6 +1831,7 @@ dependencies = [
 [[package]]
 name = "makepad-markdown"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-id",
 ]
@@ -1826,14 +1839,17 @@ dependencies = [
 [[package]]
 name = "makepad-math"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 
 [[package]]
 name = "makepad-micro-proc-macro"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 
 [[package]]
 name = "makepad-micro-serde"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-id",
  "makepad-micro-serde-derive",
@@ -1842,6 +1858,7 @@ dependencies = [
 [[package]]
 name = "makepad-micro-serde-derive"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-micro-proc-macro",
 ]
@@ -1849,10 +1866,12 @@ dependencies = [
 [[package]]
 name = "makepad-objc-sys"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 
 [[package]]
 name = "makepad-platform"
 version = "0.6.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "hilog-sys",
  "makepad-android-state",
@@ -1874,6 +1893,7 @@ dependencies = [
 [[package]]
 name = "makepad-rustybuzz"
 version = "0.8.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "bitflags 1.3.2",
  "bytemuck",
@@ -1888,6 +1908,7 @@ dependencies = [
 [[package]]
 name = "makepad-shader-compiler"
 version = "0.5.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-live-compiler",
 ]
@@ -1895,6 +1916,7 @@ dependencies = [
 [[package]]
 name = "makepad-vector"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "resvg",
  "ttf-parser",
@@ -1903,6 +1925,7 @@ dependencies = [
 [[package]]
 name = "makepad-wasm-bridge"
 version = "0.4.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-derive-wasm-bridge",
  "makepad-live-id",
@@ -1911,6 +1934,7 @@ dependencies = [
 [[package]]
 name = "makepad-widgets"
 version = "0.6.0"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-derive-widget",
  "makepad-draw",
@@ -1924,14 +1948,16 @@ dependencies = [
 [[package]]
 name = "makepad-windows"
 version = "0.51.1"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
- "windows-core 0.51.1",
+ "windows-core 0.51.1 (git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content)",
  "windows-targets 0.48.5",
 ]
 
 [[package]]
 name = "makepad-zune-core"
 version = "0.2.14"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "bitflags 2.4.1",
 ]
@@ -1939,6 +1965,7 @@ dependencies = [
 [[package]]
 name = "makepad-zune-inflate"
 version = "0.2.54"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "simd-adler32",
 ]
@@ -1946,6 +1973,7 @@ dependencies = [
 [[package]]
 name = "makepad-zune-jpeg"
 version = "0.3.17"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-zune-core",
 ]
@@ -1953,6 +1981,7 @@ dependencies = [
 [[package]]
 name = "makepad-zune-png"
 version = "0.2.1"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "makepad-zune-core",
  "makepad-zune-inflate",
@@ -3938,6 +3967,7 @@ checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
 [[package]]
 name = "ttf-parser"
 version = "0.21.1"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 
 [[package]]
 name = "typenum"
@@ -4334,6 +4364,8 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 [[package]]
 name = "windows-core"
 version = "0.51.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
 dependencies = [
  "windows-targets 0.48.5",
 ]
@@ -4341,8 +4373,7 @@ dependencies = [
 [[package]]
 name = "windows-core"
 version = "0.51.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
+source = "git+https://github.com/kevinaboos/makepad?branch=modal_sends_dismissed_action_to_inner_modal_content#dd319e6e74d9d70f8c90fef639109ae32caee863"
 dependencies = [
  "windows-targets 0.48.5",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 28f991c7..9deb4084 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,7 @@ metadata.makepad-auto-version = "zqpv-Yj-K7WNVK2I8h5Okhho46Q="
 
 [dependencies]
 # makepad-widgets = { git = "https://github.com/makepad/makepad", branch = "rik" }
-makepad-widgets = { path = "../makepad/widgets" }
+makepad-widgets = { git = "https://github.com/kevinaboos/makepad", branch = "modal_sends_dismissed_action_to_inner_modal_content" }
 
 ## Including this crate automatically configures all `robius-*` crates to work with Makepad.
 robius-use-makepad = "0.1.0"
diff --git a/src/verification.rs b/src/verification.rs
index b39af77d..b71b4fc4 100644
--- a/src/verification.rs
+++ b/src/verification.rs
@@ -170,8 +170,10 @@ async fn sas_verification_handler(
             }
             SasState::Cancelled(cancel_info) => {
                 log!("SAS verification has been cancelled, reason: {}", cancel_info.reason());
-                // No need to send a specific action here, the VerificationRequestState stream loop 
-                // will handle the Cancelled state and send a RequestCancelled action.
+                // We go ahead and send the RequestCancelled action here,
+                // because it is not guaranteed that the VerificationRequestState stream loop 
+                // will receive an update an enter the `Cancelled` state.
+                Cx::post_action(VerificationAction::RequestCancelled(cancel_info));
                 break;
             }
         }
diff --git a/src/verification_modal.rs b/src/verification_modal.rs
index f4f228b3..ca13e35f 100644
--- a/src/verification_modal.rs
+++ b/src/verification_modal.rs
@@ -15,11 +15,11 @@ live_design! {
         width: Fit
         height: Fit
 
-        wrapper = <RoundedView> {
+        <RoundedView> {
             flow: Down
             width: 600
             height: Fit
-            padding: {top: 44, right: 30 bottom: 30 left: 50}
+            padding: {top: 25, right: 30 bottom: 30 left: 45}
             spacing: 10
 
             show_bg: true
@@ -28,43 +28,19 @@ live_design! {
                 radius: 3.0
             }
 
-            <View> {
+            title = <View> {
                 width: Fill,
                 height: Fit,
                 flow: Right
+                padding: {top: 0, bottom: 40}
+                align: {x: 0.5, y: 0.0}
 
-                padding: {top: 8, bottom: 20}
-
-                title = <View> {
-                    width: Fit,
-                    height: Fit,
-
-                    <Label> {
-                        text: "Verification Request"
-                        draw_text: {
-                            text_style: <TITLE_TEXT>{font_size: 13},
-                            color: #000
-                        }
-                    }
-                }
-
-                filler_x = <View> {width: Fill, height: Fit}
-
-                // The "X" close button on the top right corner.
-                close_button = <RobrixIconButton> {
-                    width: Fit,
-                    height: Fit,
-                    align: {x: 1.0, y: 0.0},
-                    margin: 7,
-                    padding: 15,
-
-                    draw_icon: {
-                        svg_file: (ICON_CLOSE),
-                        fn get_color(self) -> vec4 {
-                            return #x0;
-                        }
+                <Label> {
+                    text: "Verification Request"
+                    draw_text: {
+                        text_style: <TITLE_TEXT>{font_size: 13},
+                        color: #000
                     }
-                    icon_walk: {width: 14, height: 14}
                 }
             }
 
@@ -78,7 +54,7 @@ live_design! {
                     width: Fill
                     draw_text: {
                         text_style: <REGULAR_TEXT>{
-                            font_size: 10,
+                            font_size: 11.5,
                             height_factor: 1.3
                         },
                         color: #000
@@ -86,13 +62,14 @@ live_design! {
                     }
                 }
 
-                actions = <View> {
+                <View> {
                     width: Fill, height: Fit
                     flow: Right,
                     align: {x: 1.0, y: 0.5}
                     spacing: 20
 
                     cancel_button = <RobrixIconButton> {
+                        padding: {left: 15, right: 15}
                         draw_icon: {
                             svg_file: (ICON_BLOCK_USER)
                             color: (COLOR_DANGER_RED),
@@ -110,6 +87,7 @@ live_design! {
                     }
 
                     accept_button = <RobrixIconButton> {
+                        padding: {left: 15, right: 15}
                         draw_icon: {
                             svg_file: (ICON_CHECKMARK)
                             color: (COLOR_ACCEPT_GREEN),
@@ -164,25 +142,27 @@ impl WidgetMatchEvent for VerificationModal {
         let accept_button = self.button(id!(accept_button));
         let cancel_button = self.button(id!(cancel_button));
 
-        if cancel_button.clicked(actions)
-            || self.button(id!(close_button)).clicked(actions)
-        {
+        let cancel_button_clicked = cancel_button.clicked(actions);
+        let modal_dismissed = actions
+            .iter()
+            .find(|a| matches!(a.downcast_ref(), Some(ModalAction::Dismissed)))
+            .is_some();
+
+        if cancel_button_clicked || modal_dismissed {
             if let Some(state) = self.state.as_ref() {
                 let _ = state.response_sender.send(VerificationUserResponse::Cancel);
             }
-            cx.widget_action(widget_uid, &scope.path, VerificationModalAction::Close);
             self.reset_state();
-        }
 
-        if actions.iter().find(|a| matches!(a.downcast_ref(), Some(ModalAction::Dismissed))).is_some() {
-            // The modal was dismissed by clicking outside of it, so we do NOT need
-            // to emit a `VerificationModalAction::Close` action, as that would cause
+            // If the modal was dismissed by clicking outside of it, we MUST NOT emit
+            // a `VerificationModalAction::Close` action, as that would cause
             // an infinite action feedback loop.
-            self.reset_state();
+            if !modal_dismissed {
+                cx.widget_action(widget_uid, &scope.path, VerificationModalAction::Close);
+            }
         }
 
-
-        if self.button(id!(accept_button)).clicked(actions) {
+        if accept_button.clicked(actions) {
             if self.is_final {
                 cx.widget_action(widget_uid, &scope.path, VerificationModalAction::Close);
                 self.reset_state();
@@ -273,13 +253,22 @@ impl WidgetMatchEvent for VerificationModal {
                     }
 
                     VerificationAction::KeysExchanged { emojis, decimals } => {
-                        self.label(id!(prompt)).set_text(&format!(
-                            "Keys have been exchanged. Please verify the following:\n\n\
-                            - Emojis: {:?}\n\
-                            - Decimals: {:?}\n\n\
-                            Do these keys match?",
-                            emojis, decimals
-                        ));
+                        let text = if let Some(emoji_list) = emojis {
+                            format!(
+                                "Keys have been exchanged. Please verify the following emoji:\
+                                \n   {}\n\n\
+                                Do these emoji keys match?",
+                                emoji_list.emojis.iter().map(|em| em.description).collect::<Vec<_>>().join("\n   ")
+                            )
+                        } else {
+                            format!(
+                                "Keys have been exchanged. Please verify the following numbers:\n\
+                                \n   {}\n   {}\n   {}\n\n\
+                                Do these number keys match?",
+                                decimals.0, decimals.1, decimals.2,
+                            )
+                        };
+                        self.label(id!(prompt)).set_text(&text);;
                         accept_button.set_enabled(true);
                         accept_button.set_text("Yes");
                         cancel_button.set_text("No");
@@ -289,7 +278,7 @@ impl WidgetMatchEvent for VerificationModal {
 
                     VerificationAction::SasConfirmed => {
                         self.label(id!(prompt)).set_text(
-                            "You successfully confirmed the Short Auth Strings.\n\n\
+                            "You successfully confirmed the Short Auth String keys.\n\n\
                             Waiting for the other device to confirm..."
                         );
                         accept_button.set_enabled(false);
@@ -301,7 +290,7 @@ impl WidgetMatchEvent for VerificationModal {
 
                     VerificationAction::SasConfirmationError(error) => {
                         self.label(id!(prompt)).set_text(
-                            &format!("Error confirming keys: {}\n\nPlease try the verification process again.", error)
+                            &format!("Error confirming keys: {}\n\nPlease retry the verification process.", error)
                         );
                         accept_button.set_text("Ok");
                         accept_button.set_enabled(true);

From 79490dc64355b604e585cade38b66ddacba27e74 Mon Sep 17 00:00:00 2001
From: Kevin Boos <1139460+kevinaboos@users.noreply.github.com>
Date: Mon, 7 Oct 2024 00:51:21 -0700
Subject: [PATCH 4/4] Update README with latest completed features

---
 README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 86d6c76d..a30550b3 100644
--- a/README.md
+++ b/README.md
@@ -108,7 +108,7 @@ These are generally sorted in order of priority. If you're interested in helping
 - [x] Reply button, send reply: https://github.com/project-robius/robrix/issues/83
 - [ ] Error display banners: no connection, failure to login, sync timeout: https://github.com/project-robius/robrix/issues/121
 - [ ] Collapsible/expandable view of contiguous "small" events: https://github.com/project-robius/robrix/issues/118
-- [ ] E2EE device verification, decrypt message content: https://github.com/project-robius/robrix/issues/116
+- [x] E2EE device verification, decrypt message content: https://github.com/project-robius/robrix/issues/116
 
 ### Auxiliary/admin features: login, registration, settings
 - [ ] Username/password login screen: https://github.com/project-robius/robrix/issues/113
@@ -124,7 +124,8 @@ These are generally sorted in order of priority. If you're interested in helping
 - [x] Side panel showing detailed user profile info (click on their Avatar)
 - [x] Ignore and unignore users (see known issues)
 - [ ] User settings screen
-- [ ] Persistence of app state to disk: https://github.com/project-robius/robrix/issues/112
+- [x] Persistence of app session to disk: https://github.com/project-robius/robrix/issues/112
+- [ ] Save/restore events in rooms to/from the event cache upon app shutdown/start: https://github.com/project-robius/robrix/issues/164
 
 
 ## Known problems/issues