matrix-js-sdk 43.0.0 → 44.0.0

package/src/matrixrtc/RTCEncryptionManager.ts

@@ -19,13 +19,14 @@ import {
     getEncryptionKeyMapKey,
     type IEncryptionManager,
 } from "./EncryptionManager.ts";
-import { type EncryptionConfig, type MembershipConfig } from "./MatrixRTCSession.ts";
+import { type EncryptionConfig } from "./MatrixRTCSession.ts";
 import type { CallMembership } from "./CallMembership.ts";
 import { decodeBase64, encodeBase64 } from "../base64.ts";
 import { type IKeyTransport, type KeyTransportEventListener, KeyTransportEvents } from "./IKeyTransport.ts";
 import { type Logger } from "../logger.ts";
 import { sleep } from "../utils.ts";
 import {
+    type Transport,
     type EncryptionKeyMapKey,
     type InboundEncryptionSession,
     type OutboundEncryptionSession,
@@ -33,6 +34,7 @@ import {
 } from "./types.ts";
 import { OutdatedKeyFilter } from "./utils.ts";
 import { computeRtcIdentityRaw } from "./membershipData/rtc.ts";
+import { isUnstableLivekitTransport } from "./LivekitTransport.ts";
 
 /**
  * Default for {@link EncryptionConfig.keyRotationParticipantLimit}.
@@ -61,8 +63,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
     // This will be done when removing the legacy EncryptionManager.
     private manageMediaKeys = false;
 
-    private useHashedRtcBackendIdentity = false;
-    private ownRtcBackendIdentityCache: string | undefined;
+    private publishedTransports: Transport[] = [];
 
     /**
      * Store the key rings for each participant.
@@ -75,7 +76,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
             key: Uint8Array<ArrayBuffer>;
             keyIndex: number;
             membership: CallMembershipIdentityParts;
-            rtcBackendIdentity: string;
+            backendIdentity: string;
         }>
     >();
 
@@ -130,7 +131,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
 
     private logger: Logger | undefined = undefined;
 
-    private readonly rtcIdentityProvider: (userId: string, deviceId: string, memberId: string) => Promise<string>;
+    private readonly rtcIdentityProvider: (userId: string, memberId: string) => Promise<string>;
 
     /**
      *
@@ -151,10 +152,10 @@ export class RTCEncryptionManager implements IEncryptionManager {
             keyBin: Uint8Array<ArrayBuffer>,
             encryptionKeyIndex: number,
             membership: CallMembershipIdentityParts,
-            rtcBackendIdentity: string,
+            backendIdentity: string,
         ) => void,
         parentLogger?: Logger,
-        rtcBackendIdProvider?: (userId: string, deviceId: string, memberId: string) => Promise<string>,
+        rtcBackendIdProvider?: (userId: string, memberId: string) => Promise<string>,
     ) {
         this.logger = parentLogger?.getChild(`[EncryptionManager]`);
         this.rtcIdentityProvider = rtcBackendIdProvider ?? computeRtcIdentityRaw;
@@ -175,20 +176,25 @@ export class RTCEncryptionManager implements IEncryptionManager {
         return this.getMemberships().length >= this.keyRotationParticipantLimit;
     }
 
-    private async getOwnRtcBackendIdentity(): Promise<string> {
-        if (this.ownRtcBackendIdentityCache) return this.ownRtcBackendIdentityCache;
+    private ownBackendIdentitiesPromise: Promise<string[]> | undefined;
 
-        if (this.useHashedRtcBackendIdentity) {
+    private getOwnBackendIdentities(): Promise<string[]> {
+        this.ownBackendIdentitiesPromise ??= (async (): Promise<string[]> => {
             const { userId, deviceId, memberId } = this.ownMembership;
-            this.logger?.info(
-                // If we see this log multiple times, we need to reconsider the precompute call of getOwnRtcBackendIdentity
-                `Computing RTC backend identity for ${userId}:${deviceId}:${memberId} (SHOULD ONLY BE CALLED ONCE)`,
-            );
-            this.ownRtcBackendIdentityCache = await this.rtcIdentityProvider(userId, deviceId, memberId);
-        } else {
-            this.ownRtcBackendIdentityCache = `${this.ownMembership.userId}:${this.ownMembership.deviceId}`;
-        }
-        return this.ownRtcBackendIdentityCache;
+            const livekitTransports = this.publishedTransports.filter(isUnstableLivekitTransport);
+            const backendIdentities: string[] = [];
+
+            if (livekitTransports.some((t) => "url" in t)) {
+                this.logger?.info(`Computing RTC backend identity for ${userId}:${deviceId}:${memberId}`);
+                backendIdentities.push(await this.rtcIdentityProvider(userId, memberId));
+            }
+            if (livekitTransports.some((t) => "livekit_service_url" in t)) {
+                backendIdentities.push(`${userId}:${deviceId}`);
+            }
+
+            return backendIdentities;
+        })();
+        return this.ownBackendIdentitiesPromise;
     }
 
     public getEncryptionKeys(): ReadonlyMap<
@@ -197,7 +203,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
             key: Uint8Array<ArrayBuffer>;
             keyIndex: number;
             membership: CallMembershipIdentityParts;
-            rtcBackendIdentity: string;
+            backendIdentity: string;
         }>
     > {
         return new Map(this.participantKeyRings);
@@ -233,33 +239,36 @@ export class RTCEncryptionManager implements IEncryptionManager {
             this.keysWithoutMatchingRTCMembership.push({ key, keyIndex, membership });
             return;
         }
-        this.addKeyToParticipantWithBackendIdentity(key, keyIndex, membership, fullMembership.rtcBackendIdentity);
+        for (const backendIdentity of fullMembership.backendIdentities) {
+            this.addKeyToParticipantWithBackendIdentity(key, keyIndex, membership, backendIdentity);
+        }
     }
 
     private addKeyToParticipantWithBackendIdentity(
         key: Uint8Array<ArrayBuffer>,
         keyIndex: number,
         membership: CallMembershipIdentityParts,
-        rtcBackendIdentity: string,
+        backendIdentity: string,
     ): void {
         const mapKey = getEncryptionKeyMapKey(membership);
         if (!this.participantKeyRings.has(mapKey)) {
             this.participantKeyRings.set(mapKey, []);
         }
-        this.participantKeyRings.get(mapKey)!.push({ key, keyIndex, membership, rtcBackendIdentity });
-        this.onEncryptionKeysChanged(key, keyIndex, membership, rtcBackendIdentity);
+        this.participantKeyRings.get(mapKey)!.push({ key, keyIndex, membership, backendIdentity });
+        this.onEncryptionKeysChanged(key, keyIndex, membership, backendIdentity);
     }
 
-    public join(joinConfig: (EncryptionConfig & MembershipConfig) | undefined): void {
+    public join(joinConfig: EncryptionConfig | undefined, publishedTransports: Transport[]): void {
         this.manageMediaKeys = joinConfig?.manageMediaKeys ?? true; // default to true
-        this.useHashedRtcBackendIdentity = joinConfig?.unstableSendStickyEvents ?? false;
+        this.publishedTransports = publishedTransports;
+        this.ownBackendIdentitiesPromise = undefined;
         this.useKeyDelay = joinConfig?.useKeyDelay ?? 1000;
         this.keyRotationGracePeriodMs = joinConfig?.keyRotationGracePeriodMs ?? 10_000;
         this.keyRotationParticipantLimit =
             joinConfig?.keyRotationParticipantLimit ?? DEFAULT_KEY_ROTATION_PARTICIPANT_LIMIT;
 
         this.transport.on(KeyTransportEvents.ReceivedKeys, this.onNewKeyReceived);
-        void this.getOwnRtcBackendIdentity(); // precompute own identity
+        void this.getOwnBackendIdentities(); // precompute own identity
 
         this.logger?.info(`Joining room`);
         this.transport.start();
@@ -364,12 +373,14 @@ export class RTCEncryptionManager implements IEncryptionManager {
                 keyId: 0,
             };
             this.outboundSession = firstKey;
-            this.addKeyToParticipantWithBackendIdentity(
-                firstKey.key,
-                firstKey.keyId,
-                this.ownMembership,
-                await this.getOwnRtcBackendIdentity(),
-            );
+            const ids = await this.getOwnBackendIdentities();
+            for (const backendIdentity of ids)
+                this.addKeyToParticipantWithBackendIdentity(
+                    firstKey.key,
+                    firstKey.keyId,
+                    this.ownMembership,
+                    backendIdentity,
+                );
         }
         // get current memberships
         const toShareWith: ParticipantDeviceInfo[] = this.getMemberships()
@@ -467,12 +478,13 @@ export class RTCEncryptionManager implements IEncryptionManager {
                 this.logger?.trace(`Delay Rollout for key:${newOutboundEncryptionSession.keyId}...`);
                 await sleep(this.useKeyDelay);
                 this.logger?.trace(`...Delayed rollout of index:${newOutboundEncryptionSession.keyId} `);
-                this.addKeyToParticipantWithBackendIdentity(
-                    newOutboundEncryptionSession.key,
-                    newOutboundEncryptionSession.keyId,
-                    this.ownMembership,
-                    await this.getOwnRtcBackendIdentity(),
-                );
+                for (const backendIdentity of await this.getOwnBackendIdentities())
+                    this.addKeyToParticipantWithBackendIdentity(
+                        newOutboundEncryptionSession.key,
+                        newOutboundEncryptionSession.keyId,
+                        this.ownMembership,
+                        backendIdentity,
+                    );
             }
         } catch (err) {
             this.logger?.error(`Failed to rollout key`, err);

package/src/matrixrtc/ToDeviceKeyTransport.ts

@@ -152,13 +152,13 @@ export class ToDeviceKeyTransport
             return;
         }
 
-        // TODO: Not possible to check if the event is encrypted or not
-        // see https://github.com/matrix-org/matrix-rust-sdk/issues/4883
-        // if (evnt.getWireType() != EventType.RoomMessageEncrypted) {
-        //     // WARN: The call keys were sent in clear. Ignore them
-        //     logger.warn(`Call encryption keys sent in clear from: ${event.getSender()}`);
-        //     return;
-        // }
+        // NB: When received via the widget driver, the to-device events
+        // are properly reconstructed as if they are encrypted (see MatrixEvent#makeEncrypted).
+        if (event.getWireType() != EventType.RoomMessageEncrypted) {
+            // WARN: The call keys were sent in clear. Ignore them
+            this.logger.warn(`Call encryption keys sent in clear from: ${event.getSender()}`);
+            return;
+        }
 
         const content = this.getValidEventContent(event);
         if (!content) return;

package/src/matrixrtc/membershipData/rtc.ts

@@ -16,7 +16,6 @@ limitations under the License.
 
 import { MXID_PATTERN } from "../../models/room-member.ts";
 import type { IContent } from "../../models/event.ts";
-import type { RelationType } from "../../types.ts";
 import { type RtcSlotApplicationContent, type Transport } from "../types.ts";
 import { MatrixRTCMembershipParseError } from "./common.ts";
 import { sha256 } from "../../digest.ts";
@@ -27,24 +26,20 @@ import { slotIdToDescription } from "../utils.ts";
  * Represents the current form of MSC4143, which uses sticky events to store membership.
  */
 export interface RtcMembershipData {
-    "slot_id": string;
-    "member": {
+    slot_id: string;
+    member: {
         user_id: string;
         device_id: string;
         id: string;
     };
-    "m.relates_to"?: {
-        event_id: string;
-        rel_type: RelationType.Reference;
-    };
-    "application": RtcSlotApplicationContent;
-    "transports": {
+    application: RtcSlotApplicationContent;
+    transports: {
         published: Transport[];
         can_subscribe: string[];
     };
-    "versions": string[];
-    "msc4354_sticky_key"?: string;
-    "sticky_key"?: string;
+    versions: string[];
+    msc4354_sticky_key?: string;
+    sticky_key?: string;
 }
 
 /**
@@ -142,15 +137,6 @@ export const checkRtcMembershipData = (data: IContent, sender: string): data is
     ) {
         errors.push(prefix + "sticky_key and msc4354_sticky_key must be equal if both are defined");
     }
-    if (data["m.relates_to"] !== undefined) {
-        const rel = data["m.relates_to"] as RtcMembershipData["m.relates_to"];
-        if (typeof rel !== "object" || rel === null) {
-            errors.push(prefix + "m.relates_to must be an object if provided");
-        } else {
-            if (typeof rel.event_id !== "string") errors.push(prefix + "m.relates_to.event_id must be a string");
-            if (rel.rel_type !== "m.reference") errors.push(prefix + "m.relates_to.rel_type must be m.reference");
-        }
-    }
 
     if (errors.length) {
         throw new MatrixRTCMembershipParseError("RtcMembership", errors);
@@ -159,9 +145,9 @@ export const checkRtcMembershipData = (data: IContent, sender: string): data is
     return true;
 };
 
-export async function computeRtcIdentityRaw(userId: string, deviceId: string, memberId: string): Promise<string> {
+export async function computeRtcIdentityRaw(userId: string, memberId: string): Promise<string> {
     // canonical JSON serialization (Matrix canonical JSON for arrays)
-    const jsonStr = JSON.stringify([userId, deviceId, memberId]);
+    const jsonStr = JSON.stringify([userId, memberId]);
     const hashBuffer = await sha256(jsonStr);
     const hashedString = encodeUnpaddedBase64(hashBuffer);
     return hashedString;

package/src/matrixrtc/membershipData/session.ts

@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 import { type IContent } from "../../matrix.ts";
-import { type RTCCallIntent, type Transport } from "../types.ts";
+import { type RTCCallCapability, type RTCCallIntent, type Transport } from "../types.ts";
 import { MatrixRTCMembershipParseError } from "./common.ts";
 
 /**
@@ -48,7 +48,7 @@ export type SessionMembershipData = {
      */
     "focus_active": {
         type: "livekit" | string;
-        focus_selection: "oldest_membership" | "multi_sfu" | string;
+        focus_selection: "multi_sfu" | string;
     };
 
     /**
@@ -87,6 +87,11 @@ export type SessionMembershipData = {
      */
     "m.call.intent"?: RTCCallIntent;
 
+    /**
+     * The kinds of media this member's device is capable of handling, e.g. audio and/or video.
+     */
+    "capabilities"?: RTCCallCapability[];
+
     /**
      * The id used on the media backend.
      * (With livekit this is the participant identity on the LK SFU)
@@ -138,6 +143,13 @@ export const checkSessionsMembershipData = (data: IContent): data is SessionMemb
         errors.push(prefix + "m.call.intent must be a string");
     }
 
+    if (
+        data.capabilities !== undefined &&
+        !(Array.isArray(data.capabilities) && data.capabilities.every((c: unknown) => typeof c === "string"))
+    ) {
+        errors.push(prefix + "capabilities must be an array of strings");
+    }
+
     if (errors.length) {
         throw new MatrixRTCMembershipParseError("SessionMembership", errors);
     }

package/src/matrixrtc/types.ts

@@ -111,6 +111,12 @@ export type RTCNotificationType = "ring" | "notification";
  */
 export type RTCCallIntent = "audio" | "video" | string;
 
+/**
+ * Represents one kind of media a member's device is capable of handling.
+ * May be any string, although `"m.render_audio"` and `"m.render_video"` are commonly accepted values.
+ */
+export type RTCCallCapability = "m.render_audio" | "m.render_video" | string;
+
 /**
  * The maximum `lifetime` of an RTC notification as per MSC4075. Larger values are capped to this.
  *

package/src/models/event-timeline-set.ts

@@ -63,6 +63,12 @@ export interface IAddEventToTimelineOptions extends Pick<
 > {
     /** Whether the sync response came from cache */
     fromCache?: boolean;
+    /**
+     * The other events being added in the same batch. A relation whose parent is in the batch but not yet
+     * in a timeline (back-pagination adds newest first) is placed as its parent will be, rather than dropped
+     * as a relation to an unknown event.
+     */
+    batch?: MatrixEvent[];
 }
 
 export interface IAddLiveEventOptions extends Pick<
@@ -501,6 +507,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
                 this.addEventToTimeline(event, timeline, {
                     toStartOfTimeline,
                     addToState,
+                    batch: events,
                 });
                 lastEventWasNew = true;
                 didUpdate = true;
@@ -656,7 +663,14 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     public addEventToTimeline(
         event: MatrixEvent,
         timeline: EventTimeline,
-        { toStartOfTimeline, fromCache = false, roomState, timelineWasEmpty, addToState }: IAddEventToTimelineOptions,
+        {
+            toStartOfTimeline,
+            fromCache = false,
+            roomState,
+            timelineWasEmpty,
+            addToState,
+            batch,
+        }: IAddEventToTimelineOptions,
     ): void {
         if (timeline.getTimelineSet() !== this) {
             throw new Error(`EventTimelineSet.addEventToTimeline: Timeline=${timeline.toString()} does not belong " +
@@ -672,7 +686,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         //
         // We can only run this check for timelines with a `room` because `canContain`
         // requires it
-        if (this.room && !this.canContain(event)) {
+        if (this.room && !this.canContain(event, batch)) {
             let eventDebugString = `event=${eventId}`;
             if (event.threadRootId) {
                 eventDebugString += `(belongs to thread=${event.threadRootId})`;
@@ -932,10 +946,11 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * Requires the `room` property to have been set at EventTimelineSet construction time.
      *
      * @param event - the event to check whether it belongs to this timeline set.
+     * @param batch - other events being added alongside, in which the event's parent may be found
      * @throws Error if `room` was not set when constructing this timeline set.
      * @returns whether the event belongs to this timeline set.
      */
-    public canContain(event: MatrixEvent): boolean {
+    public canContain(event: MatrixEvent, batch?: MatrixEvent[]): boolean {
         if (!this.room) {
             throw new Error(
                 "Cannot call `EventTimelineSet::canContain without a `room` set. " +
@@ -943,7 +958,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             );
         }
 
-        const { threadId, shouldLiveInRoom, shouldLiveInThread } = this.room.eventShouldLiveIn(event);
+        const { threadId, shouldLiveInRoom, shouldLiveInThread } = this.room.eventShouldLiveIn(event, batch);
 
         if (this.thread) {
             return this.thread.id === threadId;

package/src/models/room-sticky-events.ts

@@ -40,7 +40,7 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
      * Sticky event map is a nested map of:
      *  eventType -> `content.sticky_key sender` -> StickyMatrixEvent[]
      *
-     * The events are ordered in latest to earliest expiry, so that the first event
+     * The events are ordered descendingly by expiry, tie breaking on the event ID, so that the first event
      * in the array will always be the "current" one.
      */
     private readonly stickyEventsMap = new Map<string, Map<string, StickyMatrixEvent[]>>();
@@ -54,25 +54,41 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
     private nextStickyEventExpiryTs: number = Number.MAX_SAFE_INTEGER;
 
     /**
-     * Sort two sticky events by order of expiry. This assumes the sticky events have the same
+     * Sort two sticky events by expiry, tie breaking on the event ID. This assumes the sticky events have the same
      * `type`, `sticky_key` and `sender`.
      * @returns A positive value if event A will expire sooner, or a negative value if event B will expire sooner.
      */
     private static sortStickyEvent(eventA: StickyMatrixEvent, eventB: StickyMatrixEvent): number {
-        // Sticky events with the same key have to use the same expiration duration.
-        // Hence, comparing via `origin_server_ts` yields the exact same result as comparing their expiration time.
-        if (eventB.getTs() !== eventA.getTs()) {
-            return eventB.getTs() - eventA.getTs();
+        // First, compare by expiry (`origin_server_ts + sticky.duration_ms`).
+        const expiryA = eventA.getTs() + eventA.unstableStickyInfo!.duration_ms;
+        const expiryB = eventB.getTs() + eventB.unstableStickyInfo!.duration_ms;
+        if (expiryB !== expiryA) {
+            return expiryB - expiryA;
         }
 
-        if ((eventB.getId() ?? "") > (eventA.getId() ?? "")) {
+        // Tie break on the highest lexicographical event ID.
+        const idA = eventA.getId() ?? "";
+        const idB = eventB.getId() ?? "";
+        if (idB > idA) {
             return 1;
+        } else if (idB < idA) {
+            return -1;
         }
 
         // This should fail as we've got corruption in our sticky array.
         throw Error("Comparing two sticky events with the same event ID is not allowed.");
     }
 
+    /**
+     * Check whether a sticky event has expired.
+     * @param event The sticky event to check.
+     * @param now The current time in milliseconds since the epoch.
+     * @returns True if the event has expired, false otherwise.
+     */
+    private static isExpired(event: StickyMatrixEvent, now: number): boolean {
+        return event.unstableStickyExpiresAt <= now;
+    }
+
     /**
      * Generate the correct key for an event to be found in the inner maps of `stickyEventsMap`.
      * @param stickyKey The sticky key of an event.
@@ -133,7 +149,7 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
     private addStickyEvent(event: MatrixEvent): { added: true; prevEvent?: StickyMatrixEvent } | { added: false } {
         // The map is keyed on the event's type and sticky key, both of which are encrypted. Wait for the
         // event to be decrypted, otherwise it would be filed under `m.room.encrypted` with no sticky key.
-        if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {
+        if (event.isBeingDecrypted() || event.shouldAttemptDecryption() || event.isDecryptionFailure()) {
             this.addStickyEventOnceDecrypted(event);
             return { added: false };
         }
@@ -147,10 +163,12 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
         if (event.unstableStickyExpiresAt === undefined) {
             throw new Error(`${event.getId()} is missing msc4354_sticky.duration_ms`);
         }
+        const stickyEvent = event as StickyMatrixEvent;
+
         const sender = event.getSender();
         const type = event.getType();
         assertIsUserId(sender);
-        if (event.unstableStickyExpiresAt <= Date.now()) {
+        if (RoomStickyEventsStore.isExpired(stickyEvent, Date.now())) {
             logger.info("ignored sticky event with older expiration time than current time", stickyKey);
             return { added: false };
         }
@@ -161,8 +179,6 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
             throw new Error("Expected sender to start with @");
         }
 
-        const stickyEvent = event as StickyMatrixEvent;
-
         if (stickyKey === undefined) {
             this.unkeyedStickyEvents.add(stickyEvent);
             // Recalculate the next expiry time.
@@ -269,7 +285,7 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
         for (const [eventType, innerEvents] of this.stickyEventsMap.entries()) {
             for (const [innerMapKey, [currentEvent, ...previousEvents]] of innerEvents) {
                 // we only added items with `sticky` into this map so we can assert non-null here
-                if (now >= currentEvent.unstableStickyExpiresAt) {
+                if (RoomStickyEventsStore.isExpired(currentEvent, now)) {
                     logger.debug("Expiring sticky event", currentEvent.getId());
                     removedEvents.push(currentEvent);
                     this.stickyEventsMap.get(eventType)!.delete(innerMapKey);
@@ -279,7 +295,7 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
                         .get(eventType)!
                         .set(innerMapKey, [
                             currentEvent,
-                            ...previousEvents.filter((e) => e.unstableStickyExpiresAt <= now),
+                            ...previousEvents.filter((e) => !RoomStickyEventsStore.isExpired(e, now)),
                         ]);
                     // If not removing the event, check to see if it's the next lowest expiry.
                     this.nextStickyEventExpiryTs = Math.min(
@@ -294,7 +310,7 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
             }
         }
         for (const event of this.unkeyedStickyEvents) {
-            if (now >= event.unstableStickyExpiresAt) {
+            if (RoomStickyEventsStore.isExpired(event, now)) {
                 logger.debug("Expiring sticky event", event.getId());
                 this.unkeyedStickyEvents.delete(event);
                 removedEvents.push(event);
@@ -328,6 +344,9 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
 
         // Handle unkeyedStickyEvents first since it's *quick*.
         const redactEventId = typeof redactedEvent === "string" ? redactedEvent : redactedEvent.getId();
+        if (!redactEventId) {
+            return;
+        }
         for (const event of this.unkeyedStickyEvents) {
             if (event.getId() === redactEventId) {
                 this.unkeyedStickyEvents.delete(event);
@@ -339,60 +358,75 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
         // Faster method of finding the event since we have the event cached.
         if (typeof redactedEvent !== "string" && !redactedEvent.isRedacted()) {
             const stickyKey = redactedEvent.getContent().msc4354_sticky_key;
-            if (typeof stickyKey !== "string" && stickyKey !== undefined) {
+            if (typeof stickyKey !== "string") {
                 return; // Not a sticky event.
             }
-            const eventType = redactedEvent.getType();
             const sender = redactedEvent.getSender();
             assertIsUserId(sender);
-            const innerMap = this.stickyEventsMap.get(eventType);
-            if (!innerMap) {
-                return;
-            }
-            const mapKey = RoomStickyEventsStore.stickyMapKey(stickyKey, sender);
-            const [currentEvent, ...previousEvents] = innerMap.get(mapKey) ?? [];
-            if (!currentEvent) {
-                // No event current in the map so ignore.
-                return;
-            }
-            logger.debug(`Redaction for ${redactEventId} under sticky key ${stickyKey}`);
-            // Revert to previous state, taking care to skip any other redacted events.
-            const newEvents = previousEvents.filter((e) => !e.isRedacted()).sort(RoomStickyEventsStore.sortStickyEvent);
-            this.stickyEventsMap.get(eventType)?.set(mapKey, newEvents);
-            if (newEvents.length) {
-                this.emit(
-                    RoomStickyEventsEvent.Update,
-                    [],
-                    [
-                        {
-                            // This looks confusing. This emits that the newer event
-                            // has been redacted and the previous event has taken it's place.
-                            previous: currentEvent,
-                            current: newEvents[0],
-                        },
-                    ],
-                    [],
-                );
-            } else {
-                // We did not find a previous event, so just expire.
-                innerMap.delete(mapKey);
-                if (innerMap.size === 0) {
-                    this.stickyEventsMap.delete(eventType);
-                }
-                this.emit(RoomStickyEventsEvent.Update, [], [], [currentEvent]);
-            }
+            this.removeKeyedStickyEvent(
+                redactedEvent.getType(),
+                RoomStickyEventsStore.stickyMapKey(stickyKey, sender),
+                redactEventId,
+            );
             return;
         }
 
         // We only know the event ID of the redacted event, so we need to
         // traverse the map to find our event.
-        for (const innerMap of this.stickyEventsMap.values()) {
-            for (const [currentEvent] of innerMap.values()) {
-                if (currentEvent.getId() !== redactEventId) {
-                    continue;
+        for (const [eventType, innerMap] of this.stickyEventsMap) {
+            for (const [mapKey, events] of innerMap) {
+                if (events.some((e) => e.getId() === redactEventId)) {
+                    // Found the event.
+                    this.removeKeyedStickyEvent(eventType, mapKey, redactEventId);
+                    return;
                 }
-                // Found the event.
-                return this.handleRedaction(currentEvent);
+            }
+        }
+    }
+
+    /**
+     * Remove a redacted event from an entry of the keyed sticky map, emitting
+     * `RoomEvent.StickyEvents` if this changes the "current" event of that entry.
+     * @param eventType The event `type` of the redacted event.
+     * @param mapKey The inner map key of the redacted event, see {@link stickyMapKey}.
+     * @param redactEventId The ID of the redacted event.
+     */
+    private removeKeyedStickyEvent(eventType: string, mapKey: string, redactEventId: string): void {
+        const innerMap = this.stickyEventsMap.get(eventType);
+        const events = innerMap?.get(mapKey);
+        if (!innerMap || !events) {
+            return;
+        }
+        const index = events.findIndex((e) => e.getId() === redactEventId);
+        if (index === -1) {
+            // The event is not in the map so ignore.
+            return;
+        }
+        logger.debug(`Redaction for ${redactEventId} under sticky map key ${mapKey}`);
+
+        // The current event always sits at index 0.
+        const currentEvent = events[0];
+        const currentEventRedacted = index === 0;
+
+        // Drop the redacted event and any other events that may have already been redacted before.
+        const newEvents = events.filter((e) => e.getId() !== redactEventId && !e.isRedacted());
+        if (newEvents.length) {
+            innerMap.set(mapKey, newEvents);
+        } else {
+            innerMap.delete(mapKey);
+            if (innerMap.size === 0) {
+                this.stickyEventsMap.delete(eventType);
+            }
+        }
+
+        // Emit an update if the current event was redacted.
+        if (currentEventRedacted) {
+            if (newEvents.length) {
+                // The current event was redacted and most recent superseded event takes its place.
+                this.emit(RoomStickyEventsEvent.Update, [], [{ previous: currentEvent, current: newEvents[0] }], []);
+            } else {
+                // The current event was redacted and no superseded events remain to replace it.
+                this.emit(RoomStickyEventsEvent.Update, [], [], [currentEvent]);
             }
         }
     }