matrix-rust-sdk

public

Star0

Fork 0

Watch0

4 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `00eb9bff2d7b`

tarball

atagen <boss@atagen.co>2026-10-22 12:30 UTC

14 files changed+284-33

timeline: carry the msc4027 shortcode on reactions

Modified file: crates/matrix-sdk-base/src/store/integration_tests.rs+2 additions−2 deletions@@ -1794,7 +1794,7 @@ impl StateStoreIntegrationTests for DynStateStore {
         self.update_dependent_queued_request(
             room_id,
             &child_txn,
-            DependentQueuedRequestKind::ReactEvent { key: "👍".to_owned() },
+            DependentQueuedRequestKind::ReactEvent { key: "👍".to_owned(), shortcode: None },
         )
         .await?;
 
@@ -1806,7 +1806,7 @@ impl StateStoreIntegrationTests for DynStateStore {
         assert!(dependents[0].parent_key.is_none());
         assert_matches!(
             &dependents[0].kind,
-            DependentQueuedRequestKind::ReactEvent { key } => {
+            DependentQueuedRequestKind::ReactEvent { key, .. } => {
                 assert_eq!(key, "👍");
             }
         );

Modified file: crates/matrix-sdk-base/src/store/send_queue.rs+6 additions@@ -237,6 +237,12 @@ pub enum DependentQueuedRequestKind {
     ReactEvent {
         /// Key used for the reaction.
         key: String,
+
+        /// Shortcode of the custom emote used as the key, as per [MSC4027].
+        ///
+        /// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        shortcode: Option<String>,
     },
 
     /// Upload a file or thumbnail depending on another file or thumbnail

Modified file: crates/matrix-sdk-ui/src/timeline/controller/aggregations.rs+11 additions−2 deletions@@ -116,6 +116,11 @@ pub(crate) enum AggregationKind {
     Reaction {
         /// The reaction "key" displayed by the client, often an emoji.
         key: String,
+        /// The shortcode of the custom emote used as the key, as per
+        /// [MSC4027].
+        ///
+        /// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+        shortcode: Option<String>,
         /// Sender of the reaction.
         sender: OwnedUserId,
         /// Timestamp at which the reaction has been sent.
@@ -286,7 +291,7 @@ impl Aggregation {
                 Err(err) => ApplyAggregationResult::Error(err),
             },
 
-            AggregationKind::Reaction { key, sender, timestamp, reaction_status } => {
+            AggregationKind::Reaction { key, shortcode, sender, timestamp, reaction_status } => {
                 let Some(reactions) = event.content().reactions() else {
                     // An item that can't hold any reactions.
                     return ApplyAggregationResult::LeftItemIntact;
@@ -325,7 +330,11 @@ impl Aggregation {
 
                     reactions.entry(key.clone()).or_default().insert(
                         sender.clone(),
-                        ReactionInfo { timestamp: *timestamp, status: reaction_status.clone() },
+                        ReactionInfo {
+                            timestamp: *timestamp,
+                            status: reaction_status.clone(),
+                            shortcode: shortcode.clone(),
+                        },
                     );
 
                     ApplyAggregationResult::UpdatedItem

Modified file: crates/matrix-sdk-ui/src/timeline/controller/mod.rs+51 additions−10 deletions@@ -30,7 +30,8 @@ use matrix_sdk::{
         TimelineVectorDiffs,
     },
     send_queue::{
-        LocalEcho, LocalEchoContent, RoomSendQueueUpdate, SendHandle, SendReactionHandle,
+        LocalEcho, LocalEchoContent, RoomSendQueueStorageError, RoomSendQueueUpdate, SendHandle,
+        SendReactionHandle,
     },
     task_monitor::BackgroundTaskHandle,
 };
@@ -71,6 +72,7 @@ use super::{
     TimelineFocus, TimelineItem, TimelineItemContent, TimelineItemKind,
     TimelineReadReceiptTracking, VirtualTimelineItem,
     algorithms::{rfind_event_by_id, rfind_event_item},
+    event_handler::{REACTION_SHORTCODE_FIELD, reaction_shortcode},
     event_item::{ReactionStatus, RemoteEventOrigin},
     item::TimelineUniqueId,
     subscriber::TimelineSubscriber,
@@ -492,6 +494,7 @@ impl<P: RoomDataProvider> TimelineController<P> {
         &self,
         item_id: &TimelineEventItemId,
         key: &str,
+        shortcode: Option<&str>,
     ) -> Result<bool, Error> {
         let mut state = self.state.write().await;
 
@@ -511,7 +514,7 @@ impl<P: RoomDataProvider> TimelineController<P> {
             match item.handle() {
                 TimelineItemHandle::Local(send_handle) => {
                     if send_handle
-                        .react(key.to_owned())
+                        .react_with_shortcode(key.to_owned(), shortcode.map(ToOwned::to_owned))
                         .await
                         .map_err(|err| Error::SendQueueError(err.into()))?
                         .is_some()
@@ -530,9 +533,27 @@ impl<P: RoomDataProvider> TimelineController<P> {
                     // take care of it.
                     trace!("adding a reaction to a remote echo");
                     let annotation = Annotation::new(event_id.to_owned(), key.to_owned());
-                    self.room_data_provider
-                        .send(ReactionEventContent::from(annotation).into())
-                        .await?;
+                    let content = ReactionEventContent::from(annotation);
+                    if let Some(shortcode) = shortcode {
+                        let content = serde_json::to_value(&content)
+                            .and_then(|mut content| {
+                                content[REACTION_SHORTCODE_FIELD] = shortcode.into();
+                                Raw::new(&content)
+                            })
+                            .map_err(|err| {
+                                Error::SendQueueError(
+                                    RoomSendQueueStorageError::JsonSerialization(err).into(),
+                                )
+                            })?;
+                        self.room_data_provider
+                            .send_raw(
+                                content.cast_unchecked(),
+                                MessageLikeEventType::Reaction.to_string(),
+                            )
+                            .await?;
+                    } else {
+                        self.room_data_provider.send(content.into()).await?;
+                    }
                     return Ok(true);
                 }
             }
@@ -746,6 +767,7 @@ impl<P: RoomDataProvider> TimelineController<P> {
         &self,
         txn_id: OwnedTransactionId,
         content: AnyMessageLikeEventContent,
+        reaction_shortcode: Option<String>,
         send_handle: Option<SendHandle>,
     ) {
         let sender = self.room_data_provider.own_user_id().to_owned();
@@ -755,7 +777,15 @@ impl<P: RoomDataProvider> TimelineController<P> {
 
         let mut state = self.state.write().await;
         state
-            .handle_local_event(sender, profile, date_divider_mode, txn_id, send_handle, content)
+            .handle_local_event(
+                sender,
+                profile,
+                date_divider_mode,
+                txn_id,
+                send_handle,
+                content,
+                reaction_shortcode,
+            )
             .await;
     }
 
@@ -1130,8 +1160,17 @@ impl<P: RoomDataProvider> TimelineController<P> {
                     }
                 };
 
-                self.handle_local_event(echo.transaction_id.clone(), content, Some(send_handle))
-                    .await;
+                let shortcode = matches!(content, AnyMessageLikeEventContent::Reaction(_))
+                    .then(|| reaction_shortcode(serialized_event.raw().0))
+                    .flatten();
+
+                self.handle_local_event(
+                    echo.transaction_id.clone(),
+                    content,
+                    shortcode,
+                    Some(send_handle),
+                )
+                .await;
 
                 if let Some(send_error) = send_error {
                     self.update_event_send_state(
@@ -1147,8 +1186,8 @@ impl<P: RoomDataProvider> TimelineController<P> {
                 }
             }
 
-            LocalEchoContent::React { key, send_handle, applies_to } => {
-                self.handle_local_reaction(key, send_handle, applies_to).await;
+            LocalEchoContent::React { key, shortcode, send_handle, applies_to } => {
+                self.handle_local_reaction(key, shortcode, send_handle, applies_to).await;
             }
 
             LocalEchoContent::Redaction { redacts, send_error, .. } => {
@@ -1175,6 +1214,7 @@ impl<P: RoomDataProvider> TimelineController<P> {
     async fn handle_local_reaction(
         &self,
         reaction_key: String,
+        shortcode: Option<String>,
         send_handle: SendReactionHandle,
         applies_to: OwnedTransactionId,
     ) {
@@ -1189,6 +1229,7 @@ impl<P: RoomDataProvider> TimelineController<P> {
             TimelineEventItemId::TransactionId(reaction_txn_id),
             AggregationKind::Reaction {
                 key: reaction_key.clone(),
+                shortcode,
                 sender: self.room_data_provider.own_user_id().to_owned(),
                 timestamp: MilliSecondsSinceUnixEpoch::now(),
                 reaction_status,

Modified file: crates/matrix-sdk-ui/src/timeline/controller/state.rs+3 additions−1 deletions@@ -157,6 +157,7 @@ impl<P: RoomDataProvider> TimelineState<P> {
         txn_id: OwnedTransactionId,
         send_handle: Option<SendHandle>,
         content: AnyMessageLikeEventContent,
+        reaction_shortcode: Option<String>,
     ) {
         let mut txn = self.transaction();
 
@@ -194,7 +195,8 @@ impl<P: RoomDataProvider> TimelineState<P> {
             should_add_new_items,
         };
 
-        let timeline_action = TimelineAction::from_content(content, in_reply_to, thread_root, None);
+        let timeline_action = TimelineAction::from_content(content, in_reply_to, thread_root, None)
+            .with_reaction_shortcode(|| reaction_shortcode);
         TimelineEventHandler::new(&mut txn, ctx)
             .handle_event(&mut date_divider_adjuster, timeline_action, None)
             .await;

Modified file: crates/matrix-sdk-ui/src/timeline/event_handler.rs+50 additions−5 deletions@@ -65,6 +65,19 @@ use crate::{
     unable_to_decrypt_hook::UtdHookManager,
 };
 
+/// The field holding the shortcode of a custom emote reaction, as per
+/// [MSC4027], which ruma's `ReactionEventContent` has no field for.
+///
+/// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+pub(super) const REACTION_SHORTCODE_FIELD: &str = "com.beeper.reaction.shortcode";
+
+/// Reads the [MSC4027] shortcode from a reaction's raw content.
+///
+/// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+pub(super) fn reaction_shortcode(content: &Raw<AnyMessageLikeEventContent>) -> Option<String> {
+    content.get_field(REACTION_SHORTCODE_FIELD).ok().flatten()
+}
+
 /// When adding an event, useful information related to the source of the event.
 pub(super) enum Flow {
     /// The event was locally created.
@@ -140,7 +153,7 @@ pub(super) struct TimelineEventContext {
 #[derive(Clone, Debug)]
 pub(super) enum HandleAggregationKind {
     /// Adding a reaction to the related event.
-    Reaction { key: String },
+    Reaction { key: String, shortcode: Option<String> },
 
     /// Redacting (removing) the related event.
     Redaction,
@@ -221,6 +234,22 @@ impl TimelineAction {
         Self::AddItem { content }
     }
 
+    /// If this is a reaction, attach the shortcode computed by `shortcode`,
+    /// that [`TimelineAction::from_content`] can't see in typed content.
+    pub(super) fn with_reaction_shortcode(
+        mut self,
+        shortcode: impl FnOnce() -> Option<String>,
+    ) -> Self {
+        if let Self::HandleAggregation {
+            kind: HandleAggregationKind::Reaction { shortcode: slot, .. },
+            ..
+        } = &mut self
+        {
+            *slot = shortcode();
+        }
+        self
+    }
+
     /// Create a new [`TimelineAction`] from a given remote event.
     ///
     /// The return value may be `None` if the event was a redacted reaction.
@@ -298,6 +327,13 @@ impl TimelineAction {
 
                 Some(content) => {
                     Self::from_content(content, in_reply_to, thread_root, thread_summary)
+                        .with_reaction_shortcode(|| {
+                            raw_event
+                                .get_field::<Raw<AnyMessageLikeEventContent>>("content")
+                                .ok()
+                                .flatten()
+                                .and_then(|content| reaction_shortcode(&content))
+                        })
                 }
 
                 None => Self::add_item(redacted_message_or_none(ev.event_type())?),
@@ -382,7 +418,10 @@ impl TimelineAction {
                 // This is a reaction to a message.
                 Self::HandleAggregation {
                     related_event: c.relates_to.event_id.clone(),
-                    kind: HandleAggregationKind::Reaction { key: c.relates_to.key },
+                    kind: HandleAggregationKind::Reaction {
+                        key: c.relates_to.key,
+                        shortcode: None,
+                    },
                 }
             }
 
@@ -626,8 +665,8 @@ impl<'a, 'o> TimelineEventHandler<'a, 'o> {
             }
 
             TimelineAction::HandleAggregation { related_event, kind } => match kind {
-                HandleAggregationKind::Reaction { key } => {
-                    self.handle_reaction(related_event, key);
+                HandleAggregationKind::Reaction { key, shortcode } => {
+                    self.handle_reaction(related_event, key, shortcode);
                 }
                 HandleAggregationKind::Redaction => {
                     self.handle_redaction(related_event);
@@ -715,7 +754,12 @@ impl<'a, 'o> TimelineEventHandler<'a, 'o> {
     /// Reactions to local events are applied in
     /// [`crate::timeline::TimelineController::handle_local_echo`].
     #[instrument(skip(self))]
-    fn handle_reaction(&mut self, relates_to: OwnedEventId, reaction_key: String) {
+    fn handle_reaction(
+        &mut self,
+        relates_to: OwnedEventId,
+        reaction_key: String,
+        shortcode: Option<String>,
+    ) {
         let target = TimelineEventItemId::EventId(relates_to);
 
         // Add the aggregation to the manager.
@@ -734,6 +778,7 @@ impl<'a, 'o> TimelineEventHandler<'a, 'o> {
             self.ctx.flow.timeline_item_id(),
             AggregationKind::Reaction {
                 key: reaction_key,
+                shortcode,
                 sender: self.ctx.sender.clone(),
                 timestamp: self.ctx.timestamp,
                 reaction_status,

Modified file: crates/matrix-sdk-ui/src/timeline/event_item/mod.rs+4 additions@@ -799,6 +799,10 @@ pub struct ReactionInfo {
     pub timestamp: MilliSecondsSinceUnixEpoch,
     /// Current status of this reaction.
     pub status: ReactionStatus,
+    /// The shortcode of the custom emote used as the key, as per [MSC4027].
+    ///
+    /// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+    pub shortcode: Option<String>,
 }
 
 /// Reactions grouped by key first, then by sender.

Modified file: crates/matrix-sdk-ui/src/timeline/mod.rs+19 additions−1 deletions@@ -556,7 +556,25 @@ impl Timeline {
         item_id: &TimelineEventItemId,
         reaction_key: &str,
     ) -> Result<bool, Error> {
-        self.controller.toggle_reaction_local(item_id, reaction_key).await
+        self.toggle_reaction_with_shortcode(item_id, reaction_key, None).await
+    }
+
+    /// Toggle a reaction on an event, like [`Self::toggle_reaction`].
+    ///
+    /// For a custom emote reaction, `reaction_key` is the emote's MXC URI and
+    /// `shortcode` its shortcode, sent along as per [MSC4027]. The shortcode
+    /// is ignored when the reaction is removed.
+    ///
+    /// Returns `true` if the reaction was added, `false` if it was removed.
+    ///
+    /// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+    pub async fn toggle_reaction_with_shortcode(
+        &self,
+        item_id: &TimelineEventItemId,
+        reaction_key: &str,
+        shortcode: Option<&str>,
+    ) -> Result<bool, Error> {
+        self.controller.toggle_reaction_local(item_id, reaction_key, shortcode).await
     }
 
     /// Sends an attachment to the room.

Modified file: crates/matrix-sdk-ui/src/timeline/tests/mod.rs+14 additions−2 deletions@@ -169,7 +169,7 @@ impl TestTimeline {
 
     async fn handle_local_event(&self, content: AnyMessageLikeEventContent) -> OwnedTransactionId {
         let txn_id = TransactionId::new();
-        self.controller.handle_local_event(txn_id.clone(), content, None).await;
+        self.controller.handle_local_event(txn_id.clone(), content, None, None).await;
         txn_id
     }
 
@@ -206,7 +206,7 @@ impl TestTimeline {
         item_id: &TimelineEventItemId,
         key: &str,
     ) -> Result<(), super::Error> {
-        if self.controller.toggle_reaction_local(item_id, key).await? {
+        if self.controller.toggle_reaction_local(item_id, key, None).await? {
             let items = self.controller.items().await;
             if let Some(event_id) = rfind_event_by_item_id(&items, item_id)
                 .and_then(|(_pos, item)| item.event_id().map(ToOwned::to_owned))
@@ -255,6 +255,9 @@ struct TestRoomDataProvider {
     /// Events sent with that room data provider.
     pub sent_events: Arc<RwLock<Vec<AnyMessageLikeEventContent>>>,
 
+    /// Raw events sent with that room data provider.
+    pub sent_raw_events: Arc<RwLock<Vec<Raw<AnyMessageLikeEventContent>>>>,
+
     /// Events redacted with that room data providier.
     pub redacted: Arc<RwLock<Vec<OwnedEventId>>>,
 }
@@ -368,6 +371,15 @@ impl RoomDataProvider for TestRoomDataProvider {
         Ok(())
     }
 
+    async fn send_raw(
+        &self,
+        content: Raw<AnyMessageLikeEventContent>,
+        _event_type: String,
+    ) -> Result<(), super::Error> {
+        self.sent_raw_events.write().await.push(content);
+        Ok(())
+    }
+
     async fn redact<'a>(
         &'a self,
         event_id: &'a EventId,

Modified file: crates/matrix-sdk-ui/src/timeline/tests/reactions.rs+53 additions−2 deletions@@ -19,11 +19,13 @@ use eyeball_im::VectorDiff;
 use futures_core::Stream;
 use futures_util::{FutureExt as _, StreamExt as _};
 use imbl::vector;
-use matrix_sdk::assert_next_matches_with_timeout;
+use matrix_sdk::{assert_next_matches_with_timeout, deserialized_responses::TimelineEvent};
 use matrix_sdk_test::{ALICE, BOB, async_test};
 use ruma::{
     EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, event_id,
-    events::AnyMessageLikeEventContent, server_name, uint,
+    events::{AnyMessageLikeEventContent, reaction::ReactionEventContent},
+    serde::Raw,
+    server_name, uint,
 };
 use stream_assert::{assert_next_matches, assert_pending};
 use tokio::time::timeout;
@@ -125,6 +127,55 @@ async fn test_add_reaction_success() {
 }
 
 #[async_test]
+async fn test_add_reaction_with_shortcode_sends_it() {
+    let timeline = TestTimeline::new();
+    let mut stream = timeline.subscribe().await;
+    let (item_id, _, _) = send_first_message(&timeline, &mut stream).await;
+
+    timeline
+        .controller
+        .toggle_reaction_local(&item_id, "mxc://example.org/blobcat", Some("blobcat"))
+        .await
+        .unwrap();
+
+    assert!(timeline.data().sent_events.read().await.is_empty());
+    let sent_raw_events = &timeline.data().sent_raw_events.read().await;
+    assert_eq!(sent_raw_events.len(), 1);
+    let reaction = sent_raw_events[0].deserialize_as_unchecked::<ReactionEventContent>().unwrap();
+    assert_eq!(reaction.relates_to.key, "mxc://example.org/blobcat");
+    assert_eq!(
+        sent_raw_events[0].get_field::<String>("com.beeper.reaction.shortcode").unwrap().as_deref(),
+        Some("blobcat")
+    );
+}
+
+#[async_test]
+async fn test_remote_reaction_shortcode_is_surfaced() {
+    let timeline = TestTimeline::new();
+    let mut stream = timeline.subscribe().await;
+    let (_, event_id, item_pos) = send_first_message(&timeline, &mut stream).await;
+
+    let mut reaction = timeline
+        .factory
+        .reaction(&event_id, "mxc://example.org/blobcat")
+        .sender(*ALICE)
+        .into_raw_sync()
+        .deserialize_as_unchecked::<serde_json::Value>()
+        .unwrap();
+    reaction["content"]["com.beeper.reaction.shortcode"] = "blobcat".into();
+    timeline
+        .handle_live_event(TimelineEvent::from_plaintext(
+            Raw::new(&reaction).unwrap().cast_unchecked(),
+        ))
+        .await;
+
+    let event = assert_item_update!(stream, &event_id, item_pos);
+    let reactions = event.content().reactions().cloned().unwrap_or_default();
+    let reaction = reactions.get("mxc://example.org/blobcat").unwrap().get(*ALICE).unwrap();
+    assert_eq!(reaction.shortcode.as_deref(), Some("blobcat"));
+}
+
+#[async_test]
 async fn test_redact_reaction_success() {
     let timeline = TestTimeline::new();
     let f = &timeline.factory;

Modified file: crates/matrix-sdk-ui/src/timeline/traits.rs+17 additions@@ -30,6 +30,7 @@ use ruma::{
         receipt::{Receipt, ReceiptThread, ReceiptType},
     },
     room_version_rules::RoomVersionRules,
+    serde::Raw,
 };
 use tracing::error;
 
@@ -133,6 +134,13 @@ pub(super) trait RoomDataProvider:
         content: AnyMessageLikeEventContent,
     ) -> impl Future<Output = Result<(), super::Error>> + SendOutsideWasm + '_;
 
+    /// Send an event to that room, from its raw content.
+    fn send_raw(
+        &self,
+        content: Raw<AnyMessageLikeEventContent>,
+        event_type: String,
+    ) -> impl Future<Output = Result<(), super::Error>> + SendOutsideWasm + '_;
+
     /// Redact an event from that room.
     fn redact<'a>(
         &'a self,
@@ -223,6 +231,15 @@ impl RoomDataProvider for Room {
         Ok(())
     }
 
+    async fn send_raw(
+        &self,
+        content: Raw<AnyMessageLikeEventContent>,
+        event_type: String,
+    ) -> Result<(), super::Error> {
+        let _ = self.send_queue().send_raw(content, event_type).await?;
+        Ok(())
+    }
+
     async fn redact<'a>(
         &'a self,
         event_id: &'a EventId,

Modified file: crates/matrix-sdk/src/latest_events/latest_event/builder.rs+1

@@ -2855,6 +2855,7 @@ mod builder_tests {

28552855 let transaction_id = OwnedTransactionId::from("txnid1");

28562856 let content = LocalEchoContent::React {

28572857 key: "<< 1".to_owned(),

2858+ shortcode: None,

28582859 send_handle: SendReactionHandle::new(

28592860 room_send_queue.clone(),

28602861 ChildTransactionId::new(),

Modified file: crates/matrix-sdk/src/send_queue/mod.rs+52 additions−8 deletions@@ -1940,6 +1940,7 @@ impl QueueStorage {
         &self,
         transaction_id: &TransactionId,
         key: String,
+        shortcode: Option<String>,
         created_at: MilliSecondsSinceUnixEpoch,
     ) -> Result<Option<ChildTransactionId>, RoomSendQueueStorageError> {
         let guard = self.store.lock().await;
@@ -1971,7 +1972,7 @@ impl QueueStorage {
                 transaction_id,
                 reaction_txn_id.clone(),
                 created_at,
-                DependentQueuedRequestKind::ReactEvent { key },
+                DependentQueuedRequestKind::ReactEvent { key, shortcode },
             )
             .await?;
 
@@ -2036,10 +2037,11 @@ impl QueueStorage {
                     None
                 }
 
-                DependentQueuedRequestKind::ReactEvent { key } => Some(LocalEcho {
+                DependentQueuedRequestKind::ReactEvent { key, shortcode } => Some(LocalEcho {
                     transaction_id: dep.own_transaction_id.clone().into(),
                     content: LocalEchoContent::React {
                         key,
+                        shortcode,
                         send_handle: SendReactionHandle {
                             room: room.clone(),
                             transaction_id: dep.own_transaction_id,
@@ -2271,7 +2273,7 @@ impl QueueStorage {
                 }
             }
 
-            DependentQueuedRequestKind::ReactEvent { key } => {
+            DependentQueuedRequestKind::ReactEvent { key, shortcode } => {
                 if let Some(parent_key) = parent_key {
                     let Some(parent_event_id) = parent_key.into_event_id() else {
                         return Err(RoomSendQueueError::StorageError(
@@ -2282,9 +2284,14 @@ impl QueueStorage {
                     // Queue the reaction event in the send queue 🧠.
                     let react_event =
                         ReactionEventContent::new(Annotation::new(parent_event_id, key)).into();
+                    let mut raw = Raw::new(&react_event)
+                        .map_err(RoomSendQueueStorageError::JsonSerialization)?;
+                    if let Some(shortcode) = shortcode {
+                        raw = with_reaction_shortcode(raw, shortcode)
+                            .map_err(RoomSendQueueStorageError::JsonSerialization)?;
+                    }
                     let serializable = SerializableEventContent::from_raw(
-                        Raw::new(&react_event)
-                            .map_err(RoomSendQueueStorageError::JsonSerialization)?,
+                        raw,
                         react_event.event_type().to_string(),
                     );
 
@@ -2485,6 +2492,11 @@ pub enum LocalEchoContent {
     React {
         /// The key with which the local echo has been reacted to.
         key: String,
+        /// The shortcode of the custom emote used as the key, as per
+        /// [MSC4027].
+        ///
+        /// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+        shortcode: Option<String>,
         /// A handle to manipulate the sending of the reaction.
         send_handle: SendReactionHandle,
         /// The local echo which has been reacted to.
@@ -2903,11 +2915,28 @@ impl SendHandle {
         &self,
         key: String,
     ) -> Result<Option<SendReactionHandle>, RoomSendQueueStorageError> {
+        self.react_with_shortcode(key, None).await
+    }
+
+    /// Like [`Self::react`], for a custom emote reaction whose key is the
+    /// emote's MXC URI, carrying its shortcode as per [MSC4027].
+    ///
+    /// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+    #[instrument(skip(self), fields(room_id = %self.room.inner.room.room_id(), txn_id = %self.transaction_id))]
+    pub async fn react_with_shortcode(
+        &self,
+        key: String,
+        shortcode: Option<String>,
+    ) -> Result<Option<SendReactionHandle>, RoomSendQueueStorageError> {
         trace!("received an intent to react");
 
         let created_at = MilliSecondsSinceUnixEpoch::now();
-        if let Some(reaction_txn_id) =
-            self.room.inner.queue.react(&self.transaction_id, key.clone(), created_at).await?
+        if let Some(reaction_txn_id) = self
+            .room
+            .inner
+            .queue
+            .react(&self.transaction_id, key.clone(), shortcode.clone(), created_at)
+            .await?
         {
             trace!("successfully queued react");
 
@@ -2926,6 +2955,7 @@ impl SendHandle {
                 transaction_id: reaction_txn_id.into(),
                 content: LocalEchoContent::React {
                     key,
+                    shortcode,
                     send_handle: send_handle.clone(),
                     applies_to: self.transaction_id.clone(),
                 },
@@ -3086,6 +3116,20 @@ fn canonicalize_dependent_requests(
     by_txn.into_values().flat_map(|entries| entries.into_iter().cloned()).collect()
 }
 
+/// Adds the [MSC4027] shortcode of a custom emote to a reaction's content,
+/// which ruma's [`ReactionEventContent`] has no field for.
+///
+/// [MSC4027]: https://github.com/matrix-org/matrix-spec-proposals/pull/4027
+fn with_reaction_shortcode(
+    content: Raw<AnyMessageLikeEventContent>,
+    shortcode: String,
+) -> Result<Raw<AnyMessageLikeEventContent>, serde_json::Error> {
+    let mut content =
+        content.deserialize_as_unchecked::<serde_json::Map<String, serde_json::Value>>()?;
+    content.insert("com.beeper.reaction.shortcode".to_owned(), shortcode.into());
+    Ok(Raw::new(&content)?.cast_unchecked())
+}
+
 #[cfg(all(test, not(target_family = "wasm")))]
 mod tests {
     use std::{sync::Arc, time::Duration};
@@ -3344,7 +3388,7 @@ mod tests {
         let react_id = ChildTransactionId::new();
         let react = DependentQueuedRequest {
             own_transaction_id: react_id.clone(),
-            kind: DependentQueuedRequestKind::ReactEvent { key: "🧠".to_owned() },
+            kind: DependentQueuedRequestKind::ReactEvent { key: "🧠".to_owned(), shortcode: None },
             parent_transaction_id: txn.clone(),
             parent_key: None,
             created_at: MilliSecondsSinceUnixEpoch::now(),

Modified file: crates/matrix-sdk/tests/integration/send_queue.rs+1

@@ -232,6 +232,7 @@ macro_rules! assert_update {

232232 key,

233233 applies_to,

234234 send_handle: _,

235+ ..

235236 },

236237 transaction_id: txn,

237238 }))) = timeout(Duration::from_secs(1), $watch.recv()).await

matrix-rust-sdk

Commit 00eb9bff2d7b

Commit `00eb9bff2d7b`