@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/matrix-js-sdk/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/node_modules/matrix-js-sdk/src/models/room-sticky-events.ts

@@ -85,6 +85,7 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
     /**
      * Get all sticky events that are currently active.
      * @returns An iterable set of events.
+     * @yields {@link StickyMatrixEvent}
      */
     public *getStickyEvents(): Iterable<StickyMatrixEvent> {
         yield* this.unkeyedStickyEvents;

package/node_modules/matrix-js-sdk/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;
@@ -1346,11 +1352,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
     }
 
-    private onReceipt(event: MatrixEvent): void {
+    private onReceipt = (event: MatrixEvent): void => {
         if (this.hasEncryptionStateEvent()) {
             this.clearNotificationsOnReceipt(event);
         }
-    }
+    };
 
     private clearNotificationsOnReceipt(event: MatrixEvent): void {
         // Like above, we have to listen for read receipts from ourselves in order to
@@ -1592,9 +1598,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         const notification: NotificationCount = {
             highlight: this.threadNotifications.get(threadId)?.highlight,
             total: this.threadNotifications.get(threadId)?.total,
-            ...{
-                [type]: count,
-            },
+            [type]: count,
         };
 
         this.threadNotifications.set(threadId, notification);
@@ -1864,6 +1868,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);
     }
 
@@ -2319,15 +2325,15 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
     }
 
-    private onThreadUpdate(thread: Thread): void {
+    private onThreadUpdate = (thread: Thread): void => {
         this.updateThreadRootEvents(thread, false, false);
-    }
+    };
 
-    private onThreadReply(thread: Thread): void {
+    private onThreadReply = (thread: Thread): void => {
         this.updateThreadRootEvents(thread, false, true);
-    }
+    };
 
-    private onThreadDelete(thread: Thread): void {
+    private onThreadDelete = (thread: Thread): void => {
         this.threads.delete(thread.id);
 
         const timeline = this.getTimelineForEvent(thread.id);
@@ -2340,7 +2346,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         for (const timelineSet of this.threadsTimelineSets) {
             timelineSet.removeEvent(thread.id);
         }
-    }
+    };
 
     /**
      * Forget the timelineSet for this room with the given filter
@@ -2466,6 +2472,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 +2628,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 +3090,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 +3487,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/node_modules/matrix-js-sdk/src/receipt-accumulator.ts

@@ -65,6 +65,7 @@ export class ReceiptAccumulator {
     /**
      * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the
      *          most recently-received unthreaded receipts for each user.
+     * @yields pairs of [userId, AccumulatedReceipt]
      */
     private allUnthreaded(): IterableIterator<[string, AccumulatedReceipt]> {
         return this.unthreadedReadReceipts.entries();
@@ -74,6 +75,7 @@ export class ReceiptAccumulator {
      * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the
      *          most recently-received threaded receipts for each user, in all
      *          threads.
+     * @yields pairs of [userId, AccumulatedReceipt]
      */
     private *allThreaded(): IterableIterator<[string, AccumulatedReceipt]> {
         for (const receiptsForThread of this.threadedReadReceipts.values()) {

package/node_modules/matrix-js-sdk/src/rendezvous/index.ts

@@ -127,7 +127,7 @@ async function initGenerateQrFlow(
         channel.onFailure = undefined;
         flow.onFailure = undefined;
         // Cancel the session
-        flow.cancel(MSC4108FailureReason.UserCancelled);
+        void flow.cancel(MSC4108FailureReason.UserCancelled);
     };
 
     await session.send(""); // open channel

package/node_modules/matrix-js-sdk/src/rendezvous/transports/MSC4108RendezvousSession.ts

@@ -160,7 +160,7 @@ export class MSC4108RendezvousSession {
                 this.expiresAt = new Date(expires);
                 this.expiresTimer = setTimeout(() => {
                     this.expiresTimer = undefined;
-                    this.cancel(ClientRendezvousFailureReason.Expired);
+                    void this.cancel(ClientRendezvousFailureReason.Expired);
                 }, this.expiresAt.getTime() - Date.now());
             }
             // MSC4108: we expect a JSON response with a rendezvous URL
@@ -175,7 +175,7 @@ export class MSC4108RendezvousSession {
 
     /**
      * Receives data from the rendezvous channel.
-     * @return the returned promise won't resolve until new data is acquired or the channel is closed either by the server or the other party.
+     * @returns the returned promise won't resolve until new data is acquired or the channel is closed either by the server or the other party.
      */
     public async receive(): Promise<string | undefined> {
         if (!this.url) {

package/node_modules/matrix-js-sdk/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/node_modules/matrix-js-sdk/src/rust-crypto/PerSessionKeyBackupDownloader.ts

@@ -130,7 +130,7 @@ export class PerSessionKeyBackupDownloader {
     /**
      * Check if key download is successfully configured and active.
      *
-     * @return `true` if key download is correctly configured and active; otherwise `false`.
+     * @returns `true` if key download is correctly configured and active; otherwise `false`.
      */
     public isKeyBackupDownloadConfigured(): boolean {
         return this.configuration !== null;

package/node_modules/matrix-js-sdk/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/node_modules/matrix-js-sdk/src/rust-crypto/index.ts

@@ -185,23 +185,23 @@ async function initOlmMachine(
         enableEncryptedStateEvents,
     );
 
-    await olmMachine.registerRoomKeyUpdatedCallback((sessions: RustSdkCryptoJs.RoomKeyInfo[]) =>
+    olmMachine.registerRoomKeyUpdatedCallback((sessions: RustSdkCryptoJs.RoomKeyInfo[]) =>
         rustCrypto.onRoomKeysUpdated(sessions),
     );
-    await olmMachine.registerRoomKeysWithheldCallback((withheld: RustSdkCryptoJs.RoomKeyWithheldInfo[]) =>
+    olmMachine.registerRoomKeysWithheldCallback((withheld: RustSdkCryptoJs.RoomKeyWithheldInfo[]) =>
         rustCrypto.onRoomKeysWithheld(withheld),
     );
-    await olmMachine.registerUserIdentityUpdatedCallback((userId: RustSdkCryptoJs.UserId) =>
+    olmMachine.registerUserIdentityUpdatedCallback((userId: RustSdkCryptoJs.UserId) =>
         rustCrypto.onUserIdentityUpdated(userId),
     );
-    await olmMachine.registerDevicesUpdatedCallback((userIds: string[]) => rustCrypto.onDevicesUpdated(userIds));
+    olmMachine.registerDevicesUpdatedCallback((userIds: string[]) => rustCrypto.onDevicesUpdated(userIds));
 
     // Check if there are any key backup secrets pending processing. There may be multiple secrets to process if several devices have gossiped them.
     // The `registerReceiveSecretCallback` function will only be triggered for new secrets. If the client is restarted before processing them, the secrets will need to be manually handled.
-    rustCrypto.checkSecrets("m.megolm_backup.v1");
+    void rustCrypto.checkSecrets("m.megolm_backup.v1");
 
     // Register a callback to be notified when a new secret is received, as for now only the key backup secret is supported (the cross signing secrets are handled automatically by the OlmMachine)
-    await olmMachine.registerReceiveSecretCallback((name: string, _value: string) =>
+    olmMachine.registerReceiveSecretCallback((name: string, _value: string) =>
         // Instead of directly checking the secret value, we poll the inbox to get all values for that secret type.
         // Once we have all the values, we can safely clear the secret inbox.
         rustCrypto.checkSecrets(name),

package/node_modules/matrix-js-sdk/src/rust-crypto/rust-crypto.ts

@@ -42,6 +42,7 @@ import {
     type BackupTrustInfo,
     type BootstrapCrossSigningOpts,
     type CreateSecretStorageOpts,
+    type CrossSigningKeys,
     CrossSigningKey,
     type CrossSigningKeyInfo,
     type CrossSigningStatus,
@@ -771,6 +772,29 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
         await userIdentity.withdrawVerification();
     }
 
+    /**
+     * Implementation of {@link CryptoApi#getUserCrossSigningKeys}.
+     */
+    public async getUserCrossSigningKeys(userId: string): Promise<Partial<CrossSigningKeys> | null> {
+        const userIdentity = await this.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+
+        if (!userIdentity) {
+            return null;
+        }
+
+        const result: Partial<CrossSigningKeys> = {
+            master_key: JSON.parse(userIdentity.masterKey),
+            self_signing_key: JSON.parse(userIdentity.selfSigningKey),
+        };
+
+        // The USK is only visible for our own identity
+        if ("userSigningKey" in userIdentity) {
+            result.user_signing_key = JSON.parse(userIdentity.userSigningKey);
+        }
+
+        return result;
+    }
+
     /**
      * Implementation of {@link CryptoApi#isCrossSigningReady}
      */
@@ -1147,7 +1171,7 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
                 verificationMethodIdentifierToMethod(method),
             );
             // Get the request content to send to the DM room
-            const verCont: string = await userIdentity.verificationRequestContent(methods);
+            const verCont: string = userIdentity.verificationRequestContent(methods);
 
             // TODO: due to https://github.com/matrix-org/matrix-rust-sdk/issues/5643, we need to fix up the verification request content to include `msgtype`.
             const verContObj = JSON.parse(verCont);
@@ -1158,7 +1182,7 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
             const eventId = await this.sendVerificationRequestContent(roomId, verificationEventContent);
 
             // Get a verification request
-            const request: RustSdkCryptoJs.VerificationRequest = await userIdentity.requestVerification(
+            const request: RustSdkCryptoJs.VerificationRequest = userIdentity.requestVerification(
                 new RustSdkCryptoJs.RoomId(roomId),
                 new RustSdkCryptoJs.EventId(eventId),
                 methods,
@@ -1385,7 +1409,7 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
         }
 
         // we can check and start async
-        this.checkKeyBackupAndEnable();
+        void this.checkKeyBackupAndEnable();
     }
 
     /**
@@ -1572,7 +1596,7 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
 
         // Delete the dehydrated device, since any existing one will be signed
         // by the wrong cross-signing key
-        this.dehydratedDeviceManager.delete();
+        void this.dehydratedDeviceManager.delete();
 
         // Disable backup, and delete all the backups from the server
         await this.backupManager.deleteAllKeyBackupVersions();
@@ -1992,7 +2016,7 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
             event.getContent().membership !== KnownMembership.Join
         ) {
             this.logger.info(`Rotating session for room ${event.getRoomId()} due to member leaving the room`);
-            this.forceDiscardSession(event.getRoomId()!);
+            void this.forceDiscardSession(event.getRoomId()!);
         }
     }
 
@@ -2008,7 +2032,7 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
         for (const key of keys) {
             this.onRoomKeyUpdated(key);
         }
-        this.backupManager.maybeUploadKey();
+        void this.backupManager.maybeUploadKey();
     }
 
     private onRoomKeyUpdated(key: RustSdkCryptoJs.RoomKeyInfo): void {
@@ -2179,7 +2203,7 @@ export class RustCrypto extends TypedEventEmitter<RustCryptoEvents, CryptoEventH
 
                 clearTimeout(timeoutId);
                 event.off(MatrixEventEvent.Decrypted, onDecrypted);
-                processEvent(decryptedEvent);
+                void processEvent(decryptedEvent);
             };
 
             event.on(MatrixEventEvent.Decrypted, onDecrypted);