matrix-js-sdk 41.8.0 → 41.9.0

package/src/client.ts

@@ -223,6 +223,7 @@ import { type CryptoBackend } from "./common-crypto/CryptoBackend.ts";
 import { RUST_SDK_STORE_PREFIX } from "./rust-crypto/constants.ts";
 import {
     type CrossSigningKeyInfo,
+    type CrossSigningKeys,
     type CryptoApi,
     type CryptoCallbacks,
     CryptoEvent,
@@ -570,14 +571,6 @@ export const UNSTABLE_MSC4354_STICKY_EVENTS = "org.matrix.msc4354";
 export const UNSTABLE_MSC4133_EXTENDED_PROFILES = "uk.tcpip.msc4133";
 export const STABLE_MSC4133_EXTENDED_PROFILES = "uk.tcpip.msc4133.stable";
 
-enum CrossSigningKeyType {
-    MasterKey = "master_key",
-    SelfSigningKey = "self_signing_key",
-    UserSigningKey = "user_signing_key",
-}
-
-export type CrossSigningKeys = Record<CrossSigningKeyType, CrossSigningKeyInfo>;
-
 export type SendToDeviceContentMap = Map<string, Map<string, Record<string, any>>>;
 
 export interface ISignedKey {
@@ -588,6 +581,9 @@ export interface ISignedKey {
     device_id: string;
 }
 
+// re-export for backwards compatibility
+export { type CrossSigningKeys };
+
 export type KeySignatures = Record<string, Record<string, CrossSigningKeyInfo | ISignedKey>>;
 export interface IUploadKeySignaturesResponse {
     failures: Record<
@@ -1490,10 +1486,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // periodically poll for turn servers if we support voip
         if (this.supportsVoip()) {
             this.checkTurnServersIntervalID = setInterval(() => {
-                this.checkTurnServers();
+                void this.checkTurnServers();
             }, TURN_CHECK_INTERVAL);
-            // noinspection ES6MissingAwait
-            this.checkTurnServers();
+            void this.checkTurnServers();
         }
 
         if (this.syncApi) {
@@ -1534,9 +1529,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         if (this.clientOpts.clientWellKnownPollPeriod !== undefined) {
             this.clientWellKnownIntervalID = setInterval(() => {
-                this.fetchClientWellKnown();
+                void this.fetchClientWellKnown();
             }, 1000 * this.clientOpts.clientWellKnownPollPeriod);
-            this.fetchClientWellKnown();
+            void this.fetchClientWellKnown();
         }
 
         this.toDeviceMessageQueue.start();
@@ -1922,7 +1917,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public retryImmediately(): boolean {
         // don't await for this promise: we just want to kick it off
-        this.toDeviceMessageQueue.sendQueue();
+        void this.toDeviceMessageQueue.sendQueue();
         return this.syncApi?.retryImmediately() ?? false;
     }
 
@@ -2056,7 +2051,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         this.on(RoomMemberEvent.Membership, rustCrypto.onRoomMembership.bind(rustCrypto));
         this.on(RoomStateEvent.Events, rustCrypto.onRoomStateEvent.bind(rustCrypto));
         this.on(ClientEvent.Event, (event) => {
-            rustCrypto.onLiveEventFromSync(event);
+            void rustCrypto.onLiveEventFromSync(event);
         });
 
         // re-emit the events emitted by the crypto impl
@@ -2514,7 +2509,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public resendEvent(event: MatrixEvent, room: Room): Promise<ISendEventResponse> {
         // also kick the to-device queue to retry
-        this.toDeviceMessageQueue.sendQueue();
+        void this.toDeviceMessageQueue.sendQueue();
 
         this.updatePendingEventStatus(room, event, EventStatus.SENDING);
         return this.encryptAndSendEvent(room, event);
@@ -5918,7 +5913,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (this.isInitialSyncComplete()) {
             if (supportsMatrixCall()) {
                 this.callEventHandler!.start();
-                this.groupCallEventHandler!.start();
+                void this.groupCallEventHandler!.start();
             }
 
             this.off(ClientEvent.Sync, this.startCallEventHandler);
@@ -6432,7 +6427,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         if (event.shouldAttemptDecryption() && this.getCrypto()) {
-            event.attemptDecryption(this.cryptoBackend!, options);
+            void event.attemptDecryption(this.cryptoBackend!, options);
         }
 
         if (event.isBeingDecrypted()) {
@@ -8836,8 +8831,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (!events?.length) return;
         if (!room) return;
 
-        room.currentState.processBeaconEvents(events, this);
-        room.processPollEvents(events);
+        void room.currentState.processBeaconEvents(events, this);
+        void room.processPollEvents(events);
     }
 
     /**

package/src/crypto-api/index.ts

@@ -74,8 +74,6 @@ export interface StartDehydrationOpts {
 
 /**
  * Public interface to the cryptography parts of the js-sdk
- *
- * @remarks Currently, this is a work-in-progress. In time, more methods will be added here.
  */
 export interface CryptoApi {
     /**
@@ -267,10 +265,18 @@ export interface CryptoApi {
      *
      * This is useful if the user was previously verified but is not anymore
      * ({@link UserVerificationStatus.wasCrossSigningVerified}) and it is not possible to verify him again now.
-     *
      */
     withdrawVerificationRequirement(userId: string): Promise<void>;
 
+    /**
+     * Get the given user's public cross-signing keys, if they have published any, and we have fetched them to
+     * our store.
+     *
+     * Normally this is only useful to applications as debug info, since the SDK handles keeping track of a
+     * user's identity, and whether their devices are verified.
+     */
+    getUserCrossSigningKeys(userId: string): Promise<Partial<CrossSigningKeys> | null>;
+
     /**
      * Get the verification status of a given device.
      *
@@ -1224,11 +1230,16 @@ export interface CreateSecretStorageOpts {
 
 /** Types of cross-signing key */
 export enum CrossSigningKey {
-    Master = "master",
-    SelfSigning = "self_signing",
-    UserSigning = "user_signing",
+    Master = "master_key",
+    SelfSigning = "self_signing_key",
+    UserSigning = "user_signing_key",
 }
 
+/** All of a user's cross-signing keys.
+ * @see https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3keysdevice_signingupload
+ */
+export type CrossSigningKeys = Record<CrossSigningKey, CrossSigningKeyInfo>;
+
 /**
  * Information on one of the cross-signing keys.
  * @see https://spec.matrix.org/v1.7/client-server-api/#post_matrixclientv3keysdevice_signingupload

package/src/embedded.ts

@@ -527,19 +527,17 @@ export class RoomWidgetClient extends MatrixClient {
             );
         }
 
-        let updateDelayedEvent: (delayId: string) => Promise<unknown>;
         switch (action) {
             case UpdateDelayedEventAction.Cancel:
-                updateDelayedEvent = this.widgetApi.cancelScheduledDelayedEvent;
+                await this.widgetApi.cancelScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
                 break;
             case UpdateDelayedEventAction.Restart:
-                updateDelayedEvent = this.widgetApi.cancelScheduledDelayedEvent;
+                await this.widgetApi.restartScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
                 break;
             case UpdateDelayedEventAction.Send:
-                updateDelayedEvent = this.widgetApi.sendScheduledDelayedEvent;
+                await this.widgetApi.sendScheduledDelayedEvent(delayId).catch(timeoutToConnectionError);
                 break;
         }
-        await updateDelayedEvent.call(this.widgetApi, delayId).catch(timeoutToConnectionError);
         return {};
     }
 
@@ -682,7 +680,7 @@ export class RoomWidgetClient extends MatrixClient {
     }
 
     private async ack(ev: CustomEvent<IWidgetApiRequest>): Promise<void> {
-        await this.widgetApi.transport.reply<IWidgetApiAcknowledgeResponseData>(ev.detail, {});
+        this.widgetApi.transport.reply<IWidgetApiAcknowledgeResponseData>(ev.detail, {});
     }
 
     private updateTxId = async (event: MatrixEvent): Promise<void> => {

package/src/filter-component.ts

@@ -195,6 +195,7 @@ export class FilterComponent {
      * @returns events which matched the filter component
      */
     public filter(events: MatrixEvent[]): MatrixEvent[] {
+        // oxlint-disable-next-line typescript/unbound-method
         return events.filter(this.check, this);
     }
 

package/src/http-api/utils.ts

@@ -39,7 +39,7 @@ export function timeoutSignal(ms: number): AbortSignal {
 
 export function anySignal(signals: AbortSignal[]): {
     signal: AbortSignal;
-    cleanup(): void;
+    cleanup(this: void): void;
 } {
     const controller = new AbortController();
 

package/src/interactive-auth.ts

@@ -205,7 +205,7 @@ interface IOpts<T> {
      * The busyChanged callback should be used instead of the background flag.
      * Should return a promise which resolves to the successful response or rejects with a MatrixError.
      */
-    doRequest(auth: AuthDict | null, background: boolean): Promise<T>;
+    doRequest(this: void, auth: AuthDict | null, background: boolean): Promise<T>;
     /**
      * Called when the status of the UI auth changes,
      * ie. when the state of an auth stage changes of when the auth flow moves to a new stage.
@@ -219,7 +219,7 @@ interface IOpts<T> {
      *     m.login.email.identity:
      *         * emailSid: string, the sid of the active email auth session
      */
-    stateUpdated(nextStage: AuthType | string, status: IStageStatus): void;
+    stateUpdated(this: void, nextStage: AuthType | string, status: IStageStatus): void;
 
     /**
      * A function that takes the email address (string), clientSecret (string), attempt number (int) and
@@ -227,14 +227,20 @@ interface IOpts<T> {
      * function.
      * If the resulting promise rejects, the rejection will propagate through to the attemptAuth promise.
      */
-    requestEmailToken(email: string, secret: string, attempt: number, session: string): Promise<{ sid: string }>;
+    requestEmailToken(
+        this: void,
+        email: string,
+        secret: string,
+        attempt: number,
+        session: string,
+    ): Promise<{ sid: string }>;
     /**
      * Called whenever the interactive auth logic becomes busy submitting information provided by the user or finishes.
      * After this has been called with true the UI should indicate that a request is in progress
      * until it is called again with false.
      */
-    busyChanged?(busy: boolean): void;
-    startAuthStage?(nextStage: string): Promise<void>; // LEGACY
+    busyChanged?(this: void, busy: boolean): void;
+    startAuthStage?(this: void, nextStage: string): Promise<void>; // LEGACY
 }
 
 /**

package/src/matrixrtc/LivekitTransport.ts

@@ -32,7 +32,7 @@ export const isLivekitTransport = (object: any): object is LivekitTransport =>
     isLivekitTransportConfig(object) && "livekit_alias" in object;
 
 /**
- * @deprecated, this is just needed for the old focus active / focus fields of a call membership.
+ * @deprecated this is just needed for the old focus active / focus fields of a call membership.
  * Not needed for new implementations.
  */
 export interface LivekitFocusSelection extends Transport {

package/src/matrixrtc/MatrixRTCSession.ts

@@ -816,7 +816,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
         }
         // This also needs to be done if `changed` = false
         // A member might have updated their fingerprint (created_ts)
-        void this.encryptionManager?.onMembershipsUpdate(oldMemberships);
+        this.encryptionManager?.onMembershipsUpdate(oldMemberships);
 
         this.setExpiryTimer();
     };

package/src/models/MSC3089Branch.ts

@@ -198,7 +198,7 @@ export class MSC3089Branch {
         additionalContent?: IContent,
     ): Promise<ISendEventResponse> {
         const fileEventResponse = await this.directory.createFile(name, encryptedContents, info, {
-            ...(additionalContent ?? {}),
+            ...additionalContent,
             "m.new_content": true,
             "m.relates_to": {
                 rel_type: RelationType.Replace,

package/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/src/models/room.ts

@@ -1352,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
@@ -1598,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);
@@ -2327,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);
@@ -2348,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

package/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/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/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/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/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/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);

package/src/rust-crypto/verification.ts

@@ -728,7 +728,7 @@ export class RustSASVerifier extends BaseRustVerifer<RustSdkCryptoJs.Sas> implem
                 mismatch: (): void => {
                     const request = this.inner.cancelWithCode("m.mismatched_sas");
                     if (request) {
-                        this.outgoingRequestProcessor.makeOutgoingRequest(request);
+                        void this.outgoingRequestProcessor.makeOutgoingRequest(request);
                     }
                 },
                 cancel: (): void => {

package/src/sliding-sync-sdk.ts

@@ -156,13 +156,11 @@ class ExtensionToDevice implements Extension<ExtensionToDeviceRequest, Extension
         if (this.cryptoCallbacks) {
             receivedToDeviceMessages = await this.cryptoCallbacks.preprocessToDeviceMessages(events);
         } else {
-            receivedToDeviceMessages = events.map((rawEvent) =>
-                // Crypto is not enabled, so we just return the events.
-                ({
-                    message: rawEvent,
-                    encryptionInfo: null,
-                }),
-            );
+            // Crypto is not enabled, so we just return the events.
+            receivedToDeviceMessages = events.map((rawEvent) => ({
+                message: rawEvent,
+                encryptionInfo: null,
+            }));
         }
         processToDeviceMessages(receivedToDeviceMessages, this.client);
 

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

@@ -323,10 +323,10 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
         const roomRange = IDBKeyRange.only(roomId);
 
         const minStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "next")).then(
-            (cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1],
+            (cursor) => (<IDBValidKey[]>cursor?.primaryKey)?.[1],
         );
         const maxStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "prev")).then(
-            (cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1],
+            (cursor) => (<IDBValidKey[]>cursor?.primaryKey)?.[1],
         );
         const [minStateKey, maxStateKey] = await Promise.all([minStateKeyProm, maxStateKeyProm]);
 
@@ -637,7 +637,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
         try {
             this.syncAccumulator.removeEventsFromRoom(roomId, eventIds);
             const syncData = this.syncAccumulator.getJSON(true);
-            await Promise.all([this.persistSyncData(syncData.nextBatch, syncData.roomsData)]);
+            await this.persistSyncData(syncData.nextBatch, syncData.roomsData);
         } finally {
             this.syncToDatabasePromise = undefined;
         }

package/src/sync.ts

@@ -917,7 +917,7 @@ export class SyncApi {
             // tell the crypto module to do its processing. It may block (to do a
             // /keys/changes request).
             if (this.syncOpts.cryptoCallbacks) {
-                await this.syncOpts.cryptoCallbacks.onSyncCompleted(syncEventData);
+                this.syncOpts.cryptoCallbacks.onSyncCompleted(syncEventData);
             }
 
             // keep emitting SYNCING -> SYNCING for clients who want to do bulk updates
@@ -1195,13 +1195,11 @@ export class SyncApi {
                 receivedToDeviceMessages =
                     await this.syncOpts.cryptoCallbacks.preprocessToDeviceMessages(toDeviceMessages);
             } else {
-                receivedToDeviceMessages = toDeviceMessages.map((rawEvent) =>
-                    // Crypto is not enabled, so we just return the events.
-                    ({
-                        message: rawEvent,
-                        encryptionInfo: null,
-                    }),
-                );
+                // Crypto is not enabled, so we just return the events.
+                receivedToDeviceMessages = toDeviceMessages.map((rawEvent) => ({
+                    message: rawEvent,
+                    encryptionInfo: null,
+                }));
             }
 
             processToDeviceMessages(receivedToDeviceMessages, client);