matrix-js-sdk 41.7.0 → 41.8.0

package/src/client.ts

@@ -249,6 +249,7 @@ import {
 import { type EmptyObject } from "./@types/common.ts";
 import { UnsupportedDelayedEventsEndpointError, UnsupportedStickyEventsEndpointError } from "./errors.ts";
 import { type Transport } from "./matrixrtc/index.ts";
+import { RetentionPolicyService } from "./retentionPolicy.ts";
 
 export type Store = IStore;
 
@@ -462,6 +463,11 @@ export interface ICreateClientOpts {
      * Defaults to the built-in global logger; see {@link DebugLogger} for an alternative.
      */
     logger?: Logger;
+
+    /**
+     * Locally remove events past the server global or per room retention setting.
+     */
+    unstableMSC1763Retention?: boolean;
 }
 
 export interface IMatrixClientCreateOpts extends ICreateClientOpts {
@@ -1327,6 +1333,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public readonly matrixRTC: MatrixRTCSessionManager;
 
     private serverCapabilitiesService: ServerCapabilities;
+    public readonly retentionPolicyService: RetentionPolicyService;
+    // eslint-disable-next-line
+    public readonly _unstable_shouldApplyMessageRetention: boolean;
 
     public constructor(opts: IMatrixClientCreateOpts) {
         super();
@@ -1405,6 +1414,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         this.matrixRTC = new MatrixRTCSessionManager(this.logger, this);
 
         this.serverCapabilitiesService = new ServerCapabilities(this.logger, this.http);
+        this.retentionPolicyService = new RetentionPolicyService(this.logger, this.http);
+        this._unstable_shouldApplyMessageRetention = opts.unstableMSC1763Retention ?? false;
 
         this.on(ClientEvent.Sync, this.fixupRoomNotifications);
 
@@ -1530,6 +1541,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         this.toDeviceMessageQueue.start();
         this.serverCapabilitiesService.start();
+        if (this._unstable_shouldApplyMessageRetention) {
+            this.retentionPolicyService?.start();
+        }
     }
 
     /**
@@ -1936,9 +1950,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise resolving with The capabilities of the homeserver
      */
     public async getCapabilities(): Promise<Capabilities> {
-        const caps = this.serverCapabilitiesService.getCachedCapabilities();
+        const caps = this.serverCapabilitiesService.getCached();
         if (caps) return caps;
-        return this.serverCapabilitiesService.fetchCapabilities();
+        return this.serverCapabilitiesService.fetch();
     }
 
     /**
@@ -1948,7 +1962,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns The capabilities of the homeserver
      */
     public getCachedCapabilities(): Capabilities | undefined {
-        return this.serverCapabilitiesService.getCachedCapabilities();
+        return this.serverCapabilitiesService.getCached();
     }
 
     /**
@@ -1958,7 +1972,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns A promise which resolves to the capabilities of the homeserver
      */
     public fetchCapabilities(): Promise<Capabilities> {
-        return this.serverCapabilitiesService.fetchCapabilities();
+        return this.serverCapabilitiesService.fetch();
     }
 
     /**

package/src/matrix.ts

@@ -71,6 +71,7 @@ export * from "./@types/location.ts";
 export * from "./@types/threepids.ts";
 export * from "./@types/auth.ts";
 export * from "./@types/polls.ts";
+export * from "./@types/retention.ts";
 export type * from "./@types/local_notifications.ts";
 export type * from "./@types/registration.ts";
 export * from "./@types/read_receipts.ts";

package/src/matrixrtc/MembershipManager.ts

@@ -207,6 +207,8 @@ export class MembershipManager
      * transport selection will be used instead.
      * @param onError This will be called once the membership manager encounters an unrecoverable error.
      * This should bubble up the the frontend to communicate that the call does not work in the current environment.
+     * The original underlying error is preserved as `error.cause`, so consumers can `instanceof`-check the typed
+     * cause.
      */
     public join(fociPreferred: Transport[], multiSfuFocus?: Transport, onError?: (error: unknown) => void): void {
         if (this.scheduler.running) {

package/src/matrixrtc/MembershipManagerActionScheduler.ts

@@ -103,7 +103,10 @@ export class ActionScheduler {
                         // `this.wakeup` can also be called and sets the `wakeupUpdate` object while we are in the handler.
                         handlerResult = await this.membershipLoopHandler(nextAction.type as MembershipActionType);
                     } catch (e) {
-                        throw Error(`The MembershipManager shut down because of the end condition: ${e}`);
+                        // Preserve the original error as `cause`.
+                        throw new Error(`The MembershipManager shut down because of the end condition: ${e}`, {
+                            cause: e,
+                        });
                     }
                 }
                 // remove the processed action only after we are done processing

package/src/models/room-retention.ts

@@ -0,0 +1,230 @@
+/*
+Copyright 2026 Element Creations Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MatrixEvent } from "../models/event.ts";
+import { RoomEvent, type Room } from "./room.ts";
+import { RoomStateEvent, type RoomState } from "./room-state.ts";
+import { type Logger, logger as rootLogger } from "../logger.ts";
+import { EventType } from "../@types/event.ts";
+import type { RetentionPolicyService } from "../retentionPolicy.ts";
+import type { IStore } from "../store/index.ts";
+import { ROOM_RETENTION_TYPE, type RoomRetentionContent } from "../@types/retention.ts";
+
+/**
+ * Applies https://github.com/matrix-org/matrix-spec-proposals/pull/1763 by checking the current
+ * state of the room and applying the *latest* retention policy to all preceeding events.
+ * Currently does not:
+ *   - Apply global server policies (requires Synapse work)
+ *   - React at all to `min_retention` configs.
+ *   - Loop
+ */
+export class RoomRetentionPolicy {
+    // minRetention is not implemented.
+    private maxRetention: number | null = null;
+    private retentionTimeout?: ReturnType<typeof setTimeout>;
+    private readonly logger: Logger;
+
+    public constructor(
+        private readonly room: Room,
+        private readonly retentionService: RetentionPolicyService,
+        private readonly store: IStore,
+    ) {
+        this.logger = rootLogger.getChild(`RetentionPolicy ${room.roomId}`);
+
+        // Recalculate on room state update.
+        room.on(RoomStateEvent.Events, (event) => {
+            if (
+                event.getStateKey() !== "" ||
+                (event.getType() !== "org.matrix.msc1763.retention" && event.getType() !== "m.room.retention")
+            ) {
+                return;
+            }
+            void this.handleRetentionUpdate();
+        });
+
+        // Recalculate our retention whenever the global policy changes.
+        this.retentionService.on("update", () => {
+            this.logger.info("Got global retention policy update!");
+            void this.handleRetentionUpdate();
+        });
+        // Do an initial check on construction.
+        void this.handleRetentionUpdate();
+
+        // Only bind RoomEvent.Timeline once we know we have a retention policy.
+    }
+
+    public shouldEventBeRetained(ev: MatrixEvent): boolean {
+        if (!this.maxRetention) {
+            return true;
+        }
+        const expireBefore = Date.now() - this.maxRetention;
+        return ev.getTs() > expireBefore;
+    }
+
+    private readonly handleRetentionUpdate = async (): Promise<void> => {
+        // First store if we currently have a retention period.
+        const hadRetentionPeriod = this.maxRetention !== null;
+
+        try {
+            await this.recalculateRetention(this.room.currentState);
+        } catch (err) {
+            this.logger.warn("Failed to recalculate retention policy", err);
+            return;
+        }
+
+        // Bind/unbind the Timeline event handler based on whether we should be running retention.
+        if (hadRetentionPeriod !== (this.maxRetention !== null)) {
+            this.logger.info("retention recalculated to be", this.maxRetention);
+            // We've changed
+            if (this.maxRetention) {
+                this.room.on(RoomEvent.Timeline, this.timelineUpdated);
+            } else {
+                this.room.off(RoomEvent.Timeline, this.timelineUpdated);
+            }
+        }
+    };
+
+    private readonly recalculateRetention = async (roomState: RoomState): Promise<void> => {
+        const unstableEvent = roomState.getStateEvents(ROOM_RETENTION_TYPE.name).find((e) => e.getStateKey() === "");
+        const stableEvent = roomState.getStateEvents(ROOM_RETENTION_TYPE.altName).find((e) => e.getStateKey() === "");
+
+        const serverPolicy = this.retentionService.getCached();
+
+        const serverRoomPolicy = serverPolicy?.policies?.[this.room.roomId];
+        const roomStatePolicy =
+            unstableEvent?.getContent<RoomRetentionContent>() ?? stableEvent?.getContent<RoomRetentionContent>();
+
+        const content =
+            // * if the homeserver defines a specific retention policy for this room, then use this policy as the effective retention policy of the room.
+            serverRoomPolicy ??
+            // * otherwise, if the state of the room includes a `m.room.retention` event with an empty state key:
+            roomStatePolicy ??
+            // * otherwise, if the state of the room does not include a m.room.retention event with an empty state key:
+            serverPolicy?.policies?.["*"];
+
+        if (!content) {
+            // * otherwise, don't apply a retention policy in this room.
+            this.maxRetention = null;
+            return;
+        }
+
+        const validatePolicy = !serverRoomPolicy && roomStatePolicy;
+
+        // Parse it
+        let { max_lifetime: maxLifetime } = content;
+
+        if (!maxLifetime && validatePolicy) {
+            // if there is no value specified in the room's state, use the limit's min value for the effective retention policy of the room (which can be null or absent).
+            maxLifetime = serverPolicy?.limits?.max_lifetime?.min;
+            if (!maxLifetime) {
+                this.maxRetention = null;
+                return;
+            }
+        }
+
+        if (typeof maxLifetime !== "number") {
+            throw Error(`max_lifetime must be a number, got "${maxLifetime}"`);
+        }
+        if (maxLifetime < 0 || !Number.isInteger(maxLifetime)) {
+            throw Error(`max_lifetime must be >= 0, got ${maxLifetime}`);
+        }
+        this.maxRetention = maxLifetime;
+
+        if (validatePolicy && serverPolicy?.limits?.max_lifetime) {
+            // We're using room state so we need to validate this policy matches the server.
+            /**
+            if the value specified in the room's state complies with the limit, use this value for the effective retention policy of the room.
+            if the value specified in the room's state is lower than the limit's min value, use the min value for the effective retention policy of the room.
+            if the value specified in the room's state is greater than the limit's max value, use the max value for the effective retention policy of the room.
+            */
+            this.maxRetention = Math.max(this.maxRetention, serverPolicy.limits.max_lifetime.min ?? 0);
+            this.maxRetention = Math.min(
+                this.maxRetention,
+                serverPolicy.limits.max_lifetime.max ?? Number.MAX_SAFE_INTEGER,
+            );
+        }
+
+        this.processTimeline();
+    };
+
+    private readonly timelineUpdated = (): void => {
+        this.logger.info("timelineUpdated");
+        this.scheduleTimelineCheck(200);
+    };
+
+    private readonly scheduleTimelineCheck = (nextTs: number): void => {
+        if (this.retentionTimeout) {
+            clearTimeout(this.retentionTimeout);
+        }
+        this.retentionTimeout = setTimeout(() => {
+            this.processTimeline();
+            this.retentionTimeout = undefined;
+        }, nextTs);
+    };
+
+    private processTimeline(): void {
+        if (!this.maxRetention) {
+            return; // No policy, skip.
+        }
+        this.logger.info(`Running processTimeline`);
+        const expireBefore = Date.now() - this.maxRetention;
+        const events = this.room
+            .getLiveTimeline()
+            .getEvents()
+            .filter((ev) => ev.getStateKey() === undefined && !ev.isRedacted() && ev.getType() !== "m.room.redaction");
+
+        const expiredEvents = events.filter((ev) => ev.getTs() < expireBefore);
+        const [earliestExpiringEvent] = events
+            .filter((ev) => ev.getTs() >= expireBefore)
+            .sort((a, b) => a.getTs() - b.getTs());
+
+        if (earliestExpiringEvent) {
+            const nextTs = earliestExpiringEvent.getTs() + this.maxRetention - Date.now();
+            this.logger.info(`Next expiry scheduled for ${nextTs}`);
+            this.scheduleTimelineCheck(nextTs);
+        }
+
+        if (expiredEvents.length === 0) {
+            this.logger.info("Found no expired events");
+            return;
+        }
+        this.logger.info(`Found ${expiredEvents.length} expired events`);
+        for (const event of expiredEvents) {
+            this.room.tryApplyRedaction(
+                new MatrixEvent({
+                    type: EventType.RoomRedaction,
+                    sender: event.getSender(),
+                    event_id: "$synthetic_redaction",
+                    room_id: this.room.roomId,
+                    redacts: event.getId(),
+                    content: {
+                        reason: "Retention policy",
+                    },
+                    origin_server_ts: Date.now(),
+                    unsigned: {},
+                }),
+            );
+        }
+        void this.store
+            .removeEventsFromRoom(
+                this.room.roomId,
+                expiredEvents.map((e) => e.getId()!),
+            )
+            .catch((ex) => {
+                this.logger.warn(`Failed to remove events from store`, ex);
+            });
+    }
+}

package/src/models/room.ts

@@ -78,6 +78,7 @@ import { KnownMembership, type Membership } from "../@types/membership.ts";
 import { type Capabilities, type IRoomVersionsCapability, RoomVersionStability } from "../serverCapabilities.ts";
 import { type MSC4186Hero } from "../sliding-sync.ts";
 import { RoomStickyEventsStore, RoomStickyEventsEvent, type RoomStickyEventsMap } from "./room-sticky-events.ts";
+import { RoomRetentionPolicy } from "./room-retention.ts";
 
 // These constants are used as sane defaults when the homeserver doesn't support
 // the m.room_versions capability. In practice, KNOWN_SAFE_ROOM_VERSION should be
@@ -454,6 +455,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     private stickyEvents = new RoomStickyEventsStore();
 
+    private readonly retention?: RoomRetentionPolicy;
+
     /**
      * Construct a new Room.
      *
@@ -530,6 +533,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         } else {
             this.membersPromise = undefined;
         }
+        if (this.client?._unstable_shouldApplyMessageRetention) {
+            this.retention = new RoomRetentionPolicy(this, client.retentionPolicyService, client.store);
+        }
     }
 
     private threadTimelineSetsPromise: Promise<[EventTimelineSet, EventTimelineSet]> | null = null;
@@ -1864,6 +1870,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         timeline: EventTimeline,
         paginationToken?: string,
     ): void {
+        // ALWAYS filter out any events that are past retention
+        events = events.filter((e) => this.retention?.shouldEventBeRetained(e) ?? true);
         timeline.getTimelineSet().addEventsToTimeline(events, toStartOfTimeline, addToState, timeline, paginationToken);
     }
 
@@ -2466,6 +2474,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * Adds events to a thread's timeline. Will fire "Thread.update"
      */
     public processThreadedEvents(events: MatrixEvent[], toStartOfTimeline: boolean): void {
+        // ALWAYS filter out any events that are past retention
+        events = events.filter((e) => this.retention?.shouldEventBeRetained(e) ?? true);
         events.forEach(this.tryApplyRedaction);
 
         const eventsByThread: { [threadId: string]: MatrixEvent[] } = {};
@@ -2620,7 +2630,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
     }
 
-    private tryApplyRedaction = (event: MatrixEvent): void => {
+    public readonly tryApplyRedaction = (event: MatrixEvent): void => {
         // FIXME: apply redactions to notification list
 
         // NB: We continue to add the redaction event to the timeline at the
@@ -3082,6 +3092,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             throw new Error("duplicateStrategy MUST be either 'replace' or 'ignore'");
         }
 
+        // ALWAYS filter out any events that are past retention
+        events = events.filter((e) => this.retention?.shouldEventBeRetained(e) ?? true);
+
         // sanity check that the live timeline is still live
         this.assertTimelineSetsAreLive();
 
@@ -3476,6 +3489,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     // eslint-disable-next-line
     public _unstable_addStickyEvents(events: MatrixEvent[]): ReturnType<RoomStickyEventsStore["addStickyEvents"]> {
+        // ALWAYS filter out any events that are past retention
+        events = events.filter((e) => this.retention?.shouldEventBeRetained(e) ?? true);
+
         return this.stickyEvents.addStickyEvents(events);
     }
 

package/src/retentionPolicy.ts

@@ -0,0 +1,65 @@
+/*
+Copyright 2024 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { CapabilityPoller } from "./capabilityPoller.ts";
+import { ClientPrefix, type IHttpOpts, type MatrixHttpApi, Method } from "./http-api/index.ts";
+import type { Logger } from "./logger.ts";
+
+export interface RetentionConfigurationResponse {
+    policies?: Record<
+        string,
+        {
+            max_lifetime?: number;
+            min_lifetime?: number;
+        }
+    >;
+    limits?: {
+        min_lifetime?: {
+            min?: number;
+            max?: number;
+        };
+        max_lifetime?: {
+            min?: number;
+            max?: number;
+        };
+    };
+}
+
+/**
+ * Manages storing and periodically refreshing the server capabilities.
+ */
+export class RetentionPolicyService extends CapabilityPoller<RetentionConfigurationResponse> {
+    public constructor(logger: Logger, http: MatrixHttpApi<IHttpOpts & { onlyData: true }>) {
+        super(logger, http, "retention policy");
+    }
+    /**
+     * Fetches the latest server capabilities from the homeserver and returns them, or rejects
+     * on failure.
+     */
+    public fetch = async (): Promise<RetentionConfigurationResponse> => {
+        const resp = await this.http.authedRequest<RetentionConfigurationResponse>(
+            Method.Get,
+            "/retention/configuration",
+            undefined,
+            undefined,
+            {
+                prefix: `${ClientPrefix.Unstable}/org.matrix.msc1763`,
+            },
+        );
+        this.cached = resp;
+        return this.cached;
+    };
+}

package/src/rust-crypto/backup.ts

@@ -80,13 +80,17 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
     /** whether {@link backupKeysLoop} is currently running */
     private backupKeysLoopRunning = false;
 
+    /** The logger to use */
+    private readonly logger: Logger;
+
     public constructor(
-        private readonly logger: Logger,
+        logger: Logger,
         private readonly olmMachine: OlmMachine,
         private readonly http: MatrixHttpApi<IHttpOpts & { onlyData: true }>,
         private readonly outgoingRequestProcessor: OutgoingRequestProcessor,
     ) {
         super();
+        this.logger = logger.getChild("[RustBackupManager]");
     }
 
     /**
@@ -142,7 +146,8 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
     /**
      * Re-check the key backup and enable/disable it as appropriate.
      *
-     * @param force - whether we should force a re-check even if one has already happened.
+     * @param force - whether we should force a re-check even if one has already happened. If this is
+     *   `false`, and we have already done a check, `null` is returned rather than the actual info on the key backup.
      */
     public checkKeyBackupAndEnable(force: boolean): Promise<KeyBackupCheck | null> {
         if (!force && this.checkedForBackup) {
@@ -161,6 +166,9 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
     /**
      * Handles a backup secret received event and store it if it matches the current backup version.
      *
+     * Also enables key backup upload if it was not previously enabled, and the encryption key matches the received
+     * decryption key.
+     *
      * @param secret - The secret as received from a `m.secret.send` or `io.element.msc4385.secret.push` event for secret `m.megolm_backup.v1`.
      * @returns true if the secret is valid and has been stored, false otherwise.
      */
@@ -206,11 +214,14 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
                 `handleBackupSecretReceived: Valid decryption key for the current server-side backup version (${latestBackupInfo.version}) received`,
             );
             await this.saveBackupDecryptionKey(backupDecryptionKey, latestBackupInfo.version);
-            // Check if the backup should be enabled (e.g. if it's properly
-            // signed), and enable it if it should
+
+            // Check if backup upload should be enabled (e.g. the encryption key matches the decryption key),
+            // and enable it if so.
             if (this.keyBackupCheckInProgress) {
+                this.logger.debug("handleBackupSecretReceived: waiting for ongoing keybackup check to complete");
                 await this.keyBackupCheckInProgress;
             }
+            this.logger.debug("handleBackupSecretReceived: checking if we can enable keybackup upload");
             this.keyBackupCheckInProgress = this.doCheckKeyBackup(latestBackupInfo).finally(() => {
                 this.keyBackupCheckInProgress = null;
             });

package/src/serverCapabilities.ts

@@ -14,15 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { CapabilityPoller } from "./capabilityPoller.ts";
 import { type IHttpOpts, type MatrixHttpApi, Method } from "./http-api/index.ts";
-import { type Logger } from "./logger.ts";
-
-// How often we update the server capabilities.
-// 6 hours - an arbitrary value, but they should change very infrequently.
-const CAPABILITIES_CACHE_MS = 6 * 60 * 60 * 1000;
-
-// How long we want before retrying if we couldn't fetch
-const CAPABILITIES_RETRY_MS = 30 * 1000;
+import type { Logger } from "./logger.ts";
 
 export interface ICapability {
     enabled: boolean;
@@ -77,70 +71,17 @@ type CapabilitiesResponse = {
 /**
  * Manages storing and periodically refreshing the server capabilities.
  */
-export class ServerCapabilities {
-    private capabilities?: Capabilities;
-    private retryTimeout?: ReturnType<typeof setTimeout>;
-    private refreshTimeout?: ReturnType<typeof setInterval>;
-
-    public constructor(
-        private readonly logger: Logger,
-        private readonly http: MatrixHttpApi<IHttpOpts & { onlyData: true }>,
-    ) {}
-
-    /**
-     * Starts periodically fetching the server capabilities.
-     */
-    public start(): void {
-        this.poll().then();
+export class ServerCapabilities extends CapabilityPoller<Capabilities> {
+    public constructor(logger: Logger, http: MatrixHttpApi<IHttpOpts & { onlyData: true }>) {
+        super(logger, http, "server capabilities");
     }
-
-    /**
-     * Stops the service
-     */
-    public stop(): void {
-        this.clearTimeouts();
-    }
-
-    /**
-     * Returns the cached capabilities, or undefined if none are cached.
-     * @returns the current capabilities, if any.
-     */
-    public getCachedCapabilities(): Capabilities | undefined {
-        return this.capabilities;
-    }
-
     /**
      * Fetches the latest server capabilities from the homeserver and returns them, or rejects
      * on failure.
      */
-    public fetchCapabilities = async (): Promise<Capabilities> => {
+    public fetch = async (): Promise<Capabilities> => {
         const resp = await this.http.authedRequest<CapabilitiesResponse>(Method.Get, "/capabilities");
-        this.capabilities = resp["capabilities"];
-        return this.capabilities;
+        this.cached = resp["capabilities"];
+        return this.cached;
     };
-
-    private poll = async (): Promise<void> => {
-        try {
-            await this.fetchCapabilities();
-            this.clearTimeouts();
-            this.refreshTimeout = setTimeout(this.poll, CAPABILITIES_CACHE_MS);
-            this.logger.debug("Fetched new server capabilities");
-        } catch (e) {
-            this.clearTimeouts();
-            const howLong = Math.floor(CAPABILITIES_RETRY_MS + Math.random() * 5000);
-            this.retryTimeout = setTimeout(this.poll, howLong);
-            this.logger.warn(`Failed to refresh capabilities: retrying in ${howLong}ms`, e);
-        }
-    };
-
-    private clearTimeouts(): void {
-        if (this.refreshTimeout) {
-            clearInterval(this.refreshTimeout);
-            this.refreshTimeout = undefined;
-        }
-        if (this.retryTimeout) {
-            clearTimeout(this.retryTimeout);
-            this.retryTimeout = undefined;
-        }
-    }
 }

package/src/store/index.ts

@@ -273,6 +273,14 @@ export interface IStore {
      */
     getUserProfile(userId: string): Promise<SyncUserProfile | undefined>;
 
+    /**
+     * Remove all stored events matching the given IDs from the stored accumulated
+     * sync.
+     * @param roomId The target room.
+     * @param eventIds IDs of events to remove.
+     */
+    removeEventsFromRoom(roomId: string, eventIds: string[]): Promise<void>;
+
     /**
      * Stop the store and perform any appropriate cleanup
      */

package/src/store/indexeddb-local-backend.ts

@@ -633,6 +633,16 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
         await txnAsPromise(txn);
     }
 
+    public async removeEventsFromRoom(roomId: string, eventIds: string[]): Promise<void> {
+        try {
+            this.syncAccumulator.removeEventsFromRoom(roomId, eventIds);
+            const syncData = this.syncAccumulator.getJSON(true);
+            await Promise.all([this.persistSyncData(syncData.nextBatch, syncData.roomsData)]);
+        } finally {
+            this.syncToDatabasePromise = undefined;
+        }
+    }
+
     /*
      * Close the database
      */