matrix-js-sdk 42.1.0 → 42.2.0

package/src/client.ts

@@ -53,7 +53,7 @@ import * as utils from "./utils.ts";
 import { deepCompare, noUnsafeEventProps, type QueryDict, replaceParam, safeSet, sleep } from "./utils.ts";
 import { Direction, EventTimeline } from "./models/event-timeline.ts";
 import { type IActionsObject, PushProcessor } from "./pushprocessor.ts";
-import { AutoDiscovery, type AutoDiscoveryAction } from "./autodiscovery.ts";
+import { type AutoDiscoveryAction } from "./autodiscovery.ts";
 import { encodeUnpaddedBase64Url } from "./base64.ts";
 import { TypedReEmitter } from "./ReEmitter.ts";
 import { logger, type Logger } from "./logger.ts";
@@ -247,6 +247,9 @@ 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";
+import { createRtcTransportsCachedValue } from "./rtcTransportsCachedValue.ts";
+import { createWellKnownCachedValue } from "./wellKnownCachedValue.ts";
+import { type PollingCachedValue } from "./pollingCachedValue.ts";
 
 export type Store = IStore;
 
@@ -1095,6 +1098,7 @@ export enum ClientEvent {
     TurnServers = "turnServers",
     TurnServersError = "turnServers.error",
     UserProfileUpdate = "userProfileUpdate",
+    RtcTransportsUpdated = "rtcTransportsUpdated",
 }
 
 type RoomEvents =
@@ -1165,6 +1169,7 @@ export type ClientEventHandlerMap = {
     [ClientEvent.ReceivedVoipEvent]: (event: MatrixEvent) => void;
     [ClientEvent.TurnServers]: (servers: ITurnServer[]) => void;
     [ClientEvent.TurnServersError]: (error: Error, fatal: boolean) => void;
+    [ClientEvent.RtcTransportsUpdated]: (transports: Transport[]) => void;
     /**
      *
      * @param userId - the user ID of the profile which was updated
@@ -1273,7 +1278,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     protected syncLeftRoomsPromise?: Promise<Room[]>;
     protected syncedLeftRooms = false;
     protected clientOpts?: IStoredClientOpts;
-    protected clientWellKnownIntervalID?: ReturnType<typeof setInterval>;
     protected canResetTimelineCallback?: ResetTimelineCallback;
 
     public canSupport = new Map<Feature, ServerSupport>();
@@ -1285,8 +1289,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     // TODO: This should expire: https://github.com/matrix-org/matrix-js-sdk/issues/1020
     protected serverVersionsPromise?: Promise<IServerVersions>;
 
-    protected clientWellKnown?: IClientWellKnown;
-    protected clientWellKnownPromise?: Promise<IClientWellKnown>;
     protected turnServers: ITurnServer[] = [];
     protected turnServersExpiry = 0;
     protected checkTurnServersIntervalID?: ReturnType<typeof setInterval>;
@@ -1316,6 +1318,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public readonly retentionPolicyService: RetentionPolicyService;
     public readonly _unstable_shouldApplyMessageRetention: boolean;
 
+    public cachedRtcTransports: PollingCachedValue<Transport[]>;
+    protected cachedWellKnown: PollingCachedValue<IClientWellKnown>;
+
     public constructor(opts: IMatrixClientCreateOpts) {
         super();
 
@@ -1338,7 +1343,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const userId = opts.userId || null;
         this.credentials = { userId };
 
-        this.http = new MatrixHttpApi(this as ConstructorParameters<typeof MatrixHttpApi>[0], {
+        this.http = new MatrixHttpApi(this, {
             fetchFn: opts.fetchFn,
             baseUrl: opts.baseUrl,
             idBaseUrl: opts.idBaseUrl,
@@ -1432,6 +1437,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // having lots of event listeners is not unusual. 0 means "unlimited".
         this.setMaxListeners(0);
+
+        this.cachedRtcTransports = createRtcTransportsCachedValue(this, this.logger);
+        this.cachedWellKnown = createWellKnownCachedValue(this, this.logger);
     }
 
     public set store(newStore: Store) {
@@ -1510,18 +1518,19 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         this.syncApi.sync().catch((e) => this.logger.info("Sync startup aborted with an error:", e));
 
-        if (this.clientOpts.clientWellKnownPollPeriod !== undefined) {
-            this.clientWellKnownIntervalID = setInterval(() => {
-                void this.fetchClientWellKnown();
-            }, 1000 * this.clientOpts.clientWellKnownPollPeriod);
-            void this.fetchClientWellKnown();
-        }
+        this.cachedWellKnown.start(
+            this.clientOpts.clientWellKnownPollPeriod !== undefined
+                ? 1000 * this.clientOpts.clientWellKnownPollPeriod
+                : undefined,
+        );
 
         this.toDeviceMessageQueue.start();
         this.serverCapabilitiesService.start();
         if (this._unstable_shouldApplyMessageRetention) {
             this.retentionPolicyService?.start();
         }
+
+        this.cachedRtcTransports.start();
     }
 
     /**
@@ -1568,15 +1577,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         globalThis.clearInterval(this.checkTurnServersIntervalID);
         this.checkTurnServersIntervalID = undefined;
 
-        if (this.clientWellKnownIntervalID !== undefined) {
-            globalThis.clearInterval(this.clientWellKnownIntervalID);
-        }
-
         this.toDeviceMessageQueue.stop();
 
         this.matrixRTC.stop();
 
         this.serverCapabilitiesService.stop();
+
+        this.cachedRtcTransports.stop();
+        this.cachedWellKnown.stop();
     }
 
     /**
@@ -1969,6 +1977,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param args.storagePassword - An alternative to `storageKey`. A password which will be used to derive a key to
      *    encrypt the store with. Deriving a key from a password is (deliberately) a slow operation, so prefer
      *    to pass a `storageKey` directly where possible.
+     * @param args.caCertsPem - Optional PEM-formatted string that provides CA certificates. These will be used to check
+     *    X.509 signatures on user identities. Any user identity that has a valid signature according to the supplied
+     *    CAs will be considered verified, without any manual verification taking place.
+     *
+     *    NOTE: this is an unspecified extension to Matrix. Applications should exercise caution when using it.
      *
      * @returns a Promise which will resolve when the crypto layer has been
      *    successfully initialised.
@@ -1979,6 +1992,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             cryptoDatabasePrefix?: string;
             storageKey?: Uint8Array;
             storagePassword?: string;
+            caCertsPem?: string;
         } = {},
     ): Promise<void> {
         if (this.cryptoBackend) {
@@ -2024,6 +2038,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             },
 
             enableEncryptedStateEvents: this.enableEncryptedStateEvents,
+
+            caCertsPem: args.caCertsPem,
         });
 
         rustCrypto.setSupportedVerificationMethods(this.verificationMethods);
@@ -2129,7 +2145,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public deleteKeysFromBackup(roomId: string, sessionId: undefined, version?: string): Promise<void>;
     public deleteKeysFromBackup(roomId: string, sessionId: string, version?: string): Promise<void>;
     public async deleteKeysFromBackup(roomId?: string, sessionId?: string, version?: string): Promise<void> {
-        const path = this.makeKeyBackupPath(roomId!, sessionId!, version);
+        const path = this.makeKeyBackupPath(roomId, sessionId, version);
         await this.http.authedRequest(Method.Delete, path.path, path.queryData, undefined, { prefix: ClientPrefix.V3 });
     }
 
@@ -3194,14 +3210,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     ): Promise<ISendEventResponse> {
         if (typeof threadId !== "string" && threadId !== null) {
             txnId = content as string;
-            content = threadId as RoomMessageEventContent;
+            content = threadId;
             threadId = null;
         }
 
         const eventType = EventType.RoomMessage;
         const sendContent = content as RoomMessageEventContent;
 
-        return this.sendEvent(roomId, threadId as string | null, eventType, sendContent, txnId);
+        return this.sendEvent(roomId, threadId, eventType, sendContent, txnId);
     }
 
     /**
@@ -3310,8 +3326,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     ): Promise<ISendEventResponse> {
         if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
             text = (info as string) || "Image";
-            info = url as ImageInfo;
-            url = threadId as string;
+            info = url;
+            url = threadId;
             threadId = null;
         }
         const content = {
@@ -3351,8 +3367,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     ): Promise<ISendEventResponse> {
         if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
             text = (info as string) || "Sticker";
-            info = url as ImageInfo;
-            url = threadId as string;
+            info = url;
+            url = threadId;
             threadId = null;
         }
         const content = {
@@ -3384,7 +3400,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         htmlBody?: string,
     ): Promise<ISendEventResponse> {
         if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
-            htmlBody = body as string;
+            htmlBody = body;
             body = threadId;
             threadId = null;
         }
@@ -3412,7 +3428,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         htmlBody?: string,
     ): Promise<ISendEventResponse> {
         if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
-            htmlBody = body as string;
+            htmlBody = body;
             body = threadId;
             threadId = null;
         }
@@ -3440,7 +3456,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         htmlBody?: string,
     ): Promise<ISendEventResponse> {
         if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
-            htmlBody = body as string;
+            htmlBody = body;
             body = threadId;
             threadId = null;
         }
@@ -5561,7 +5577,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (promise) {
             return new Promise<void>((resolve, reject) => {
                 // Update this.pushRules when the operation completes
-                promise!
+                promise
                     .then(() => {
                         this.getPushRules()
                             .then((result) => {
@@ -6046,23 +6062,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return this.http.authedRequest(Method.Post, path, undefined, undefined, { prefix: "" });
     }
 
-    protected async fetchClientWellKnown(): Promise<void> {
-        // `getRawClientConfig` does not throw or reject on network errors, instead
-        // it absorbs errors and returns `{}`.
-        this.clientWellKnownPromise = AutoDiscovery.getRawClientConfig(this.getDomain() ?? undefined);
-        this.clientWellKnown = await this.clientWellKnownPromise;
-        this.emit(ClientEvent.ClientWellKnown, this.clientWellKnown);
-    }
-
     public getClientWellKnown(): IClientWellKnown | undefined {
-        return this.clientWellKnown;
+        return this.cachedWellKnown.get();
     }
 
-    public waitForClientWellKnown(): Promise<IClientWellKnown> {
+    public async waitForClientWellKnown(): Promise<IClientWellKnown> {
         if (!this.clientRunning) {
             throw new Error("Client is not running");
         }
-        return this.clientWellKnownPromise!;
+        const wellKnown = await this.cachedWellKnown.wait();
+        return wellKnown!;
     }
 
     /**
@@ -6986,8 +6995,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             room_id: roomId,
             type: eventType,
             state_key: stateKey,
-            // Cast safety: StateEvents[K] is a stronger bound than IContent, which has [key: string]: any
-            content: content as IContent,
+            content,
         });
 
         await this.encryptStateEventIfNeeded(event, room ?? undefined);
@@ -7030,7 +7038,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // If the crypto impl thinks we shouldn't encrypt, then we shouldn't.
         // Safety: we checked the crypto impl exists above.
-        if (!(await this.cryptoBackend!.isStateEncryptionEnabledInRoom(room.roomId))) {
+        if (!(await this.cryptoBackend.isStateEncryptionEnabledInRoom(room.roomId))) {
             return;
         }
 

package/src/common-crypto/key-passphrase.ts

@@ -30,7 +30,7 @@ interface IAuthData {
  */
 export function keyFromAuthData(authData: IAuthData, passphrase: string): Promise<Uint8Array> {
     if (!authData.private_key_salt || !authData.private_key_iterations) {
-        throw new Error("Salt and/or iterations not found: " + "this backup cannot be restored with a passphrase");
+        throw new Error("Salt and/or iterations not found: this backup cannot be restored with a passphrase");
     }
 
     return deriveRecoveryKeyFromPassphrase(

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

@@ -590,7 +590,7 @@ const DB_MIGRATIONS: DbMigration[] = [
 export const VERSION = DB_MIGRATIONS.length;
 
 export function upgradeDatabase(db: IDBDatabase, oldVersion: number): void {
-    logger.log(`Upgrading IndexedDBCryptoStore from version ${oldVersion}` + ` to ${VERSION}`);
+    logger.log(`Upgrading IndexedDBCryptoStore from version ${oldVersion} to ${VERSION}`);
     DB_MIGRATIONS.forEach((migration, index) => {
         if (oldVersion <= index) migration(db);
     });
@@ -632,6 +632,7 @@ function promiseifyTxn<T>(txn: IDBTransaction): Promise<T | null> {
         txn.oncomplete = (): void => {
             if ((txn as IWrappedIDBTransaction)._mx_abortexception !== undefined) {
                 reject((txn as IWrappedIDBTransaction)._mx_abortexception);
+                return;
             }
             resolve(null);
         };

package/src/crypto/store/indexeddb-crypto-store.ts

@@ -199,9 +199,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
                     // in this db so we should use it or nothing at all.
                     throw new InvalidCryptoStoreError(InvalidCryptoStoreState.TooNew);
                 }
-                logger.warn(
-                    `unable to connect to indexeddb ${this.dbName}` + `: falling back to localStorage store: ${e}`,
-                );
+                logger.warn(`unable to connect to indexeddb ${this.dbName}: falling back to localStorage store: ${e}`);
 
                 try {
                     if (!(globalThis.localStorage instanceof Storage)) {

package/src/crypto/store/memory-crypto-store.ts

@@ -132,7 +132,7 @@ export class MemoryCryptoStore implements CryptoStore {
         func: (key: SecretStorePrivateKeys[K] | null) => void,
         type: K,
     ): void {
-        const result = this.privateKeys[type] as SecretStorePrivateKeys[K] | undefined;
+        const result = this.privateKeys[type];
         func(result || null);
     }
 

package/src/embedded.ts

@@ -32,7 +32,8 @@ import {
     UnstableApiVersion,
 } from "matrix-widget-api";
 
-import { MatrixEvent, type IEvent, type IContent, EventStatus } from "./models/event.ts";
+import { type Transport } from "./matrixrtc/index.ts";
+import { MatrixEvent, type IEvent, EventStatus } from "./models/event.ts";
 import {
     type ISendEventResponse,
     type SendDelayedEventRequestOpts,
@@ -137,6 +138,13 @@ export interface ICapabilities {
      * @defaultValue false
      */
     receiveSticky?: boolean;
+
+    /**
+     * Whether this client needs to be able to discover the RTC transports the host can reach.
+     * @experimental Part of MSC4515
+     * @defaultValue false
+     */
+    rtcTransports?: boolean;
 }
 
 export enum RoomWidgetClientEvent {
@@ -285,6 +293,9 @@ export class RoomWidgetClient extends MatrixClient {
         if (capabilities.turnServers) {
             this.widgetApi.requestCapability(MatrixCapabilities.MSC3846TurnServers);
         }
+        if (capabilities.rtcTransports) {
+            this.widgetApi.requestCapability(MatrixCapabilities.MSC4515RtcTransports);
+        }
     }
 
     public async supportUpdateState(): Promise<boolean> {
@@ -346,12 +357,9 @@ export class RoomWidgetClient extends MatrixClient {
             );
         }
 
-        if (opts.clientWellKnownPollPeriod !== undefined) {
-            this.clientWellKnownIntervalID = setInterval(() => {
-                this.fetchClientWellKnown();
-            }, 1000 * opts.clientWellKnownPollPeriod);
-            this.fetchClientWellKnown();
-        }
+        this.cachedWellKnown.start(
+            opts.clientWellKnownPollPeriod !== undefined ? 1000 * opts.clientWellKnownPollPeriod : undefined,
+        );
         this.setSyncState(SyncState.Syncing);
         logger.info("Finished initial sync");
 
@@ -408,7 +416,7 @@ export class RoomWidgetClient extends MatrixClient {
         // We need the additional as assertion for the EW linter to be happy.
         // It is not capable of implying the type based on the throw if `stickyDurationMs !== undefined && typeof stickyDurationMs !== "number"`
         // above
-        const stickyDurationMsAsNumber: number | undefined = stickyDurationMs as number | undefined;
+        const stickyDurationMsAsNumber: number | undefined = stickyDurationMs;
 
         // We need to extend the content with the redacts parameter
         // The js sdk uses event.redacts but the widget api uses event.content.redacts
@@ -622,6 +630,21 @@ export class RoomWidgetClient extends MatrixClient {
         };
     }
 
+    /**
+     * Returns a set of configured RTC transports supported by the homeserver.
+     *
+     * Overrides the homeserver-side {@link MatrixClient._unstable_getRTCTransports} (MSC4143):
+     * a widget cannot make authenticated homeserver calls itself, so we ask the host over the
+     * widget API instead (MSC4515). Requires the `rtcTransports` capability and a host that
+     * advertises the `org.matrix.msc4515` API version (otherwise the request throws).
+     */
+    public override async _unstable_getRTCTransports(): Promise<Transport[]> {
+        const { rtc_transports: rtcTransports } = await this.widgetApi
+            .getRtcTransports()
+            .catch(timeoutToConnectionError);
+        return rtcTransports;
+    }
+
     public async queueToDevice({ eventType, batch }: ToDeviceBatch): Promise<void> {
         // map: user Id → device Id → payload
         const contentMap: MapWithDefault<string, Map<string, ToDevicePayload>> = new MapWithDefault(() => new Map());
@@ -726,7 +749,7 @@ export class RoomWidgetClient extends MatrixClient {
         // Verify the room ID matches, since it's possible for the client to
         // send us events from other rooms if this widget is always on screen
         if (ev.detail.data.room_id === this.roomId) {
-            const event = new MatrixEvent(ev.detail.data as Partial<IEvent>);
+            const event = new MatrixEvent(ev.detail.data);
 
             // Only inject once we have update the txId
             await this.updateTxId(event);
@@ -768,7 +791,7 @@ export class RoomWidgetClient extends MatrixClient {
         const event = new MatrixEvent({
             type: ev.detail.data.type,
             sender: ev.detail.data.sender,
-            content: ev.detail.data.content as IContent,
+            content: ev.detail.data.content,
         });
         // Mark the event as encrypted if it was, using fake contents and keys since those are unknown to us
         if (ev.detail.data.encrypted) event.makeEncrypted(EventType.RoomMessageEncrypted, {}, "", "");
@@ -791,7 +814,7 @@ export class RoomWidgetClient extends MatrixClient {
             // send us state updates from other rooms if this widget is always
             // on screen
             if (rawEvent.room_id === this.roomId) {
-                const event = new MatrixEvent(rawEvent as Partial<IEvent>);
+                const event = new MatrixEvent(rawEvent);
 
                 if (this.syncApi instanceof SyncApi) {
                     await this.syncApi.injectRoomEvents(this.room!, undefined, [event]);

package/src/matrixrtc/MatrixRTCSession.ts

@@ -516,7 +516,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
                   )
                 : new MembershipManager(joinConfig, this.roomSubset, this.client, this.slotDescription, this.logger);
 
-            this.reEmitter.reEmit(this.membershipManager!, [
+            this.reEmitter.reEmit(this.membershipManager, [
                 MembershipManagerEvent.ProbablyLeft,
                 MembershipManagerEvent.StatusChanged,
                 MembershipManagerEvent.DelayIdChanged,
@@ -550,12 +550,12 @@ export class MatrixRTCSession extends TypedEventEmitter<
         this.pendingNotificationToSend = this.joinConfig?.notificationType;
 
         // Join!
-        this.membershipManager!.join(fociPreferred, multiSfuFocus, (e) => {
+        this.membershipManager.join(fociPreferred, multiSfuFocus, (e) => {
             this.logger.error("MembershipManager encountered an unrecoverable error: ", e);
             this.emit(MatrixRTCSessionEvent.MembershipManagerError, e);
             this.emit(MatrixRTCSessionEvent.JoinStateChanged, this.isJoined());
         });
-        this.encryptionManager!.join(joinConfig);
+        this.encryptionManager.join(joinConfig);
 
         this.emit(MatrixRTCSessionEvent.JoinStateChanged, true);
     }

package/src/matrixrtc/MembershipManager.ts

@@ -284,7 +284,7 @@ export class MembershipManager
             this.logger.warn("Missing own membership: force re-join");
             this.state.hasMemberStateEvent = false;
 
-            if (this.scheduler.actions.some((a) => sendingMembershipActions.includes(a.type as MembershipActionType))) {
+            if (this.scheduler.actions.some((a) => sendingMembershipActions.includes(a.type))) {
                 this.logger.error(
                     "tried adding another `SendDelayedEvent` actions even though we already have one in the Queue\nActionQueueOnMemberUpdate:",
                     this.scheduler.actions,

package/src/matrixrtc/MembershipManagerActionScheduler.ts

@@ -101,7 +101,7 @@ export class ActionScheduler {
                     );
                     try {
                         // `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);
+                        handlerResult = await this.membershipLoopHandler(nextAction.type);
                     } catch (e) {
                         // Preserve the original error as `cause`.
                         throw new Error(`The MembershipManager shut down because of the end condition: ${e}`, {

package/src/matrixrtc/RTCEncryptionManager.ts

@@ -342,7 +342,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
             })
             .map((membership) => {
                 return {
-                    userId: membership.sender!,
+                    userId: membership.sender,
                     deviceId: membership.deviceId,
                     membershipTs: membership.createdTs(),
                 };
@@ -446,7 +446,7 @@ export class RTCEncryptionManager implements IEncryptionManager {
 
     private nextKeyIndex(): number {
         if (this.outboundSession) {
-            return (this.outboundSession!.keyId + 1) % 256;
+            return (this.outboundSession.keyId + 1) % 256;
         }
         return 0;
     }

package/src/matrixrtc/ToDeviceKeyTransport.ts

@@ -88,8 +88,8 @@ export class ToDeviceKeyTransport
         const targets = members
             .map((member) => {
                 return {
-                    userId: member.userId!,
-                    deviceId: member.deviceId!,
+                    userId: member.userId,
+                    deviceId: member.deviceId,
                 };
             })
             // filter out me
@@ -137,7 +137,7 @@ export class ToDeviceKeyTransport
             // TODO userId this is claimed information, deviceId is claimed information
             {
                 userId: fromUser,
-                deviceId: content.member.claimed_device_id!,
+                deviceId: content.member.claimed_device_id,
                 memberId: content.member.id ?? hardcodedMemberIdAlternative,
             },
             content.keys.key,

package/src/matrixrtc/membershipData/rtc.ts

@@ -105,7 +105,7 @@ export const checkRtcMembershipData = (data: IContent, sender: string): data is
     } else {
         // validate that each transport has at least a string 'type'
         for (const t of data.transports.published) {
-            if (typeof t !== "object" || t === null || typeof (t as any).type !== "string") {
+            if (typeof t !== "object" || t === null || typeof t.type !== "string") {
                 errors.push(prefix + "transports.published entries must be objects with a string type");
                 break;
             }

package/src/matrixrtc/utils.ts

@@ -24,8 +24,6 @@ export class OutdatedKeyFilter {
     // Map of participantId -> keyIndex -> timestamp
     private tsBuffer: Map<EncryptionKeyMapKey, Map<number, number>> = new Map();
 
-    public constructor() {}
-
     /**
      * Check if there is a recent key with the same keyId (index) and then use the creationTS to decide what to
      * do with the key. If the key received is older than the one already in the buffer, it is ignored.

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

@@ -526,9 +526,9 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
                 // that would happen, so I'm going to ignore it for now.
                 //
                 if (existingTimeline == neighbour) {
-                    debuglog("Event " + eventId + " in neighbouring timeline - " + "switching to " + existingTimeline);
+                    debuglog("Event " + eventId + " in neighbouring timeline - switching to " + existingTimeline);
                 } else {
-                    debuglog("Event " + eventId + " already in a different " + "timeline " + existingTimeline);
+                    debuglog("Event " + eventId + " already in a different timeline " + existingTimeline);
                 }
                 timeline = existingTimeline;
                 continue;
@@ -582,7 +582,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             if (direction === EventTimeline.FORWARDS && timeline === this.liveTimeline) {
                 logger.warn({ lastEventWasNew, didUpdate }); // for debugging
                 logger.warn(
-                    `Refusing to set forwards pagination token of live timeline ` + `${timeline} to ${paginationToken}`,
+                    `Refusing to set forwards pagination token of live timeline ${timeline} to ${paginationToken}`,
                 );
                 return;
             }

package/src/models/event.ts

@@ -436,17 +436,17 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         // of space if we don't intern it.
         (["state_key", "type", "sender", "room_id", "membership"] as const).forEach((prop) => {
             if (typeof event[prop] !== "string") return;
-            event[prop] = internaliseString(event[prop]!);
+            event[prop] = internaliseString(event[prop]);
         });
 
         (["membership", "avatar_url", "displayname"] as const).forEach((prop) => {
             if (typeof event.content?.[prop] !== "string") return;
-            event.content[prop] = internaliseString(event.content[prop]!);
+            event.content[prop] = internaliseString(event.content[prop]);
         });
 
         (["rel_type"] as const).forEach((prop) => {
             if (typeof event.content?.["m.relates_to"]?.[prop] !== "string") return;
-            event.content["m.relates_to"][prop] = internaliseString(event.content["m.relates_to"][prop]!);
+            event.content["m.relates_to"][prop] = internaliseString(event.content["m.relates_to"][prop]);
         });
 
         this.txnId = event.txn_id;
@@ -827,7 +827,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
         // if this is a state event, pack cleartext type and statekey
         if (this.isState()) {
-            this.event.state_key = `${this.clearEvent!.type}:${this.clearEvent!.state_key}`;
+            this.event.state_key = `${this.clearEvent.type}:${this.clearEvent.state_key}`;
         }
     }
 
@@ -948,7 +948,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
                 this.setClearData(res);
                 this._decryptionFailureReason = null;
             } catch (e) {
-                const detailedError = e instanceof DecryptionError ? (<DecryptionError>e).detailedString : String(e);
+                const detailedError = e instanceof DecryptionError ? e.detailedString : String(e);
 
                 err = e as Error;
 
@@ -981,7 +981,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
                 this.setClearDataForDecryptionFailure(String(e));
                 this._decryptionFailureReason =
-                    e instanceof DecryptionError ? (<DecryptionError>e).code : DecryptionFailureCode.UNKNOWN_ERROR;
+                    e instanceof DecryptionError ? e.code : DecryptionFailureCode.UNKNOWN_ERROR;
             }
 
             // Make sure we clear 'decryptionPromise' before sending the 'Event.decrypted' event,
@@ -1254,10 +1254,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
             this.clearEvent = undefined;
         }
 
-        const keeps =
-            this.getType() in REDACT_KEEP_CONTENT_MAP
-                ? REDACT_KEEP_CONTENT_MAP[this.getType() as keyof typeof REDACT_KEEP_CONTENT_MAP]
-                : {};
+        const keeps = this.getType() in REDACT_KEEP_CONTENT_MAP ? REDACT_KEEP_CONTENT_MAP[this.getType()] : {};
         const content = this.getContent();
         for (const key in content) {
             if (content.hasOwnProperty(key) && !keeps[key]) {

package/src/models/invites-ignorer.ts

@@ -252,7 +252,7 @@ export class IgnoredInvites {
             // `sources` could contain non-string / invalid room ids
             .filter((roomId) => typeof roomId === "string")
             .map((roomId) => this.client.getRoom(roomId))
-            .filter((room) => !!room) as Room[];
+            .filter((room) => !!room);
         if (sourceRooms.length != sources.length) {
             hasChanges = true;
         }

package/src/models/poll.ts

@@ -176,7 +176,7 @@ export class Poll extends TypedEventEmitter<Exclude<PollEvent, PollEvent.New>, P
 
         const responses =
             this.responses ||
-            new Relations("m.reference", M_POLL_RESPONSE.name, this.matrixClient, [M_POLL_RESPONSE.altName!]);
+            new Relations("m.reference", M_POLL_RESPONSE.name, this.matrixClient, [M_POLL_RESPONSE.altName]);
 
         const pollEndEvent = allRelations.events.find((event) => M_POLL_END.matches(event.getType()));
 

package/src/models/read-receipt.ts

@@ -325,7 +325,7 @@ export abstract class ReadReceipt<
         }
         this.receiptCacheByEventId.get(eventId)!.push({
             userId: userId,
-            type: receiptType as ReceiptType,
+            type: receiptType,
             data: receipt,
         });
     }