From 25296bb4863168d054d74877f9520f8130cd2402 Mon Sep 17 00:00:00 2001
From: Michael Weimann <michaelw@matrix.org>
Date: Tue, 29 Nov 2022 19:38:38 +0100
Subject: [PATCH 01/60] Update @typescript-eslint/parser (#2917)

---
 yarn.lock | 52 +++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 43 insertions(+), 9 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index 67c5baeb430..d39f27e5162 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1741,13 +1741,13 @@
     tsutils "^3.21.0"
 
 "@typescript-eslint/parser@^5.6.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.43.0.tgz#9c86581234b88f2ba406f0b99a274a91c11630fd"
-  integrity sha512-2iHUK2Lh7PwNUlhFxxLI2haSDNyXvebBO9izhjhMoDC+S3XI9qt2DGFUsiJ89m2k7gGYch2aEpYqV5F/+nwZug==
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.45.0.tgz#b18a5f6b3cf1c2b3e399e9d2df4be40d6b0ddd0e"
+  integrity sha512-brvs/WSM4fKUmF5Ot/gEve6qYiCMjm6w4HkHPfS6ZNmxTS0m0iNN4yOChImaCkqc1hRwFGqUyanMXuGal6oyyQ==
   dependencies:
-    "@typescript-eslint/scope-manager" "5.43.0"
-    "@typescript-eslint/types" "5.43.0"
-    "@typescript-eslint/typescript-estree" "5.43.0"
+    "@typescript-eslint/scope-manager" "5.45.0"
+    "@typescript-eslint/types" "5.45.0"
+    "@typescript-eslint/typescript-estree" "5.45.0"
     debug "^4.3.4"
 
 "@typescript-eslint/scope-manager@5.43.0":
@@ -1758,6 +1758,14 @@
     "@typescript-eslint/types" "5.43.0"
     "@typescript-eslint/visitor-keys" "5.43.0"
 
+"@typescript-eslint/scope-manager@5.45.0":
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.45.0.tgz#7a4ac1bfa9544bff3f620ab85947945938319a96"
+  integrity sha512-noDMjr87Arp/PuVrtvN3dXiJstQR1+XlQ4R1EvzG+NMgXi8CuMCXpb8JqNtFHKceVSQ985BZhfRdowJzbv4yKw==
+  dependencies:
+    "@typescript-eslint/types" "5.45.0"
+    "@typescript-eslint/visitor-keys" "5.45.0"
+
 "@typescript-eslint/type-utils@5.43.0":
   version "5.43.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.43.0.tgz#91110fb827df5161209ecca06f70d19a96030be6"
@@ -1773,6 +1781,11 @@
   resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.43.0.tgz#e4ddd7846fcbc074325293515fa98e844d8d2578"
   integrity sha512-jpsbcD0x6AUvV7tyOlyvon0aUsQpF8W+7TpJntfCUWU1qaIKu2K34pMwQKSzQH8ORgUrGYY6pVIh1Pi8TNeteg==
 
+"@typescript-eslint/types@5.45.0":
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.45.0.tgz#794760b9037ee4154c09549ef5a96599621109c5"
+  integrity sha512-QQij+u/vgskA66azc9dCmx+rev79PzX8uDHpsqSjEFtfF2gBUTRCpvYMh2gw2ghkJabNkPlSUCimsyBEQZd1DA==
+
 "@typescript-eslint/typescript-estree@5.43.0":
   version "5.43.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.43.0.tgz#b6883e58ba236a602c334be116bfc00b58b3b9f2"
@@ -1786,6 +1799,19 @@
     semver "^7.3.7"
     tsutils "^3.21.0"
 
+"@typescript-eslint/typescript-estree@5.45.0":
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.45.0.tgz#f70a0d646d7f38c0dfd6936a5e171a77f1e5291d"
+  integrity sha512-maRhLGSzqUpFcZgXxg1qc/+H0bT36lHK4APhp0AEUVrpSwXiRAomm/JGjSG+kNUio5kAa3uekCYu/47cnGn5EQ==
+  dependencies:
+    "@typescript-eslint/types" "5.45.0"
+    "@typescript-eslint/visitor-keys" "5.45.0"
+    debug "^4.3.4"
+    globby "^11.1.0"
+    is-glob "^4.0.3"
+    semver "^7.3.7"
+    tsutils "^3.21.0"
+
 "@typescript-eslint/utils@5.43.0":
   version "5.43.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.43.0.tgz#00fdeea07811dbdf68774a6f6eacfee17fcc669f"
@@ -1808,6 +1834,14 @@
     "@typescript-eslint/types" "5.43.0"
     eslint-visitor-keys "^3.3.0"
 
+"@typescript-eslint/visitor-keys@5.45.0":
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.45.0.tgz#e0d160e9e7fdb7f8da697a5b78e7a14a22a70528"
+  integrity sha512-jc6Eccbn2RtQPr1s7th6jJWQHBHI6GBVQkCHoJFQ5UreaKm59Vxw+ynQUPPY2u2Amquc+7tmEoC2G52ApsGNNg==
+  dependencies:
+    "@typescript-eslint/types" "5.45.0"
+    eslint-visitor-keys "^3.3.0"
+
 JSONStream@^1.0.3:
   version "1.3.5"
   resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
@@ -3963,9 +3997,9 @@ ieee754@^1.1.4:
   integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
 
 ignore@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.0.tgz#6d3bac8fa7fe0d45d9f9be7bac2fc279577e345a"
-  integrity sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==
+  version "5.2.1"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.1.tgz#c2b1f76cb999ede1502f3a226a9310fdfe88d46c"
+  integrity sha512-d2qQLzTJ9WxQftPAuEQpSPmKqzxePjzVbpAVv62AQ64NTL+wR4JkrVqR/LqFsFEUsHDAiId52mJteHDFuDkElA==
 
 import-fresh@^3.0.0, import-fresh@^3.2.1:
   version "3.3.0"

From 6611cfa2537ef14ce8c8f7d76a45dad4a4e26167 Mon Sep 17 00:00:00 2001
From: Marco Bartelt <marco.bartelt94@gmail.com>
Date: Tue, 29 Nov 2022 20:23:57 +0100
Subject: [PATCH 02/60] add-privileged-users-in-room (#2892)

---
 spec/integ/matrix-client-methods.spec.ts | 47 +++++++++++++++---------
 src/client.ts                            | 18 ++++++---
 2 files changed, 41 insertions(+), 24 deletions(-)

diff --git a/spec/integ/matrix-client-methods.spec.ts b/spec/integ/matrix-client-methods.spec.ts
index 5508ceaf031..f2ff9e6df77 100644
--- a/spec/integ/matrix-client-methods.spec.ts
+++ b/spec/integ/matrix-client-methods.spec.ts
@@ -1337,27 +1337,38 @@ describe("MatrixClient", function() {
         });
     });
 
-    describe("registerWithIdentityServer", () => {
-        it("should pass data to POST request", async () => {
-            const token = {
-                access_token: "access_token",
-                token_type: "Bearer",
-                matrix_server_name: "server_name",
-                expires_in: 12345,
-            };
+    describe("setPowerLevel", () => {
+        it.each([
+            {
+                userId: "alice@localhost",
+                expectation: {
+                    "alice@localhost": 100,
+                },
+            },
+            {
+                userId: ["alice@localhost", "bob@localhost"],
+                expectation: {
+                    "alice@localhost": 100,
+                    "bob@localhost": 100,
+                },
+            },
+        ])("should modify power levels of $userId correctly", async ({ userId, expectation }) => {
+            const event = {
+                getType: () => "m.room.power_levels",
+                getContent: () => ({
+                    users: {
+                        "alice@localhost": 50,
+                    },
+                }),
+            } as MatrixEvent;
 
-            httpBackend!.when("POST", "/account/register").check(req => {
-                expect(req.data).toStrictEqual(token);
-            }).respond(200, {
-                access_token: "at",
-                token: "tt",
-            });
+            httpBackend!.when("PUT", "/state/m.room.power_levels").check(req => {
+                expect(req.data.users).toStrictEqual(expectation);
+            }).respond(200, {});
 
-            const prom = client!.registerWithIdentityServer(token);
+            const prom = client!.setPowerLevel("!room_id:server", userId, 100, event);
             await httpBackend!.flushAllExpected();
-            const resp = await prom;
-            expect(resp.access_token).toBe("at");
-            expect(resp.token).toBe("tt");
+            await prom;
         });
     });
 });
diff --git a/src/client.ts b/src/client.ts
index b091a31ec45..d8bb110630f 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -3795,9 +3795,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * Set a user's power level.
+     * Set a power level to one or multiple users.
      * @param {string} roomId
-     * @param {string} userId
+     * @param {string|string[]} userId
      * @param {Number} powerLevel
      * @param {MatrixEvent} event
      * @return {Promise} Resolves: to an ISendEventResponse object
@@ -3805,19 +3805,25 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public setPowerLevel(
         roomId: string,
-        userId: string,
+        userId: string | string[],
         powerLevel: number,
         event: MatrixEvent,
     ): Promise<ISendEventResponse> {
         let content = {
-            users: {},
+            users: {} as Record<string, number>,
         };
-        if (event?.getType() === EventType.RoomPowerLevels) {
+        if (event.getType() === EventType.RoomPowerLevels) {
             // take a copy of the content to ensure we don't corrupt
             // existing client state with a failed power level change
             content = utils.deepCopy(event.getContent());
         }
-        content.users[userId] = powerLevel;
+        if (Array.isArray(userId)) {
+            for (const user of userId) {
+                content.users[user] = powerLevel;
+            }
+        } else {
+            content.users[userId] = powerLevel;
+        }
         const path = utils.encodeUri("/rooms/$roomId/state/m.room.power_levels", {
             $roomId: roomId,
         });

From e0df53c2ed109fa97246303bbf10998d60de22ac Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 30 Nov 2022 01:11:32 +0000
Subject: [PATCH 03/60] Update dependency terser to v5.16.0 (#2919)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 yarn.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index d39f27e5162..f13f2de890e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6530,9 +6530,9 @@ tapable@^2.2.0:
   integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
 
 terser@^5.5.1:
-  version "5.15.1"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-5.15.1.tgz#8561af6e0fd6d839669c73b92bdd5777d870ed6c"
-  integrity sha512-K1faMUvpm/FBxjBXud0LWVAGxmvoPbZbfTCYbSgaaYQaIXI3/TdI7a7ZGA73Zrou6Q8Zmz3oeUTsp/dj+ag2Xw==
+  version "5.16.0"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.16.0.tgz#29362c6f5506e71545c73b069ccd199bb28f7f54"
+  integrity sha512-KjTV81QKStSfwbNiwlBXfcgMcOloyuRdb62/iLFPGBcVNF4EXjhdYBhYHmbJpiBrVxZhDvltE11j+LBQUxEEJg==
   dependencies:
     "@jridgewell/source-map" "^0.3.2"
     acorn "^8.5.0"

From 3577aa98b593915dd7092092835ea6e48959d84f Mon Sep 17 00:00:00 2001
From: Germain <germains@element.io>
Date: Wed, 30 Nov 2022 07:58:29 +0000
Subject: [PATCH 04/60] Fix synthesizeReceipt (#2916)

---
 spec/unit/notifications.spec.ts | 24 +++++++++++++++++++++--
 spec/unit/read-receipt.spec.ts  | 17 +++++++++++++++++
 src/client.ts                   | 23 ++++++++++++----------
 src/models/read-receipt.ts      |  2 +-
 src/models/room.ts              | 34 +++++++++++++++++++++++++--------
 src/models/thread.ts            | 14 +++++++++++++-
 6 files changed, 92 insertions(+), 22 deletions(-)

diff --git a/spec/unit/notifications.spec.ts b/spec/unit/notifications.spec.ts
index def7ef820cd..d7936014b7d 100644
--- a/spec/unit/notifications.spec.ts
+++ b/spec/unit/notifications.spec.ts
@@ -37,7 +37,7 @@ let event: MatrixEvent;
 let threadEvent: MatrixEvent;
 
 const ROOM_ID = "!roomId:example.org";
-let THREAD_ID;
+let THREAD_ID: string;
 
 function mkPushAction(notify, highlight): IActionsObject {
     return {
@@ -76,7 +76,7 @@ describe("fixNotificationCountOnDecryption", () => {
             event: true,
         }, mockClient);
 
-        THREAD_ID = event.getId();
+        THREAD_ID = event.getId()!;
         threadEvent = mkEvent({
             type: EventType.RoomMessage,
             content: {
@@ -108,6 +108,16 @@ describe("fixNotificationCountOnDecryption", () => {
         expect(room.getUnreadNotificationCount(NotificationCountType.Highlight)).toBe(1);
     });
 
+    it("does not change the room count when there's no unread count", () => {
+        room.setUnreadNotificationCount(NotificationCountType.Total, 0);
+        room.setUnreadNotificationCount(NotificationCountType.Highlight, 0);
+
+        fixNotificationCountOnDecryption(mockClient, event);
+
+        expect(room.getRoomUnreadNotificationCount(NotificationCountType.Total)).toBe(0);
+        expect(room.getRoomUnreadNotificationCount(NotificationCountType.Highlight)).toBe(0);
+    });
+
     it("changes the thread count to highlight on decryption", () => {
         expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total)).toBe(1);
         expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight)).toBe(0);
@@ -118,6 +128,16 @@ describe("fixNotificationCountOnDecryption", () => {
         expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight)).toBe(1);
     });
 
+    it("does not change the room count when there's no unread count", () => {
+        room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total, 0);
+        room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight, 0);
+
+        fixNotificationCountOnDecryption(mockClient, event);
+
+        expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total)).toBe(0);
+        expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight)).toBe(0);
+    });
+
     it("emits events", () => {
         const cb = jest.fn();
         room.on(RoomEvent.UnreadNotifications, cb);
diff --git a/spec/unit/read-receipt.spec.ts b/spec/unit/read-receipt.spec.ts
index 2a3fbd87bcc..4443c25befc 100644
--- a/spec/unit/read-receipt.spec.ts
+++ b/spec/unit/read-receipt.spec.ts
@@ -20,6 +20,7 @@ import { MAIN_ROOM_TIMELINE, ReceiptType } from '../../src/@types/read_receipts'
 import { MatrixClient } from "../../src/client";
 import { Feature, ServerSupport } from '../../src/feature';
 import { EventType } from '../../src/matrix';
+import { synthesizeReceipt } from '../../src/models/read-receipt';
 import { encodeUri } from '../../src/utils';
 import * as utils from "../test-utils/test-utils";
 
@@ -175,4 +176,20 @@ describe("Read receipt", () => {
             await flushPromises();
         });
     });
+
+    describe("synthesizeReceipt", () => {
+        it.each([
+            { event: roomEvent, destinationId: MAIN_ROOM_TIMELINE },
+            { event: threadEvent, destinationId: threadEvent.threadRootId! },
+        ])("adds the receipt to $destinationId", ({ event, destinationId }) => {
+            const userId = "@bob:example.org";
+            const receiptType = ReceiptType.Read;
+
+            const fakeReadReceipt = synthesizeReceipt(userId, event, receiptType);
+
+            const content = fakeReadReceipt.getContent()[event.getId()!][receiptType][userId];
+
+            expect(content.thread_id).toEqual(destinationId);
+        });
+    });
 });
diff --git a/src/client.ts b/src/client.ts
index d8bb110630f..8b8fa18c315 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -5836,8 +5836,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             ).then(async (res) => {
                 const mapper = this.getEventMapper();
                 const matrixEvents = res.chunk.map(mapper);
-                for (const event of matrixEvents) {
-                    await eventTimeline.getTimelineSet()?.thread?.processEvent(event);
+
+                // Process latest events first
+                for (const event of matrixEvents.slice().reverse()) {
+                    await thread?.processEvent(event);
+                    const sender = event.getSender()!;
+                    if (!backwards || thread?.getEventReadUpTo(sender) === null) {
+                        room.addLocalEchoReceipt(sender, event, ReceiptType.Read);
+                    }
                 }
 
                 const newToken = res.next_batch;
@@ -9344,19 +9350,16 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
     if (!room || !cli.getUserId()) return;
 
     const isThreadEvent = !!event.threadRootId && !event.isThreadRoot;
-    const currentCount = (isThreadEvent
-        ? room.getThreadUnreadNotificationCount(
-            event.threadRootId,
-            NotificationCountType.Highlight,
-        )
-        : room.getUnreadNotificationCount(NotificationCountType.Highlight)) ?? 0;
+
+    const totalCount = room.getUnreadCountForEventContext(NotificationCountType.Total, event);
+    const currentCount = room.getUnreadCountForEventContext(NotificationCountType.Highlight, event);
 
     // Ensure the unread counts are kept up to date if the event is encrypted
     // We also want to make sure that the notification count goes up if we already
     // have encrypted events to avoid other code from resetting 'highlight' to zero.
     const oldHighlight = !!oldActions?.tweaks?.highlight;
     const newHighlight = !!actions?.tweaks?.highlight;
-    if (oldHighlight !== newHighlight || currentCount > 0) {
+    if ((oldHighlight !== newHighlight || currentCount > 0) && totalCount > 0) {
         // TODO: Handle mentions received while the client is offline
         // See also https://github.com/vector-im/element-web/issues/9069
         const hasReadEvent = isThreadEvent
@@ -9381,7 +9384,7 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
             // Fix 'Mentions Only' rooms from not having the right badge count
             const totalCount = (isThreadEvent
                 ? room.getThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Total)
-                : room.getUnreadNotificationCount(NotificationCountType.Total)) ?? 0;
+                : room.getRoomUnreadNotificationCount(NotificationCountType.Total)) ?? 0;
 
             if (totalCount < newCount) {
                 if (isThreadEvent) {
diff --git a/src/models/read-receipt.ts b/src/models/read-receipt.ts
index 3d78991478f..391cd98117e 100644
--- a/src/models/read-receipt.ts
+++ b/src/models/read-receipt.ts
@@ -33,7 +33,7 @@ export function synthesizeReceipt(userId: string, event: MatrixEvent, receiptTyp
                 [receiptType]: {
                     [userId]: {
                         ts: event.getTs(),
-                        threadId: event.threadRootId ?? MAIN_ROOM_TIMELINE,
+                        thread_id: event.threadRootId ?? MAIN_ROOM_TIMELINE,
                     },
                 },
             },
diff --git a/src/models/room.ts b/src/models/room.ts
index 0d16940273e..de3d18733de 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -1183,7 +1183,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      *                  for this type.
      */
     public getUnreadNotificationCount(type = NotificationCountType.Total): number {
-        let count = this.notificationCounts[type] ?? 0;
+        let count = this.getRoomUnreadNotificationCount(type);
         if (this.client.canSupport.get(Feature.ThreadUnreadNotifications) !== ServerSupport.Unsupported) {
             for (const threadNotification of this.threadNotifications.values()) {
                 count += threadNotification[type] ?? 0;
@@ -1192,6 +1192,27 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         return count;
     }
 
+    /**
+     * Get the notification for the event context (room or thread timeline)
+     */
+    public getUnreadCountForEventContext(type = NotificationCountType.Total, event: MatrixEvent): number {
+        const isThreadEvent = !!event.threadRootId && !event.isThreadRoot;
+
+        return (isThreadEvent
+            ? this.getThreadUnreadNotificationCount(event.threadRootId, type)
+            : this.getRoomUnreadNotificationCount(type)) ?? 0;
+    }
+
+    /**
+     * Get one of the notification counts for this room
+     * @param {String} type The type of notification count to get. default: 'total'
+     * @return {Number} The notification count, or undefined if there is no count
+     *                  for this type.
+     */
+    public getRoomUnreadNotificationCount(type = NotificationCountType.Total): number {
+        return this.notificationCounts[type] ?? 0;
+    }
+
     /**
      * @experimental
      * Get one of the notification counts for a thread
@@ -1758,20 +1779,17 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             let latestMyThreadsRootEvent: MatrixEvent | undefined;
             const roomState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);
             for (const rootEvent of threadRoots) {
-                this.threadsTimelineSets[0]?.addLiveEvent(rootEvent, {
+                const opts = {
                     duplicateStrategy: DuplicateStrategy.Ignore,
                     fromCache: false,
                     roomState,
-                });
+                };
+                this.threadsTimelineSets[0]?.addLiveEvent(rootEvent, opts);
 
                 const threadRelationship = rootEvent
                     .getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
                 if (threadRelationship?.current_user_participated) {
-                    this.threadsTimelineSets[1]?.addLiveEvent(rootEvent, {
-                        duplicateStrategy: DuplicateStrategy.Ignore,
-                        fromCache: false,
-                        roomState,
-                    });
+                    this.threadsTimelineSets[1]?.addLiveEvent(rootEvent, opts);
                     latestMyThreadsRootEvent = rootEvent;
                 }
             }
diff --git a/src/models/thread.ts b/src/models/thread.ts
index 5abe63d6c2f..8c9826c35ec 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -123,7 +123,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         this.room.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
         this.room.on(RoomEvent.Redaction, this.onRedaction);
         this.room.on(RoomEvent.LocalEchoUpdated, this.onEcho);
-        this.timelineSet.on(RoomEvent.Timeline, this.onEcho);
+        this.timelineSet.on(RoomEvent.Timeline, this.onTimelineEvent);
 
         // even if this thread is thought to be originating from this client, we initialise it as we may be in a
         // gappy sync and a thread around this event may already exist.
@@ -192,6 +192,18 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         }
     };
 
+    private onTimelineEvent = (
+        event: MatrixEvent,
+        room: Room | undefined,
+        toStartOfTimeline: boolean | undefined,
+    ): void => {
+        // Add a synthesized receipt when paginating forward in the timeline
+        if (!toStartOfTimeline) {
+            room!.addLocalEchoReceipt(event.getSender()!, event, ReceiptType.Read);
+        }
+        this.onEcho(event);
+    };
+
     private onEcho = async (event: MatrixEvent): Promise<void> => {
         if (event.threadRootId !== this.id) return; // ignore echoes for other timelines
         if (this.lastEvent === event) return;

From 8d6d262e5fa75f2e69db0d4dd0977262800cf4af Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 30 Nov 2022 09:27:23 +0000
Subject: [PATCH 05/60] Update CODEOWNERS (#2918)

---
 .github/CODEOWNERS | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index f28b852a788..dd0bfc9ebfa 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,4 +1,6 @@
-* @matrix-org/element-web
-
-/src/webrtc @matrix-org/element-call-reviewers
-/spec/*/webrtc @matrix-org/element-call-reviewers
+*                         @matrix-org/element-web
+/.github/workflows/**     @matrix-org/element-web-app-team
+/package.json             @matrix-org/element-web-app-team
+/yarn.lock                @matrix-org/element-web-app-team
+/src/webrtc               @matrix-org/element-call-reviewers
+/spec/*/webrtc            @matrix-org/element-call-reviewers

From 1606274c36008b6a976a5e4b47cdd13a1e4e5997 Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Wed, 30 Nov 2022 10:53:38 +0000
Subject: [PATCH 06/60] Process `m.room.encryption` events before emitting
 `RoomMember` events (#2914)

vector-im/element-web#23819 is an intermittent failure to correctly initiate a user verification process. The
root cause is as follows:

* In matrix-react-sdk, ensureDMExists tries to create an encrypted DM room, and assumes it is ready for use
  (including sending encrypted events) as soon as it receives a RoomStateEvent.NewMember notification
  indicating that the other user has been invited or joined.

* However, in sync.ts, we process the membership events in a /sync response (including emitting
  RoomStateEvent.NewMember notifications), which is long before we process any m.room.encryption event.

* The upshot is that we can end up trying to send an encrypted event in the new room before processing
  the m.room.encryption event, which causes the crypto layer to blow up with an error of "Room was
  previously configured to use encryption, but is no longer".

Strictly speaking, ensureDMExists probably ought to be listening for ClientEvent.Room as well as RoomStateEvent.NewMember; but that doesn't help us, because ClientEvent.Room is also emitted
before we process the crypto event.

So, we need to process the crypto event before we start emitting these other events; but a corollary of that
is that we need to do so before we store the new room in the client's store. That makes things tricky, because
currently the crypto layer expects the room to have been stored in the client first.

So... we have to rearrange everything to pass the newly-created Room object into the crypto layer, rather than
just the room id, so that it doesn't need to rely on getting the Room from the client's store.
---
 spec/integ/megolm-integ.spec.ts | 110 ++++++++++++++++++++++++++++++--
 spec/test-utils/test-utils.ts   |  24 ++++---
 spec/unit/crypto.spec.ts        |  45 +++++++++++++
 src/crypto/index.ts             |  90 +++++++++++++++++---------
 src/sliding-sync-sdk.ts         |   2 +-
 src/sync.ts                     |  32 +++++-----
 6 files changed, 243 insertions(+), 60 deletions(-)

diff --git a/spec/integ/megolm-integ.spec.ts b/spec/integ/megolm-integ.spec.ts
index a4891b702f6..89c06426617 100644
--- a/spec/integ/megolm-integ.spec.ts
+++ b/spec/integ/megolm-integ.spec.ts
@@ -21,16 +21,19 @@ import * as testUtils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
 import { logger } from "../../src/logger";
 import {
+    IClaimOTKsResult,
     IContent,
+    IDownloadKeyResult,
     IEvent,
-    IClaimOTKsResult,
     IJoinedRoom,
+    IndexedDBCryptoStore,
     ISyncResponse,
-    IDownloadKeyResult,
+    IUploadKeysRequest,
     MatrixEvent,
     MatrixEventEvent,
-    IndexedDBCryptoStore,
     Room,
+    RoomMember,
+    RoomStateEvent,
 } from "../../src/matrix";
 import { IDeviceKeys } from "../../src/crypto/dehydration";
 import { DeviceInfo } from "../../src/crypto/deviceinfo";
@@ -327,7 +330,9 @@ describe("megolm", () => {
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
         const event = room.getLiveTimeline().getEvents()[0];
         expect(event.isEncrypted()).toBe(true);
-        const decryptedEvent = await testUtils.awaitDecryption(event);
+
+        // it probably won't be decrypted yet, because it takes a while to process the olm keys
+        const decryptedEvent = await testUtils.awaitDecryption(event, { waitOnDecryptionFailure: true });
         expect(decryptedEvent.getContent().body).toEqual('42');
     });
 
@@ -873,7 +878,12 @@ describe("megolm", () => {
 
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
         await room.decryptCriticalEvents();
-        expect(room.getLiveTimeline().getEvents()[0].getContent().body).toEqual('42');
+
+        // it probably won't be decrypted yet, because it takes a while to process the olm keys
+        const decryptedEvent = await testUtils.awaitDecryption(
+            room.getLiveTimeline().getEvents()[0], { waitOnDecryptionFailure: true },
+        );
+        expect(decryptedEvent.getContent().body).toEqual('42');
 
         const exported = await aliceTestClient.client.exportRoomKeys();
 
@@ -1012,7 +1022,9 @@ describe("megolm", () => {
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
         const event = room.getLiveTimeline().getEvents()[0];
         expect(event.isEncrypted()).toBe(true);
-        const decryptedEvent = await testUtils.awaitDecryption(event);
+
+        // it probably won't be decrypted yet, because it takes a while to process the olm keys
+        const decryptedEvent = await testUtils.awaitDecryption(event, { waitOnDecryptionFailure: true });
         expect(decryptedEvent.getRoomId()).toEqual(ROOM_ID);
         expect(decryptedEvent.getContent()).toEqual({});
         expect(decryptedEvent.getClearContent()).toBeUndefined();
@@ -1364,4 +1376,90 @@ describe("megolm", () => {
 
         await beccaTestClient.stop();
     });
+
+    it("allows sending an encrypted event as soon as room state arrives", async () => {
+        /* Empirically, clients expect to be able to send encrypted events as soon as the
+         * RoomStateEvent.NewMember notification is emitted, so test that works correctly.
+         */
+        const testRoomId = "!testRoom:id";
+        await aliceTestClient.start();
+
+        aliceTestClient.httpBackend.when("POST", "/keys/query")
+            .respond(200, function(_path, content: IUploadKeysRequest) {
+                return { device_keys: {} };
+            });
+
+        /* Alice makes the /createRoom call */
+        aliceTestClient.httpBackend.when("POST", "/createRoom")
+            .respond(200, { room_id: testRoomId });
+        await Promise.all([
+            aliceTestClient.client.createRoom({
+                initial_state: [{
+                    type: 'm.room.encryption',
+                    state_key: '',
+                    content: { algorithm: 'm.megolm.v1.aes-sha2' },
+                }],
+            }),
+            aliceTestClient.httpBackend.flushAllExpected(),
+        ]);
+
+        /* The sync arrives in two parts; first the m.room.create... */
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+            rooms: { join: {
+                [testRoomId]: {
+                    timeline: { events: [
+                        {
+                            type: 'm.room.create',
+                            state_key: '',
+                            event_id: "$create",
+                        },
+                        {
+                            type: 'm.room.member',
+                            state_key: aliceTestClient.getUserId(),
+                            content: { membership: "join" },
+                            event_id: "$alijoin",
+                        },
+                    ] },
+                },
+            } },
+        });
+        await aliceTestClient.flushSync();
+
+        // ... and then the e2e event and an invite ...
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+            rooms: { join: {
+                [testRoomId]: {
+                    timeline: { events: [
+                        {
+                            type: 'm.room.encryption',
+                            state_key: '',
+                            content: { algorithm: 'm.megolm.v1.aes-sha2' },
+                            event_id: "$e2e",
+                        },
+                        {
+                            type: 'm.room.member',
+                            state_key: "@other:user",
+                            content: { membership: "invite" },
+                            event_id: "$otherinvite",
+                        },
+                    ] },
+                },
+            } },
+        });
+
+        // as soon as the roomMember arrives, try to send a message
+        aliceTestClient.client.on(RoomStateEvent.NewMember, (_e, _s, member: RoomMember) => {
+            if (member.userId == "@other:user") {
+                aliceTestClient.client.sendMessage(testRoomId, { msgtype: "m.text", body: "Hello, World" });
+            }
+        });
+
+        // flush the sync and wait for the /send/ request.
+        aliceTestClient.httpBackend.when("PUT", "/send/m.room.encrypted/")
+            .respond(200, (_path, _content) => ({ event_id: "asdfgh" }));
+        await Promise.all([
+            aliceTestClient.flushSync(),
+            aliceTestClient.httpBackend.flush("/send/m.room.encrypted/", 1),
+        ]);
+    });
 });
diff --git a/spec/test-utils/test-utils.ts b/spec/test-utils/test-utils.ts
index af87ebbe64f..21ae4d18bad 100644
--- a/spec/test-utils/test-utils.ts
+++ b/spec/test-utils/test-utils.ts
@@ -362,22 +362,28 @@ export class MockStorageApi {
  * @param {MatrixEvent} event
  * @returns {Promise} promise which resolves (to `event`) when the event has been decrypted
  */
-export async function awaitDecryption(event: MatrixEvent): Promise<MatrixEvent> {
+export async function awaitDecryption(
+    event: MatrixEvent, { waitOnDecryptionFailure = false } = {},
+): Promise<MatrixEvent> {
     // An event is not always decrypted ahead of time
     // getClearContent is a good signal to know whether an event has been decrypted
     // already
     if (event.getClearContent() !== null) {
-        return event;
+        if (waitOnDecryptionFailure && event.isDecryptionFailure()) {
+            logger.log(`${Date.now()} event ${event.getId()} got decryption error; waiting`);
+        } else {
+            return event;
+        }
     } else {
-        logger.log(`${Date.now()} event ${event.getId()} is being decrypted; waiting`);
+        logger.log(`${Date.now()} event ${event.getId()} is not yet decrypted; waiting`);
+    }
 
-        return new Promise((resolve) => {
-            event.once(MatrixEventEvent.Decrypted, (ev) => {
-                logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
-                resolve(ev);
-            });
+    return new Promise((resolve) => {
+        event.once(MatrixEventEvent.Decrypted, (ev) => {
+            logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
+            resolve(ev);
         });
-    }
+    });
 }
 
 export const emitPromise = (e: EventEmitter, k: string): Promise<any> => new Promise(r => e.once(k, r));
diff --git a/spec/unit/crypto.spec.ts b/spec/unit/crypto.spec.ts
index e8a95370c61..68c8264b6f8 100644
--- a/spec/unit/crypto.spec.ts
+++ b/spec/unit/crypto.spec.ts
@@ -19,6 +19,7 @@ import { MemoryStore } from "../../src";
 import { RoomKeyRequestState } from '../../src/crypto/OutgoingRoomKeyRequestManager';
 import { RoomMember } from '../../src/models/room-member';
 import { IStore } from '../../src/store';
+import { IRoomEncryption, RoomList } from "../../src/crypto/RoomList";
 
 const Olm = global.Olm;
 
@@ -1140,4 +1141,48 @@ describe("Crypto", function() {
             await client!.client.crypto!.start();
         });
     });
+
+    describe("setRoomEncryption", () => {
+        let mockClient: MatrixClient;
+        let mockRoomList: RoomList;
+        let clientStore: IStore;
+        let crypto: Crypto;
+
+        beforeEach(async function() {
+            mockClient = {} as MatrixClient;
+            const mockStorage = new MockStorageApi() as unknown as Storage;
+            clientStore = new MemoryStore({ localStorage: mockStorage }) as unknown as IStore;
+            const cryptoStore = new MemoryCryptoStore();
+
+            mockRoomList = {
+                getRoomEncryption: jest.fn().mockReturnValue(null),
+                setRoomEncryption: jest.fn().mockResolvedValue(undefined),
+            } as unknown as RoomList;
+
+            crypto = new Crypto(
+                mockClient,
+                "@alice:home.server",
+                "FLIBBLE",
+                clientStore,
+                cryptoStore,
+                mockRoomList,
+                [],
+            );
+        });
+
+        it("should set the algorithm if called for a known room", async () => {
+            const room = new Room("!room:id", mockClient, "@my.user:id");
+            await clientStore.storeRoom(room);
+            await crypto.setRoomEncryption("!room:id", { algorithm: "m.megolm.v1.aes-sha2" } as IRoomEncryption);
+            expect(mockRoomList!.setRoomEncryption).toHaveBeenCalledTimes(1);
+            expect(jest.mocked(mockRoomList!.setRoomEncryption).mock.calls[0][0]).toEqual("!room:id");
+        });
+
+        it("should raise if called for an unknown room", async () => {
+            await expect(async () => {
+                await crypto.setRoomEncryption("!room:id", { algorithm: "m.megolm.v1.aes-sha2" } as IRoomEncryption);
+            }).rejects.toThrow(/unknown room/);
+            expect(mockRoomList!.setRoomEncryption).not.toHaveBeenCalled();
+        });
+    });
 });
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 4a7f73e9bd4..0f203bc25cc 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -86,6 +86,7 @@ import { ISyncStateData } from "../sync";
 import { CryptoStore } from "./store/base";
 import { IVerificationChannel } from "./verification/request/Channel";
 import { TypedEventEmitter } from "../models/typed-event-emitter";
+import { IContent } from "../models/event";
 
 const DeviceVerification = DeviceInfo.DeviceVerification;
 
@@ -2552,12 +2553,45 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @param {boolean=} inhibitDeviceQuery true to suppress device list query for
      *   users in the room (for now). In case lazy loading is enabled,
      *   the device query is always inhibited as the members are not tracked.
+     *
+     * @deprecated It is normally incorrect to call this method directly. Encryption
+     *   is enabled by receiving an `m.room.encryption` event (which we may have sent
+     *   previously).
      */
     public async setRoomEncryption(
         roomId: string,
         config: IRoomEncryption,
         inhibitDeviceQuery?: boolean,
     ): Promise<void> {
+        const room = this.clientStore.getRoom(roomId);
+        if (!room) {
+            throw new Error(`Unable to enable encryption tracking devices in unknown room ${roomId}`);
+        }
+        await this.setRoomEncryptionImpl(room, config);
+        if (!this.lazyLoadMembers && !inhibitDeviceQuery) {
+            this.deviceList.refreshOutdatedDeviceLists();
+        }
+    }
+
+    /**
+     * Set up encryption for a room.
+     *
+     * This is called when an <tt>m.room.encryption</tt> event is received. It saves a flag
+     * for the room in the cryptoStore (if it wasn't already set), sets up an "encryptor" for
+     * the room, and enables device-list tracking for the room.
+     *
+     * It does <em>not</em> initiate a device list query for the room. That is normally
+     * done once we finish processing the sync, in onSyncCompleted.
+     *
+     * @param room The room to enable encryption in.
+     * @param config The encryption config for the room.
+     */
+    private async setRoomEncryptionImpl(
+        room: Room,
+        config: IRoomEncryption,
+    ): Promise<void> {
+        const roomId = room.roomId;
+
         // ignore crypto events with no algorithm defined
         // This will happen if a crypto event is redacted before we fetch the room state
         // It would otherwise just throw later as an unknown algorithm would, but we may
@@ -2625,14 +2659,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             logger.log("Enabling encryption in " + roomId + "; " +
                 "starting to track device lists for all users therein");
 
-            await this.trackRoomDevices(roomId);
-            // TODO: this flag is only not used from MatrixClient::setRoomEncryption
-            // which is never used (inside Element at least)
-            // but didn't want to remove it as it technically would
-            // be a breaking change.
-            if (!inhibitDeviceQuery) {
-                this.deviceList.refreshOutdatedDeviceLists();
-            }
+            await this.trackRoomDevicesImpl(room);
         } else {
             logger.log("Enabling encryption in " + roomId);
         }
@@ -2645,15 +2672,30 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @returns {Promise} when all devices for the room have been fetched and marked to track
      */
     public trackRoomDevices(roomId: string): Promise<void> {
+        const room = this.clientStore.getRoom(roomId);
+        if (!room) {
+            throw new Error(`Unable to start tracking devices in unknown room ${roomId}`);
+        }
+        return this.trackRoomDevicesImpl(room);
+    }
+
+    /**
+     * Make sure we are tracking the device lists for all users in this room.
+     *
+     * This is normally called when we are about to send an encrypted event, to make sure
+     * we have all the devices in the room; but it is also called when processing an
+     * m.room.encryption state event (if lazy-loading is disabled), or when members are
+     * loaded (if lazy-loading is enabled), to prepare the device list.
+     *
+     * @param room Room to enable device-list tracking in
+     */
+    private trackRoomDevicesImpl(room: Room): Promise<void> {
+        const roomId = room.roomId;
         const trackMembers = async (): Promise<void> => {
             // not an encrypted room
             if (!this.roomEncryptors.has(roomId)) {
                 return;
             }
-            const room = this.clientStore.getRoom(roomId);
-            if (!room) {
-                throw new Error(`Unable to start tracking devices in unknown room ${roomId}`);
-            }
             logger.log(`Starting to track devices for room ${roomId} ...`);
             const members = await room.getEncryptionTargetMembers();
             members.forEach((m) => {
@@ -2815,17 +2857,14 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             // MatrixClient has already checked that this room should be encrypted,
             // so this is an unexpected situation.
             throw new Error(
-                "Room was previously configured to use encryption, but is " +
+                "Room " + roomId + " was previously configured to use encryption, but is " +
                 "no longer. Perhaps the homeserver is hiding the " +
                 "configuration event.",
             );
         }
 
-        if (!this.roomDeviceTrackingState[roomId]) {
-            this.trackRoomDevices(roomId);
-        }
         // wait for all the room devices to be loaded
-        await this.roomDeviceTrackingState[roomId];
+        await this.trackRoomDevicesImpl(room);
 
         let content = event.getContent();
         // If event has an m.relates_to then we need
@@ -2844,7 +2883,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             delete content['io.element.performance_metrics'];
         }
 
-        const encryptedContent = await alg.encryptMessage(room, event.getType(), content);
+        const encryptedContent = await alg.encryptMessage(room, event.getType(), content) as IContent;
 
         if (mRelatesTo) {
             encryptedContent['m.relates_to'] = mRelatesTo;
@@ -2972,19 +3011,12 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * handle an m.room.encryption event
      *
-     * @param {module:models/event.MatrixEvent} event encryption event
+     * @param room in which the event was received
+     * @param event encryption event to be processed
      */
-    public async onCryptoEvent(event: MatrixEvent): Promise<void> {
-        const roomId = event.getRoomId()!;
+    public async onCryptoEvent(room: Room, event: MatrixEvent): Promise<void> {
         const content = event.getContent<IRoomEncryption>();
-
-        try {
-            // inhibit the device list refresh for now - it will happen once we've
-            // finished processing the sync, in onSyncCompleted.
-            await this.setRoomEncryption(roomId, content, true);
-        } catch (e) {
-            logger.error(`Error configuring encryption in room ${roomId}`, e);
-        }
+        await this.setRoomEncryptionImpl(room, content);
     }
 
     /**
diff --git a/src/sliding-sync-sdk.ts b/src/sliding-sync-sdk.ts
index a787b4e3465..03a17bed327 100644
--- a/src/sliding-sync-sdk.ts
+++ b/src/sliding-sync-sdk.ts
@@ -703,7 +703,7 @@ export class SlidingSyncSdk {
         const processRoomEvent = async (e: MatrixEvent): Promise<void> => {
             client.emit(ClientEvent.Event, e);
             if (e.isState() && e.getType() == EventType.RoomEncryption && this.opts.crypto) {
-                await this.opts.crypto.onCryptoEvent(e);
+                await this.opts.crypto.onCryptoEvent(room, e);
             }
         };
 
diff --git a/src/sync.ts b/src/sync.ts
index f32ccf7d239..20cab67b6eb 100644
--- a/src/sync.ts
+++ b/src/sync.ts
@@ -1362,6 +1362,18 @@ export class SyncApi {
                 }
             }
 
+            // process any crypto events *before* emitting the RoomStateEvent events. This
+            // avoids a race condition if the application tries to send a message after the
+            // state event is processed, but before crypto is enabled, which then causes the
+            // crypto layer to complain.
+            if (this.opts.crypto) {
+                for (const e of stateEvents.concat(events)) {
+                    if (e.isState() && e.getType() === EventType.RoomEncryption && e.getStateKey() === "") {
+                        await this.opts.crypto.onCryptoEvent(room, e);
+                    }
+                }
+            }
+
             try {
                 await this.injectRoomEvents(room, stateEvents, events, syncEventData.fromCache);
             } catch (e) {
@@ -1389,21 +1401,11 @@ export class SyncApi {
 
             this.processEventsForNotifs(room, events);
 
-            const processRoomEvent = async (e): Promise<void> => {
-                client.emit(ClientEvent.Event, e);
-                if (e.isState() && e.getType() == "m.room.encryption" && this.opts.crypto) {
-                    await this.opts.crypto.onCryptoEvent(e);
-                }
-            };
-
-            await utils.promiseMapSeries(stateEvents, processRoomEvent);
-            await utils.promiseMapSeries(events, processRoomEvent);
-            ephemeralEvents.forEach(function(e) {
-                client.emit(ClientEvent.Event, e);
-            });
-            accountDataEvents.forEach(function(e) {
-                client.emit(ClientEvent.Event, e);
-            });
+            const emitEvent = (e: MatrixEvent): boolean => client.emit(ClientEvent.Event, e);
+            stateEvents.forEach(emitEvent);
+            events.forEach(emitEvent);
+            ephemeralEvents.forEach(emitEvent);
+            accountDataEvents.forEach(emitEvent);
 
             // Decrypt only the last message in all rooms to make sure we can generate a preview
             // And decrypt all events after the recorded read receipt to ensure an accurate

From 4362297edc9dc45d154fe83f97f479a2901905aa Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 30 Nov 2022 14:21:43 +0000
Subject: [PATCH 07/60] Update dependency @typescript-eslint/eslint-plugin to
 v5.44.0 (#2924)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 yarn.lock | 72 +++++++++++++++----------------------------------------
 1 file changed, 19 insertions(+), 53 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index f13f2de890e..987c5a6cdb3 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1726,13 +1726,13 @@
     "@types/yargs-parser" "*"
 
 "@typescript-eslint/eslint-plugin@^5.6.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.43.0.tgz#4a5248eb31b454715ddfbf8cfbf497529a0a78bc"
-  integrity sha512-wNPzG+eDR6+hhW4yobEmpR36jrqqQv1vxBq5LJO3fBAktjkvekfr4BRl+3Fn1CM/A+s8/EiGUbOMDoYqWdbtXA==
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.45.0.tgz#ffa505cf961d4844d38cfa19dcec4973a6039e41"
+  integrity sha512-CXXHNlf0oL+Yg021cxgOdMHNTXD17rHkq7iW6RFHoybdFgQBjU3yIXhhcPpGwr1CjZlo6ET8C6tzX5juQoXeGA==
   dependencies:
-    "@typescript-eslint/scope-manager" "5.43.0"
-    "@typescript-eslint/type-utils" "5.43.0"
-    "@typescript-eslint/utils" "5.43.0"
+    "@typescript-eslint/scope-manager" "5.45.0"
+    "@typescript-eslint/type-utils" "5.45.0"
+    "@typescript-eslint/utils" "5.45.0"
     debug "^4.3.4"
     ignore "^5.2.0"
     natural-compare-lite "^1.4.0"
@@ -1750,14 +1750,6 @@
     "@typescript-eslint/typescript-estree" "5.45.0"
     debug "^4.3.4"
 
-"@typescript-eslint/scope-manager@5.43.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.43.0.tgz#566e46303392014d5d163704724872e1f2dd3c15"
-  integrity sha512-XNWnGaqAtTJsUiZaoiGIrdJYHsUOd3BZ3Qj5zKp9w6km6HsrjPk/TGZv0qMTWyWj0+1QOqpHQ2gZOLXaGA9Ekw==
-  dependencies:
-    "@typescript-eslint/types" "5.43.0"
-    "@typescript-eslint/visitor-keys" "5.43.0"
-
 "@typescript-eslint/scope-manager@5.45.0":
   version "5.45.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.45.0.tgz#7a4ac1bfa9544bff3f620ab85947945938319a96"
@@ -1766,39 +1758,21 @@
     "@typescript-eslint/types" "5.45.0"
     "@typescript-eslint/visitor-keys" "5.45.0"
 
-"@typescript-eslint/type-utils@5.43.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.43.0.tgz#91110fb827df5161209ecca06f70d19a96030be6"
-  integrity sha512-K21f+KY2/VvYggLf5Pk4tgBOPs2otTaIHy2zjclo7UZGLyFH86VfUOm5iq+OtDtxq/Zwu2I3ujDBykVW4Xtmtg==
+"@typescript-eslint/type-utils@5.45.0":
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.45.0.tgz#aefbc954c40878fcebeabfb77d20d84a3da3a8b2"
+  integrity sha512-DY7BXVFSIGRGFZ574hTEyLPRiQIvI/9oGcN8t1A7f6zIs6ftbrU0nhyV26ZW//6f85avkwrLag424n+fkuoJ1Q==
   dependencies:
-    "@typescript-eslint/typescript-estree" "5.43.0"
-    "@typescript-eslint/utils" "5.43.0"
+    "@typescript-eslint/typescript-estree" "5.45.0"
+    "@typescript-eslint/utils" "5.45.0"
     debug "^4.3.4"
     tsutils "^3.21.0"
 
-"@typescript-eslint/types@5.43.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.43.0.tgz#e4ddd7846fcbc074325293515fa98e844d8d2578"
-  integrity sha512-jpsbcD0x6AUvV7tyOlyvon0aUsQpF8W+7TpJntfCUWU1qaIKu2K34pMwQKSzQH8ORgUrGYY6pVIh1Pi8TNeteg==
-
 "@typescript-eslint/types@5.45.0":
   version "5.45.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.45.0.tgz#794760b9037ee4154c09549ef5a96599621109c5"
   integrity sha512-QQij+u/vgskA66azc9dCmx+rev79PzX8uDHpsqSjEFtfF2gBUTRCpvYMh2gw2ghkJabNkPlSUCimsyBEQZd1DA==
 
-"@typescript-eslint/typescript-estree@5.43.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.43.0.tgz#b6883e58ba236a602c334be116bfc00b58b3b9f2"
-  integrity sha512-BZ1WVe+QQ+igWal2tDbNg1j2HWUkAa+CVqdU79L4HP9izQY6CNhXfkNwd1SS4+sSZAP/EthI1uiCSY/+H0pROg==
-  dependencies:
-    "@typescript-eslint/types" "5.43.0"
-    "@typescript-eslint/visitor-keys" "5.43.0"
-    debug "^4.3.4"
-    globby "^11.1.0"
-    is-glob "^4.0.3"
-    semver "^7.3.7"
-    tsutils "^3.21.0"
-
 "@typescript-eslint/typescript-estree@5.45.0":
   version "5.45.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.45.0.tgz#f70a0d646d7f38c0dfd6936a5e171a77f1e5291d"
@@ -1812,28 +1786,20 @@
     semver "^7.3.7"
     tsutils "^3.21.0"
 
-"@typescript-eslint/utils@5.43.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.43.0.tgz#00fdeea07811dbdf68774a6f6eacfee17fcc669f"
-  integrity sha512-8nVpA6yX0sCjf7v/NDfeaOlyaIIqL7OaIGOWSPFqUKK59Gnumd3Wa+2l8oAaYO2lk0sO+SbWFWRSvhu8gLGv4A==
+"@typescript-eslint/utils@5.45.0":
+  version "5.45.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.45.0.tgz#9cca2996eee1b8615485a6918a5c763629c7acf5"
+  integrity sha512-OUg2JvsVI1oIee/SwiejTot2OxwU8a7UfTFMOdlhD2y+Hl6memUSL4s98bpUTo8EpVEr0lmwlU7JSu/p2QpSvA==
   dependencies:
     "@types/json-schema" "^7.0.9"
     "@types/semver" "^7.3.12"
-    "@typescript-eslint/scope-manager" "5.43.0"
-    "@typescript-eslint/types" "5.43.0"
-    "@typescript-eslint/typescript-estree" "5.43.0"
+    "@typescript-eslint/scope-manager" "5.45.0"
+    "@typescript-eslint/types" "5.45.0"
+    "@typescript-eslint/typescript-estree" "5.45.0"
     eslint-scope "^5.1.1"
     eslint-utils "^3.0.0"
     semver "^7.3.7"
 
-"@typescript-eslint/visitor-keys@5.43.0":
-  version "5.43.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.43.0.tgz#cbbdadfdfea385310a20a962afda728ea106befa"
-  integrity sha512-icl1jNH/d18OVHLfcwdL3bWUKsBeIiKYTGxMJCoGe7xFht+E4QgzOqoWYrU8XSLJWhVw8nTacbm03v23J/hFTg==
-  dependencies:
-    "@typescript-eslint/types" "5.43.0"
-    eslint-visitor-keys "^3.3.0"
-
 "@typescript-eslint/visitor-keys@5.45.0":
   version "5.45.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.45.0.tgz#e0d160e9e7fdb7f8da697a5b78e7a14a22a70528"

From d692a5dbe239d06e04159c40f282159725415689 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 30 Nov 2022 14:22:05 +0000
Subject: [PATCH 08/60] Update tspascoal/get-user-teams-membership action to v2
 (#2925)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 .github/workflows/pull_request.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/pull_request.yaml b/.github/workflows/pull_request.yaml
index 940aa0ea239..d2a8857aa5f 100644
--- a/.github/workflows/pull_request.yaml
+++ b/.github/workflows/pull_request.yaml
@@ -42,7 +42,7 @@ jobs:
     if: github.event.action == 'opened'
     steps:
       - name: Check membership
-        uses: tspascoal/get-user-teams-membership@v1
+        uses: tspascoal/get-user-teams-membership@v2
         id: teams
         with:
           username: ${{ github.event.pull_request.user.login }}

From 720ea0e12e5fe757e598f0e493631754b9d6d02a Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 1 Dec 2022 07:24:50 +0000
Subject: [PATCH 09/60] Update all non-major dependencies (#2928)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 yarn.lock | 44 ++++++++++++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 16 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index 987c5a6cdb3..c748b4750b1 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1049,6 +1049,13 @@
     uuid "8.3.2"
     xml "1.0.1"
 
+"@eslint-community/eslint-utils@^4.1.0":
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.1.2.tgz#14ca568ddaa291dd19a4a54498badc18c6cfab78"
+  integrity sha512-7qELuQWWjVDdVsFQ5+beUl+KPczrEDA7S3zM4QUd/bJl7oXgsmpXaEVqrRTnOBqenOV4rWf2kVZk2Ot085zPWA==
+  dependencies:
+    eslint-visitor-keys "^3.3.0"
+
 "@eslint/eslintrc@^1.3.3":
   version "1.3.3"
   resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-1.3.3.tgz#2b044ab39fdfa75b4688184f9e573ce3c5b0ff95"
@@ -2556,11 +2563,16 @@ chokidar@^3.4.0:
   optionalDependencies:
     fsevents "~2.3.2"
 
-ci-info@^3.2.0, ci-info@^3.6.1:
+ci-info@^3.2.0:
   version "3.6.1"
   resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.6.1.tgz#7594f1c95cb7fdfddee7af95a13af7dbc67afdcf"
   integrity sha512-up5ggbaDqOqJ4UqLKZ2naVkyqSJQgJi5lwD6b6mM748ysrghDBX0bx/qJTUHzw7zu6Mq4gycviSF5hJnwceD8w==
 
+ci-info@^3.6.1:
+  version "3.7.0"
+  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.7.0.tgz#6d01b3696c59915b6ce057e4aa4adfc2fa25f5ef"
+  integrity sha512-2CpRNYmImPx+RXKLq6jko/L07phmS9I02TyqkcNU20GCF/GgaWvc58hPtjxDX8lPpkdwc9sNh72V9k00S7ezog==
+
 cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
@@ -3283,23 +3295,23 @@ eslint-plugin-matrix-org@^0.8.0:
   integrity sha512-/Poz/F8lXYDsmQa29iPSt+kO+Jn7ArvRdq10g0CCk8wbRS0sb2zb6fvd9xL1BgR5UDQL771V0l8X32etvY5yKA==
 
 eslint-plugin-unicorn@^45.0.0:
-  version "45.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-unicorn/-/eslint-plugin-unicorn-45.0.0.tgz#a6650ff3000dc1a87cc2f6ac3a11edcde61712e2"
-  integrity sha512-iP8cMRxXKHonKioOhnCoCcqVhoqhAp6rB+nsoLjXFDxTHz3btWMAp8xwzjHA0B1K6YV/U/Yvqn1bUXZt8sJPuQ==
+  version "45.0.1"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-unicorn/-/eslint-plugin-unicorn-45.0.1.tgz#2307f4620502fd955c819733ce1276bed705b736"
+  integrity sha512-tLnIw5oDJJc3ILYtlKtqOxPP64FZLTkZkgeuoN6e7x6zw+rhBjOxyvq2c7577LGxXuIhBYrwisZuKNqOOHp3BA==
   dependencies:
     "@babel/helper-validator-identifier" "^7.19.1"
+    "@eslint-community/eslint-utils" "^4.1.0"
     ci-info "^3.6.1"
     clean-regexp "^1.0.0"
-    eslint-utils "^3.0.0"
     esquery "^1.4.0"
     indent-string "^4.0.0"
     is-builtin-module "^3.2.0"
-    jsesc "3.0.2"
+    jsesc "^3.0.2"
     lodash "^4.17.21"
     pluralize "^8.0.0"
     read-pkg-up "^7.0.1"
     regexp-tree "^0.1.24"
-    regjsparser "0.9.1"
+    regjsparser "^0.9.1"
     safe-regex "^2.1.1"
     semver "^7.3.8"
     strip-indent "^3.0.0"
@@ -3520,9 +3532,9 @@ ext@^1.1.2:
     type "^2.7.2"
 
 fake-indexeddb@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/fake-indexeddb/-/fake-indexeddb-4.0.0.tgz#1dfb2023a3be175e35a6d84975218b432041934d"
-  integrity sha512-oCfWSJ/qvQn1XPZ8SHX6kY3zr1t+bN7faZ/lltGY0SBGhFOPXnWf0+pbO/MOAgfMx6khC2gK3S/bvAgQpuQHDQ==
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/fake-indexeddb/-/fake-indexeddb-4.0.1.tgz#09bb2468e21d0832b2177e894765fb109edac8fb"
+  integrity sha512-hFRyPmvEZILYgdcLBxVdHLik4Tj3gDTu/g7s9ZDOiU3sTNiGx+vEu1ri/AMsFJUZ/1sdRbAVrEcKndh3sViBcA==
   dependencies:
     realistic-structured-clone "^3.0.0"
 
@@ -4810,16 +4822,16 @@ jsdom@^20.0.0:
     ws "^8.9.0"
     xml-name-validator "^4.0.0"
 
-jsesc@3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.0.2.tgz#bb8b09a6597ba426425f2e4a07245c3d00b9343e"
-  integrity sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==
-
 jsesc@^2.5.1:
   version "2.5.2"
   resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
   integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
 
+jsesc@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.0.2.tgz#bb8b09a6597ba426425f2e4a07245c3d00b9343e"
+  integrity sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==
+
 jsesc@~0.5.0:
   version "0.5.0"
   resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d"
@@ -6005,7 +6017,7 @@ regjsgen@^0.7.1:
   resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.7.1.tgz#ee5ef30e18d3f09b7c369b76e7c2373ed25546f6"
   integrity sha512-RAt+8H2ZEzHeYWxZ3H2z6tF18zyyOnlcdaafLrm21Bguj7uZy6ULibiAFdXEtKQY4Sy7wDTwDiOazasMLc4KPA==
 
-regjsparser@0.9.1, regjsparser@^0.9.1:
+regjsparser@^0.9.1:
   version "0.9.1"
   resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.9.1.tgz#272d05aa10c7c1f67095b1ff0addae8442fc5709"
   integrity sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==

From a0f3e5d3bf1d0791d40152d8b7f388af60c30e81 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Thu, 1 Dec 2022 07:25:08 +0000
Subject: [PATCH 10/60] Update babel monorepo (#2929)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
---
 yarn.lock | 104 ++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 74 insertions(+), 30 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index c748b4750b1..77cca92702e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -58,26 +58,31 @@
   dependencies:
     "@babel/highlight" "^7.18.6"
 
-"@babel/compat-data@^7.17.7", "@babel/compat-data@^7.20.0", "@babel/compat-data@^7.20.1":
+"@babel/compat-data@^7.17.7", "@babel/compat-data@^7.20.1":
   version "7.20.1"
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.20.1.tgz#f2e6ef7790d8c8dbf03d379502dcc246dcce0b30"
   integrity sha512-EWZ4mE2diW3QALKvDMiXnbZpRvlj+nayZ112nK93SnhqOtpdsbVD4W+2tEoT3YNBAG9RBR0ISY758ZkOgsn6pQ==
 
+"@babel/compat-data@^7.20.0":
+  version "7.20.5"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.20.5.tgz#86f172690b093373a933223b4745deeb6049e733"
+  integrity sha512-KZXo2t10+/jxmkhNXc7pZTqRvSOIvVv/+lJwHS+B2rErwOyjuVRh60yVpb7liQ1U5t7lLJ1bz+t8tSypUZdm0g==
+
 "@babel/core@^7.11.6", "@babel/core@^7.12.10", "@babel/core@^7.12.3", "@babel/core@^7.7.5":
-  version "7.20.2"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.20.2.tgz#8dc9b1620a673f92d3624bd926dc49a52cf25b92"
-  integrity sha512-w7DbG8DtMrJcFOi4VrLm+8QM4az8Mo+PuLBKLp2zrYRCow8W/f9xiXm5sN53C8HksCyDQwCKha9JiDoIyPjT2g==
+  version "7.20.5"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.20.5.tgz#45e2114dc6cd4ab167f81daf7820e8fa1250d113"
+  integrity sha512-UdOWmk4pNWTm/4DlPUl/Pt4Gz4rcEMb7CY0Y3eJl5Yz1vI8ZJGmHWaVE55LoxRjdpx0z259GE9U5STA9atUinQ==
   dependencies:
     "@ampproject/remapping" "^2.1.0"
     "@babel/code-frame" "^7.18.6"
-    "@babel/generator" "^7.20.2"
+    "@babel/generator" "^7.20.5"
     "@babel/helper-compilation-targets" "^7.20.0"
     "@babel/helper-module-transforms" "^7.20.2"
-    "@babel/helpers" "^7.20.1"
-    "@babel/parser" "^7.20.2"
+    "@babel/helpers" "^7.20.5"
+    "@babel/parser" "^7.20.5"
     "@babel/template" "^7.18.10"
-    "@babel/traverse" "^7.20.1"
-    "@babel/types" "^7.20.2"
+    "@babel/traverse" "^7.20.5"
+    "@babel/types" "^7.20.5"
     convert-source-map "^1.7.0"
     debug "^4.1.0"
     gensync "^1.0.0-beta.2"
@@ -109,7 +114,16 @@
     "@jridgewell/gen-mapping" "^0.3.2"
     jsesc "^2.5.1"
 
-"@babel/generator@^7.20.1", "@babel/generator@^7.20.2", "@babel/generator@^7.7.2":
+"@babel/generator@^7.20.1", "@babel/generator@^7.20.5":
+  version "7.20.5"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.20.5.tgz#cb25abee3178adf58d6814b68517c62bdbfdda95"
+  integrity sha512-jl7JY2Ykn9S0yj4DQP82sYvPU+T3g0HFcWTqDLqiuA9tGRNIj9VfbtXGAYTTkyNEnQk1jkMGOdYka8aG/lulCA==
+  dependencies:
+    "@babel/types" "^7.20.5"
+    "@jridgewell/gen-mapping" "^0.3.2"
+    jsesc "^2.5.1"
+
+"@babel/generator@^7.7.2":
   version "7.20.4"
   resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.20.4.tgz#4d9f8f0c30be75fd90a0562099a26e5839602ab8"
   integrity sha512-luCf7yk/cm7yab6CAW1aiFnmEfBJplb/JojV56MYEK7ziWfGmFlTfmL9Ehwfy4gFhbjBfWO1wj7/TuSbVNEEtA==
@@ -310,14 +324,14 @@
     "@babel/traverse" "^7.19.0"
     "@babel/types" "^7.19.0"
 
-"@babel/helpers@^7.20.1":
-  version "7.20.1"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.20.1.tgz#2ab7a0fcb0a03b5bf76629196ed63c2d7311f4c9"
-  integrity sha512-J77mUVaDTUJFZ5BpP6mMn6OIl3rEWymk2ZxDBQJUG3P+PbmyMcF3bYWvz0ma69Af1oobDqT/iAsvzhB58xhQUg==
+"@babel/helpers@^7.20.5":
+  version "7.20.6"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.20.6.tgz#e64778046b70e04779dfbdf924e7ebb45992c763"
+  integrity sha512-Pf/OjgfgFRW5bApskEz5pvidpim7tEDPlFtKcNRXWmfHGn9IEI2W2flqRQXTFb7gIPTyK++N6rVHuwKut4XK6w==
   dependencies:
     "@babel/template" "^7.18.10"
-    "@babel/traverse" "^7.20.1"
-    "@babel/types" "^7.20.0"
+    "@babel/traverse" "^7.20.5"
+    "@babel/types" "^7.20.5"
 
 "@babel/highlight@^7.18.6":
   version "7.18.6"
@@ -328,11 +342,16 @@
     chalk "^2.0.0"
     js-tokens "^4.0.0"
 
-"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.18.10", "@babel/parser@^7.2.3", "@babel/parser@^7.20.1", "@babel/parser@^7.20.2":
+"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.2.3":
   version "7.20.3"
   resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.20.3.tgz#5358cf62e380cf69efcb87a7bb922ff88bfac6e2"
   integrity sha512-OP/s5a94frIPXwjzEcv5S/tpQfc6XhxYUnmWpgdqMWGgYCuErA3SzozaRAMQgSZWKeTJxht9aWAkUY+0UzvOFg==
 
+"@babel/parser@^7.18.10", "@babel/parser@^7.20.1", "@babel/parser@^7.20.5":
+  version "7.20.5"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.20.5.tgz#7f3c7335fe417665d929f34ae5dceae4c04015e8"
+  integrity sha512-r27t/cy/m9uKLXQNWWebeCUHgnAZq0CpG1OwKRxzJMP1vpSU4bSIK2hq+/cp0bQxetkXx38n09rNu8jVkcK/zA==
+
 "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.18.6":
   version "7.18.6"
   resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.18.6.tgz#da5b8f9a580acdfbe53494dba45ea389fb09a4d2"
@@ -995,11 +1014,11 @@
     source-map-support "^0.5.16"
 
 "@babel/runtime@^7.12.5", "@babel/runtime@^7.7.6", "@babel/runtime@^7.8.4":
-  version "7.20.1"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.20.1.tgz#1148bb33ab252b165a06698fde7576092a78b4a9"
-  integrity sha512-mrzLkl6U9YLF8qpqI7TB82PESyEGjm/0Ly91jG575eVxMMlb8fYfOXFZIJ8XfLrJZQbm7dlKry2bJmXBUEkdFg==
+  version "7.20.6"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.20.6.tgz#facf4879bfed9b5326326273a64220f099b0fce3"
+  integrity sha512-Q+8MqP7TiHMWzSfwiJwXCjyf4GYA4Dgw3emg/7xmwsdLJOZUp+nMqcOwOzzYheuM1rhDu8FSj2l0aoMygEuXuA==
   dependencies:
-    regenerator-runtime "^0.13.10"
+    regenerator-runtime "^0.13.11"
 
 "@babel/template@^7.18.10", "@babel/template@^7.3.3":
   version "7.18.10"
@@ -1010,7 +1029,7 @@
     "@babel/parser" "^7.18.10"
     "@babel/types" "^7.18.10"
 
-"@babel/traverse@^7.1.6", "@babel/traverse@^7.19.0", "@babel/traverse@^7.19.1", "@babel/traverse@^7.20.1", "@babel/traverse@^7.7.2":
+"@babel/traverse@^7.1.6", "@babel/traverse@^7.19.0", "@babel/traverse@^7.19.1", "@babel/traverse@^7.7.2":
   version "7.20.1"
   resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.20.1.tgz#9b15ccbf882f6d107eeeecf263fbcdd208777ec8"
   integrity sha512-d3tN8fkVJwFLkHkBN479SOsw4DMZnz8cdbL/gvuDuzy3TS6Nfw80HuQqhw1pITbIruHyh7d1fMA47kWzmcUEGA==
@@ -1026,7 +1045,23 @@
     debug "^4.1.0"
     globals "^11.1.0"
 
-"@babel/types@^7.0.0", "@babel/types@^7.18.10", "@babel/types@^7.18.6", "@babel/types@^7.18.9", "@babel/types@^7.19.0", "@babel/types@^7.2.0", "@babel/types@^7.20.0", "@babel/types@^7.20.2", "@babel/types@^7.3.0", "@babel/types@^7.3.3", "@babel/types@^7.4.4":
+"@babel/traverse@^7.20.1", "@babel/traverse@^7.20.5":
+  version "7.20.5"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.20.5.tgz#78eb244bea8270fdda1ef9af22a5d5e5b7e57133"
+  integrity sha512-WM5ZNN3JITQIq9tFZaw1ojLU3WgWdtkxnhM1AegMS+PvHjkM5IXjmYEGY7yukz5XS4sJyEf2VzWjI8uAavhxBQ==
+  dependencies:
+    "@babel/code-frame" "^7.18.6"
+    "@babel/generator" "^7.20.5"
+    "@babel/helper-environment-visitor" "^7.18.9"
+    "@babel/helper-function-name" "^7.19.0"
+    "@babel/helper-hoist-variables" "^7.18.6"
+    "@babel/helper-split-export-declaration" "^7.18.6"
+    "@babel/parser" "^7.20.5"
+    "@babel/types" "^7.20.5"
+    debug "^4.1.0"
+    globals "^11.1.0"
+
+"@babel/types@^7.0.0", "@babel/types@^7.18.9", "@babel/types@^7.2.0", "@babel/types@^7.3.0", "@babel/types@^7.3.3", "@babel/types@^7.4.4":
   version "7.20.2"
   resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.20.2.tgz#67ac09266606190f496322dbaff360fdaa5e7842"
   integrity sha512-FnnvsNWgZCr232sqtXggapvlkk/tuwR/qhGzcmxI0GXLCjmPYQPzio2FbdlWuY6y1sHFfQKk+rRbUZ9VStQMog==
@@ -1035,6 +1070,15 @@
     "@babel/helper-validator-identifier" "^7.19.1"
     to-fast-properties "^2.0.0"
 
+"@babel/types@^7.18.10", "@babel/types@^7.18.6", "@babel/types@^7.19.0", "@babel/types@^7.20.0", "@babel/types@^7.20.2", "@babel/types@^7.20.5":
+  version "7.20.5"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.20.5.tgz#e206ae370b5393d94dfd1d04cd687cace53efa84"
+  integrity sha512-c9fst/h2/dcF7H+MJKZ2T0KjEQ8hY/BNnDk/H3XY8C4Aw/eWQXWn/lWntHF9ooUBnGmEvbfGrTgLWc+um0YDUg==
+  dependencies:
+    "@babel/helper-string-parser" "^7.19.4"
+    "@babel/helper-validator-identifier" "^7.19.1"
+    to-fast-properties "^2.0.0"
+
 "@bcoe/v8-coverage@^0.2.3":
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
@@ -2507,9 +2551,9 @@ camelcase@^6.2.0:
   integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
 
 caniuse-lite@^1.0.30001400:
-  version "1.0.30001431"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001431.tgz#e7c59bd1bc518fae03a4656be442ce6c4887a795"
-  integrity sha512-zBUoFU0ZcxpvSt9IU66dXVT/3ctO1cy4y9cscs1szkPlcWb6pasYM144GqrUygUbT+k7cmUCW61cvskjcv0enQ==
+  version "1.0.30001435"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001435.tgz#502c93dbd2f493bee73a408fe98e98fb1dad10b2"
+  integrity sha512-kdCkUTjR+v4YAJelyiDTqiu82BDr4W4CP5sgTA0ZBmqn30XfS2ZghPLMowik9TPhS+psWJiUNxsqLyurDbmutA==
 
 center-align@^0.1.1:
   version "0.1.3"
@@ -5969,10 +6013,10 @@ regenerator-runtime@^0.11.0:
   resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
   integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==
 
-regenerator-runtime@^0.13.10:
-  version "0.13.10"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.10.tgz#ed07b19616bcbec5da6274ebc75ae95634bfc2ee"
-  integrity sha512-KepLsg4dU12hryUO7bp/axHAKvwGOCV0sGloQtpagJ12ai+ojVDqkeGSiRX1zlq+kjIMZ1t7gpze+26QqtdGqw==
+regenerator-runtime@^0.13.11:
+  version "0.13.11"
+  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz#f6dca3e7ceec20590d07ada785636a90cdca17f9"
+  integrity sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==
 
 regenerator-transform@^0.15.0:
   version "0.15.0"

From 3870e3395d0caad778ac83eb5ee2daeef53f0e9e Mon Sep 17 00:00:00 2001
From: Faye Duxovni <fayed@matrix.org>
Date: Thu, 1 Dec 2022 04:49:36 -0500
Subject: [PATCH 11/60] Add method to get outgoing room key requests for a
 given event (#2930)

* Add method to get outgoing room key requests for a given event

* Write test, fix typo

* Add test case for non-encrypted event
---
 spec/integ/matrix-client-crypto.spec.ts | 41 +++++++++++++++++++++++++
 src/client.ts                           | 29 ++++++++++++++++-
 2 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/spec/integ/matrix-client-crypto.spec.ts b/spec/integ/matrix-client-crypto.spec.ts
index 38de34aa59d..847bb8528ae 100644
--- a/spec/integ/matrix-client-crypto.spec.ts
+++ b/spec/integ/matrix-client-crypto.spec.ts
@@ -679,4 +679,45 @@ describe("MatrixClient crypto", () => {
             });
         await httpBackend.flushAllExpected();
     });
+
+    it("Checks for outgoing room key requests for a given event's session", async () => {
+        const eventA0 = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {
+                algorithm: 'm.megolm.v1.aes-sha2',
+                session_id: "sessionid",
+                sender_key: "senderkey",
+            },
+        });
+        const eventA1 = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {
+                algorithm: 'm.megolm.v1.aes-sha2',
+                session_id: "sessionid",
+                sender_key: "senderkey",
+            },
+        });
+        const eventB = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {
+                algorithm: 'm.megolm.v1.aes-sha2',
+                session_id: "othersessionid",
+                sender_key: "senderkey",
+            },
+        });
+        const nonEncryptedEvent = new MatrixEvent({
+            sender: "@bob:example.com",
+            room_id: "!someroom",
+            content: {},
+        });
+
+        aliTestClient.client.crypto?.onSyncCompleted({});
+        await aliTestClient.client.cancelAndResendEventRoomKeyRequest(eventA0);
+        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(eventA1)).not.toBeNull();
+        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(eventB)).toBeNull();
+        expect(await aliTestClient.client.getOutgoingRoomKeyRequest(nonEncryptedEvent)).toBeNull();
+    });
 });
diff --git a/src/client.ts b/src/client.ts
index 8b8fa18c315..42709446ecc 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -78,6 +78,7 @@ import {
     IMegolmSessionData,
     isCryptoAvailable,
     VerificationMethod,
+    IRoomKeyRequestBody,
 } from './crypto';
 import { DeviceInfo, IDevice } from "./crypto/deviceinfo";
 import { decodeRecoveryKey } from './crypto/recoverykey';
@@ -184,7 +185,7 @@ import {
     RuleId,
 } from "./@types/PushRules";
 import { IThreepid } from "./@types/threepids";
-import { CryptoStore } from "./crypto/store/base";
+import { CryptoStore, OutgoingRoomKeyRequest } from "./crypto/store/base";
 import {
     GroupCall,
     IGroupCallDataChannelOptions,
@@ -2631,6 +2632,32 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return device.isVerified();
     }
 
+    /**
+     * Get outgoing room key request for this event if there is one.
+     * @param {MatrixEvent} event The event to check for
+     *
+     * @return {Promise} A room key request, or null if there is none
+     */
+    public getOutgoingRoomKeyRequest(event: MatrixEvent): Promise<OutgoingRoomKeyRequest | null> {
+        if (!this.crypto) {
+            throw new Error("End-to-End encryption disabled");
+        }
+        const wireContent = event.getWireContent();
+        const requestBody: IRoomKeyRequestBody = {
+            session_id: wireContent.session_id,
+            sender_key: wireContent.sender_key,
+            algorithm: wireContent.algorithm,
+            room_id: event.getRoomId()!,
+        };
+        if (
+            !requestBody.session_id
+            || !requestBody.sender_key
+            || !requestBody.algorithm
+            || !requestBody.room_id
+        ) return Promise.resolve(null);
+        return this.crypto.cryptoStore.getOutgoingRoomKeyRequest(requestBody);
+    }
+
     /**
      * Cancel a room key request for this event if one is ongoing and resend the
      * request.

From c0090852ad577582ea529d4bc97a783085c0652a Mon Sep 17 00:00:00 2001
From: Robin Townsend <robin@robin.town>
Date: Thu, 1 Dec 2022 10:45:34 -0500
Subject: [PATCH 12/60] Make GroupCall work better with widgets

If the client uses a widget to join group calls, like Element Web does, then the local device could be joined to the call without GroupCall knowing. This adds a field to GroupCall that allows the client to tell GroupCall when it's using another session to join the call.
---
 spec/unit/webrtc/groupCall.spec.ts | 23 ++++++++++++-----------
 src/webrtc/groupCall.ts            | 24 +++++++++++++++++++++---
 2 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/spec/unit/webrtc/groupCall.spec.ts b/spec/unit/webrtc/groupCall.spec.ts
index 047474f8e12..7085f50c12d 100644
--- a/spec/unit/webrtc/groupCall.spec.ts
+++ b/spec/unit/webrtc/groupCall.spec.ts
@@ -180,13 +180,13 @@ describe('Group Call', function() {
 
             room = new Room(FAKE_ROOM_ID, mockClient, FAKE_USER_ID_1);
             groupCall = new GroupCall(mockClient, room, GroupCallType.Video, false, GroupCallIntent.Prompt);
-        });
-
-        it("does not initialize local call feed, if it already is", async () => {
             room.currentState.members[FAKE_USER_ID_1] = {
                 userId: FAKE_USER_ID_1,
+                membership: "join",
             } as unknown as RoomMember;
+        });
 
+        it("does not initialize local call feed, if it already is", async () => {
             await groupCall.initLocalCallFeed();
             jest.spyOn(groupCall, "initLocalCallFeed");
             await groupCall.enter();
@@ -216,10 +216,6 @@ describe('Group Call', function() {
         });
 
         it("sends member state event to room on enter", async () => {
-            room.currentState.members[FAKE_USER_ID_1] = {
-                userId: FAKE_USER_ID_1,
-            } as unknown as RoomMember;
-
             await groupCall.create();
 
             try {
@@ -249,10 +245,6 @@ describe('Group Call', function() {
         });
 
         it("sends member state event to room on leave", async () => {
-            room.currentState.members[FAKE_USER_ID_1] = {
-                userId: FAKE_USER_ID_1,
-            } as unknown as RoomMember;
-
             await groupCall.create();
             await groupCall.enter();
             mockSendState.mockClear();
@@ -267,6 +259,15 @@ describe('Group Call', function() {
             );
         });
 
+        it("includes local device in participants when entered via another session", async () => {
+            groupCall.enteredViaAnotherSession = true;
+
+            const hasLocalParticipant = groupCall.participants.get(
+                room.getMember(mockClient.getUserId()!)!,
+            )?.has(mockClient.getDeviceId()!);
+            expect(hasLocalParticipant).toBe(true);
+        });
+
         it("starts with mic unmuted in regular calls", async () => {
             try {
                 await groupCall.create();
diff --git a/src/webrtc/groupCall.ts b/src/webrtc/groupCall.ts
index 7713d6de9a0..fde46182bc1 100644
--- a/src/webrtc/groupCall.ts
+++ b/src/webrtc/groupCall.ts
@@ -285,6 +285,21 @@ export class GroupCall extends TypedEventEmitter<
         this._creationTs = value;
     }
 
+    private _enteredViaAnotherSession = false;
+
+    /**
+     * Whether the local device has entered this call via another session, such
+     * as a widget.
+     */
+    public get enteredViaAnotherSession(): boolean {
+        return this._enteredViaAnotherSession;
+    }
+
+    public set enteredViaAnotherSession(value: boolean) {
+        this._enteredViaAnotherSession = value;
+        this.updateParticipants();
+    }
+
     /**
      * Executes the given callback on all calls in this group call.
      * @param f The callback.
@@ -1170,7 +1185,7 @@ export class GroupCall extends TypedEventEmitter<
 
         const participants = new Map<RoomMember, Map<string, ParticipantState>>();
         const now = Date.now();
-        const entered = this.state === GroupCallState.Entered;
+        const entered = this.state === GroupCallState.Entered || this.enteredViaAnotherSession;
         let nextExpiration = Infinity;
 
         for (const e of this.getMemberStateEvents()) {
@@ -1344,8 +1359,11 @@ export class GroupCall extends TypedEventEmitter<
         await this.updateDevices(devices => {
             const newDevices = devices.filter(d => {
                 const device = deviceMap.get(d.device_id);
-                return device?.last_seen_ts !== undefined
-                    && !(d.device_id === this.client.getDeviceId()! && this.state !== GroupCallState.Entered);
+                return device?.last_seen_ts !== undefined && !(
+                    d.device_id === this.client.getDeviceId()!
+                    && this.state !== GroupCallState.Entered
+                    && !this.enteredViaAnotherSession
+                );
             });
 
             // Skip the update if the devices are unchanged

From 9de9ff76b50c24d401c87c6bdd29a9f4e2c161ac Mon Sep 17 00:00:00 2001
From: Robin Townsend <robin@robin.town>
Date: Thu, 1 Dec 2022 23:27:31 -0500
Subject: [PATCH 13/60] Test cleanMemberState

---
 spec/test-utils/webrtc.ts          |   3 +
 spec/unit/webrtc/groupCall.spec.ts | 166 +++++++++++++++++++++++++++--
 2 files changed, 163 insertions(+), 6 deletions(-)

diff --git a/spec/test-utils/webrtc.ts b/spec/test-utils/webrtc.ts
index 8d9423796a3..6a1b1a35794 100644
--- a/spec/test-utils/webrtc.ts
+++ b/spec/test-utils/webrtc.ts
@@ -416,6 +416,9 @@ export class MockCallMatrixClient extends TypedEventEmitter<EmittedEvents, Emitt
     public getRooms = jest.fn<Room[], []>().mockReturnValue([]);
     public getRoom = jest.fn();
 
+    public supportsExperimentalThreads(): boolean { return true; }
+    public async decryptEventIfNeeded(): Promise<void> {}
+
     public typed(): MatrixClient { return this as unknown as MatrixClient; }
 
     public emitRoomState(event: MatrixEvent, state: RoomState): void {
diff --git a/spec/unit/webrtc/groupCall.spec.ts b/spec/unit/webrtc/groupCall.spec.ts
index 7085f50c12d..3c9266b98c8 100644
--- a/spec/unit/webrtc/groupCall.spec.ts
+++ b/spec/unit/webrtc/groupCall.spec.ts
@@ -25,7 +25,7 @@ import {
 } from '../../../src';
 import { RoomStateEvent } from "../../../src/models/room-state";
 import { GroupCall, GroupCallEvent, GroupCallState } from "../../../src/webrtc/groupCall";
-import { MatrixClient } from "../../../src/client";
+import { IMyDevice, MatrixClient } from "../../../src/client";
 import {
     installWebRTCMocks,
     MockCallFeed,
@@ -260,12 +260,15 @@ describe('Group Call', function() {
         });
 
         it("includes local device in participants when entered via another session", async () => {
-            groupCall.enteredViaAnotherSession = true;
-
-            const hasLocalParticipant = groupCall.participants.get(
+            const hasLocalParticipant = () => groupCall.participants.get(
                 room.getMember(mockClient.getUserId()!)!,
-            )?.has(mockClient.getDeviceId()!);
-            expect(hasLocalParticipant).toBe(true);
+            )?.has(mockClient.getDeviceId()!) ?? false;
+
+            expect(groupCall.enteredViaAnotherSession).toBe(false);
+            expect(hasLocalParticipant()).toBe(false);
+
+            groupCall.enteredViaAnotherSession = true;
+            expect(hasLocalParticipant()).toBe(true);
         });
 
         it("starts with mic unmuted in regular calls", async () => {
@@ -1271,4 +1274,155 @@ describe('Group Call', function() {
             });
         });
     });
+
+    describe("cleaning member state", () => {
+        const bobWeb: IMyDevice = {
+            device_id: "bobweb",
+            last_seen_ts: 0,
+        };
+        const bobDesktop: IMyDevice = {
+            device_id: "bobdesktop",
+            last_seen_ts: 0,
+        };
+        const bobDesktopOffline: IMyDevice = {
+            device_id: "bobdesktopoffline",
+            last_seen_ts: 1000 * 60 * 60 * -2, // 2 hours ago
+        };
+        const bobDesktopNeverOnline: IMyDevice = {
+            device_id: "bobdesktopneveronline",
+        };
+
+        const mkContent = (devices: IMyDevice[]) => ({
+            "m.calls": [{
+                "m.call_id": groupCall.groupCallId,
+                "m.devices": devices.map(d => ({
+                    device_id: d.device_id, session_id: "1", feeds: [], expires_ts: 1000 * 60 * 10,
+                })),
+            }],
+        });
+
+        const expectDevices = (devices: IMyDevice[]) => expect(
+            room.currentState.getStateEvents(EventType.GroupCallMemberPrefix, FAKE_USER_ID_2)?.getContent(),
+        ).toEqual({
+            "m.calls": [{
+                "m.call_id": groupCall.groupCallId,
+                "m.devices": devices.map(d => ({
+                    device_id: d.device_id, session_id: "1", feeds: [], expires_ts: expect.any(Number),
+                })),
+            }],
+        });
+
+        let mockClient: MatrixClient;
+        let room: Room;
+        let groupCall: GroupCall;
+
+        beforeAll(() => {
+            jest.useFakeTimers();
+            jest.setSystemTime(0);
+        });
+
+        afterAll(() => jest.useRealTimers());
+
+        beforeEach(async () => {
+            const typedMockClient = new MockCallMatrixClient(
+                FAKE_USER_ID_2, bobWeb.device_id, FAKE_SESSION_ID_2,
+            );
+            jest.spyOn(typedMockClient, "sendStateEvent").mockImplementation(
+                async (roomId, eventType, content, stateKey) => {
+                    const eventId = `$${Math.random()}`;
+                    if (roomId === room.roomId) {
+                        room.addLiveEvents([new MatrixEvent({
+                            event_id: eventId,
+                            type: eventType,
+                            room_id: roomId,
+                            sender: FAKE_USER_ID_2,
+                            content,
+                            state_key: stateKey,
+                        })]);
+                    }
+                    return { event_id: eventId };
+                },
+            );
+            mockClient = typedMockClient as unknown as MatrixClient;
+
+            room = new Room(FAKE_ROOM_ID, mockClient, FAKE_USER_ID_2);
+            room.getMember = jest.fn().mockImplementation((userId) => ({ userId }));
+
+            groupCall = new GroupCall(
+                mockClient,
+                room,
+                GroupCallType.Video,
+                false,
+                GroupCallIntent.Prompt,
+                FAKE_CONF_ID,
+            );
+            await groupCall.create();
+
+            mockClient.getDevices = async () => ({
+                devices: [
+                    bobWeb,
+                    bobDesktop,
+                    bobDesktopOffline,
+                    bobDesktopNeverOnline,
+                ],
+            });
+        });
+
+        afterEach(() => groupCall.leave());
+
+        it("doesn't clean up valid devices", async () => {
+            await groupCall.enter();
+            await mockClient.sendStateEvent(
+                room.roomId,
+                EventType.GroupCallMemberPrefix,
+                mkContent([bobWeb, bobDesktop]),
+                FAKE_USER_ID_2,
+            );
+
+            await groupCall.cleanMemberState();
+            expectDevices([bobWeb, bobDesktop]);
+        });
+
+        it("cleans up our own device if we're disconnected", async () => {
+            await mockClient.sendStateEvent(
+                room.roomId,
+                EventType.GroupCallMemberPrefix,
+                mkContent([bobWeb, bobDesktop]),
+                FAKE_USER_ID_2,
+            );
+
+            await groupCall.cleanMemberState();
+            expectDevices([bobDesktop]);
+        });
+
+        it("doesn't clean up the local device if entered via another session", async () => {
+            groupCall.enteredViaAnotherSession = true;
+            await mockClient.sendStateEvent(
+                room.roomId,
+                EventType.GroupCallMemberPrefix,
+                mkContent([bobWeb]),
+                FAKE_USER_ID_2,
+            );
+
+            await groupCall.cleanMemberState();
+            expectDevices([bobWeb]);
+        });
+
+        it("cleans up devices that have never been online", async () => {
+            await mockClient.sendStateEvent(
+                room.roomId,
+                EventType.GroupCallMemberPrefix,
+                mkContent([bobDesktop, bobDesktopNeverOnline]),
+                FAKE_USER_ID_2,
+            );
+
+            await groupCall.cleanMemberState();
+            expectDevices([bobDesktop]);
+        });
+
+        it("no-ops if there are no state events", async () => {
+            await groupCall.cleanMemberState();
+            expect(room.currentState.getStateEvents(EventType.GroupCallMemberPrefix, FAKE_USER_ID_2)).toBe(null);
+        });
+    });
 });

From 43bfa0c0208db3e0953c38115d21e555596b88b2 Mon Sep 17 00:00:00 2001
From: Janne Mareike Koschinski <jannemk@element.io>
Date: Fri, 2 Dec 2022 15:01:15 +0100
Subject: [PATCH 14/60] Switch to stable /relations endpoint, stop using
 unspecced original_event field (#2911)

* Switch to stable /relations endpoint, stop using unspecced original_event field
* Adapt the tests to the changed endpoint
---
 .../matrix-client-event-timeline.spec.ts      | 39 +++++++++++++++----
 spec/integ/matrix-client-relations.spec.ts    | 20 ++++++++--
 src/@types/requests.ts                        |  1 -
 src/client.ts                                 | 23 +++++------
 4 files changed, 60 insertions(+), 23 deletions(-)

diff --git a/spec/integ/matrix-client-event-timeline.spec.ts b/spec/integ/matrix-client-event-timeline.spec.ts
index fe7393bfd73..4bf36baa88c 100644
--- a/spec/integ/matrix-client-event-timeline.spec.ts
+++ b/spec/integ/matrix-client-event-timeline.spec.ts
@@ -611,7 +611,12 @@ describe("MatrixClient event timelines", function() {
                     return THREAD_ROOT;
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/relations/" +
+            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function() {
+                    return THREAD_ROOT;
+                });
+
+            httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
                 encodeURIComponent(THREAD_ROOT.event_id!) + "/" +
                 encodeURIComponent(THREAD_RELATION_TYPE.name) + "?dir=b&limit=1")
                 .respond(200, function() {
@@ -650,7 +655,6 @@ describe("MatrixClient event timelines", function() {
                 encodeURIComponent(THREAD_RELATION_TYPE.name) + "?dir=b&limit=1")
                 .respond(200, function() {
                     return {
-                        original_event: THREAD_ROOT,
                         chunk: [THREAD_REPLY],
                         // no next batch as this is the oldest end of the timeline
                     };
@@ -660,11 +664,17 @@ describe("MatrixClient event timelines", function() {
             await httpBackend.flushAllExpected();
             const timelineSet = thread.timelineSet;
 
+            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function() {
+                    return THREAD_ROOT;
+                });
+
             const timelinePromise = client.getEventTimeline(timelineSet, THREAD_REPLY.event_id!);
-            const timeline = await timelinePromise;
+            const [timeline] = await Promise.all([timelinePromise, httpBackend.flushAllExpected()]);
 
-            expect(timeline!.getEvents().find(e => e.getId() === THREAD_ROOT.event_id!)).toBeTruthy();
-            expect(timeline!.getEvents().find(e => e.getId() === THREAD_REPLY.event_id!)).toBeTruthy();
+            const eventIds = timeline!.getEvents().map(it => it.getId());
+            expect(eventIds).toContain(THREAD_ROOT.event_id);
+            expect(eventIds).toContain(THREAD_REPLY.event_id);
         });
 
         it("should return relevant timeline from non-thread timelineSet when asking for the thread root", async () => {
@@ -1504,7 +1514,22 @@ describe("MatrixClient event timelines", function() {
                     state: [],
                     end: "end_token",
                 });
-            httpBackend.when("GET", "/rooms/!foo%3Abar/relations/" +
+            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" +
+                encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function() {
+                    return THREAD_ROOT;
+                });
+            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" +
+                encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function() {
+                    return THREAD_ROOT;
+                });
+            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" +
+                encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function() {
+                    return THREAD_ROOT;
+                });
+            httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
                 encodeURIComponent(THREAD_ROOT.event_id!) + "/" +
                 encodeURIComponent(THREAD_RELATION_TYPE.name) + buildParams(Direction.Backward, "start_token"))
                 .respond(200, function() {
@@ -1513,7 +1538,7 @@ describe("MatrixClient event timelines", function() {
                         chunk: [],
                     };
                 });
-            httpBackend.when("GET", "/rooms/!foo%3Abar/relations/" +
+            httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
                 encodeURIComponent(THREAD_ROOT.event_id!) + "/" +
                 encodeURIComponent(THREAD_RELATION_TYPE.name) + buildParams(Direction.Forward, "end_token"))
                 .respond(200, function() {
diff --git a/spec/integ/matrix-client-relations.spec.ts b/spec/integ/matrix-client-relations.spec.ts
index 456db2efb07..5a4fa2bd0dc 100644
--- a/spec/integ/matrix-client-relations.spec.ts
+++ b/spec/integ/matrix-client-relations.spec.ts
@@ -55,7 +55,10 @@ describe("MatrixClient relations", () => {
         const response = client!.relations(roomId, '$event-0', null, null);
 
         httpBackend!
-            .when("GET", "/rooms/!room%3Ahere/relations/%24event-0?dir=b")
+            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
+            .respond(200, null);
+        httpBackend!
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0?dir=b")
             .respond(200, { chunk: [], next_batch: 'NEXT' });
 
         await httpBackend!.flushAllExpected();
@@ -67,7 +70,10 @@ describe("MatrixClient relations", () => {
         const response = client!.relations(roomId, '$event-0', 'm.reference', null);
 
         httpBackend!
-            .when("GET", "/rooms/!room%3Ahere/relations/%24event-0/m.reference?dir=b")
+            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
+            .respond(200, null);
+        httpBackend!
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0/m.reference?dir=b")
             .respond(200, { chunk: [], next_batch: 'NEXT' });
 
         await httpBackend!.flushAllExpected();
@@ -78,10 +84,13 @@ describe("MatrixClient relations", () => {
     it("should read related events with relation type and event type", async () => {
         const response = client!.relations(roomId, '$event-0', 'm.reference', 'm.room.message');
 
+        httpBackend!
+            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
+            .respond(200, null);
         httpBackend!
             .when(
                 "GET",
-                "/rooms/!room%3Ahere/relations/%24event-0/m.reference/m.room.message?dir=b",
+                "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0/m.reference/m.room.message?dir=b",
             )
             .respond(200, { chunk: [], next_batch: 'NEXT' });
 
@@ -98,10 +107,13 @@ describe("MatrixClient relations", () => {
             to: 'TO',
         });
 
+        httpBackend!
+            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
+            .respond(200, null);
         httpBackend!
             .when(
                 "GET",
-                "/rooms/!room%3Ahere/relations/%24event-0?dir=f&from=FROM&limit=10&to=TO",
+                "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0?dir=f&from=FROM&limit=10&to=TO",
             )
             .respond(200, { chunk: [], next_batch: 'NEXT' });
 
diff --git a/src/@types/requests.ts b/src/@types/requests.ts
index f9095455e15..936ace5b46e 100644
--- a/src/@types/requests.ts
+++ b/src/@types/requests.ts
@@ -153,7 +153,6 @@ export interface IRelationsRequestOpts {
 }
 
 export interface IRelationsResponse {
-    original_event: IEvent;
     chunk: IEvent[];
     next_batch?: string;
     prev_batch?: string;
diff --git a/src/client.ts b/src/client.ts
index 42709446ecc..355a0af0e33 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -5469,7 +5469,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
                 timelineSet.addEventsToTimeline(events, true, timeline, resNewer.next_batch);
                 if (!resOlder.next_batch) {
-                    timelineSet.addEventsToTimeline([mapper(resOlder.original_event)], true, timeline, null);
+                    const originalEvent = await this.fetchRoomEvent(timelineSet.room.roomId, thread.id);
+                    timelineSet.addEventsToTimeline([mapper(originalEvent)], true, timeline, null);
                 }
                 timeline.setPaginationToken(resOlder.next_batch ?? null, Direction.Backward);
                 timeline.setPaginationToken(resNewer.next_batch ?? null, Direction.Forward);
@@ -5526,7 +5527,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
                 timelineSet.addEventsToTimeline(events, true, timeline, null);
                 if (!resOlder.next_batch) {
-                    timelineSet.addEventsToTimeline([mapper(resOlder.original_event)], true, timeline, null);
+                    const originalEvent = await this.fetchRoomEvent(timelineSet.room.roomId, thread.id);
+                    timelineSet.addEventsToTimeline([mapper(originalEvent)], true, timeline, null);
                 }
                 timeline.setPaginationToken(resOlder.next_batch ?? null, Direction.Backward);
                 timeline.setPaginationToken(null, Direction.Forward);
@@ -5878,7 +5880,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 const timelineSet = eventTimeline.getTimelineSet();
                 timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, newToken ?? null);
                 if (!newToken && backwards) {
-                    timelineSet.addEventsToTimeline([mapper(res.original_event)], true, eventTimeline, null);
+                    const originalEvent = await this.fetchRoomEvent(eventTimeline.getRoomId() ?? "", thread.id);
+                    timelineSet.addEventsToTimeline([mapper(originalEvent)], true, eventTimeline, null);
                 }
                 this.processBeaconEvents(timelineSet.room, matrixEvents);
 
@@ -7099,15 +7102,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         prevBatch?: string | null;
     }> {
         const fetchedEventType = eventType ? this.getEncryptedIfNeededEventType(roomId, eventType) : null;
-        const result = await this.fetchRelations(
-            roomId,
-            eventId,
-            relationType,
-            fetchedEventType,
-            opts);
+        const [eventResult, result] = await Promise.all([
+            this.fetchRoomEvent(roomId, eventId),
+            this.fetchRelations(roomId, eventId, relationType, fetchedEventType, opts),
+        ]);
         const mapper = this.getEventMapper();
 
-        const originalEvent = result.original_event ? mapper(result.original_event) : undefined;
+        const originalEvent = eventResult ? mapper(eventResult) : undefined;
         let events = result.chunk.map(mapper);
 
         if (fetchedEventType === EventType.RoomMessageEncrypted) {
@@ -7669,7 +7670,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             });
         return this.http.authedRequest(
             Method.Get, path, undefined, undefined, {
-                prefix: ClientPrefix.Unstable,
+                prefix: ClientPrefix.V1,
             },
         );
     }

From 720248466f871cb3d6c49b931492e3a02f7538a8 Mon Sep 17 00:00:00 2001
From: Janne Mareike Koschinski <jannemk@element.io>
Date: Fri, 2 Dec 2022 15:01:43 +0100
Subject: [PATCH 15/60] Include pending events in thread summary and count
 again (#2922)

* Include pending events in thread summary and count again
* Pass through pending event status
---
 spec/unit/models/thread.spec.ts | 50 +++++++++++++++++++++++++++++++--
 src/models/room.ts              |  1 +
 src/models/thread.ts            | 26 ++++++++++++++---
 3 files changed, 71 insertions(+), 6 deletions(-)

diff --git a/spec/unit/models/thread.spec.ts b/spec/unit/models/thread.spec.ts
index 37e77954795..1ffb466370f 100644
--- a/spec/unit/models/thread.spec.ts
+++ b/spec/unit/models/thread.spec.ts
@@ -14,11 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MatrixClient } from "../../../src/client";
+import { MatrixClient, PendingEventOrdering } from "../../../src/client";
 import { Room } from "../../../src/models/room";
-import { Thread } from "../../../src/models/thread";
+import { Thread, THREAD_RELATION_TYPE, ThreadEvent } from "../../../src/models/thread";
 import { mkThread } from "../../test-utils/thread";
 import { TestClient } from "../../TestClient";
+import { emitPromise, mkMessage } from "../../test-utils/test-utils";
+import { EventStatus } from "../../../src";
 
 describe('Thread', () => {
     describe("constructor", () => {
@@ -30,6 +32,50 @@ describe('Thread', () => {
         });
     });
 
+    it("includes pending events in replyCount", async () => {
+        const myUserId = "@bob:example.org";
+        const testClient = new TestClient(
+            myUserId,
+            "DEVICE",
+            "ACCESS_TOKEN",
+            undefined,
+            { timelineSupport: false },
+        );
+        const client = testClient.client;
+        const room = new Room("123", client, myUserId, {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+
+        jest.spyOn(client, "getRoom").mockReturnValue(room);
+
+        const { thread } = mkThread({
+            room,
+            client,
+            authorId: myUserId,
+            participantUserIds: ["@alice:example.org"],
+            length: 3,
+        });
+        await emitPromise(thread, ThreadEvent.Update);
+        expect(thread.length).toBe(2);
+
+        const event = mkMessage({
+            room: room.roomId,
+            user: myUserId,
+            msg: "thread reply",
+            relatesTo: {
+                rel_type: THREAD_RELATION_TYPE.name,
+                event_id: thread.id,
+            },
+            event: true,
+        });
+        await thread.processEvent(event);
+        event.setStatus(EventStatus.SENDING);
+        room.addPendingEvent(event, "txn01");
+
+        await emitPromise(thread, ThreadEvent.Update);
+        expect(thread.length).toBe(3);
+    });
+
     describe("hasUserReadEvent", () => {
         const myUserId = "@bob:example.org";
         let client: MatrixClient;
diff --git a/src/models/room.ts b/src/models/room.ts
index de3d18733de..7c01fca5ca7 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -2017,6 +2017,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         const thread = new Thread(threadId, rootEvent, {
             room: this,
             client: this.client,
+            pendingEventOrdering: this.opts.pendingEventOrdering,
         });
 
         // This is necessary to be able to jump to events in threads:
diff --git a/src/models/thread.ts b/src/models/thread.ts
index 8c9826c35ec..d641ba8ec3b 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -16,10 +16,10 @@ limitations under the License.
 
 import { Optional } from "matrix-events-sdk";
 
-import { MatrixClient } from "../client";
+import { MatrixClient, PendingEventOrdering } from "../client";
 import { TypedReEmitter } from "../ReEmitter";
 import { RelationType } from "../@types/event";
-import { IThreadBundledRelationship, MatrixEvent, MatrixEventEvent } from "./event";
+import { EventStatus, IThreadBundledRelationship, MatrixEvent, MatrixEventEvent } from "./event";
 import { EventTimeline } from "./event-timeline";
 import { EventTimelineSet, EventTimelineSetHandlerMap } from './event-timeline-set';
 import { NotificationCountType, Room, RoomEvent } from './room';
@@ -51,6 +51,7 @@ export type EventHandlerMap = {
 interface IThreadOpts {
     room: Room;
     client: MatrixClient;
+    pendingEventOrdering?: PendingEventOrdering;
 }
 
 export enum FeatureSupport {
@@ -88,9 +89,12 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
     private lastEvent: MatrixEvent | undefined;
     private replyCount = 0;
+    private lastPendingEvent: MatrixEvent | undefined;
+    private pendingReplyCount = 0;
 
     public readonly room: Room;
     public readonly client: MatrixClient;
+    private readonly pendingEventOrdering: PendingEventOrdering;
 
     public initialEventsFetched = !Thread.hasServerSideSupport;
 
@@ -109,6 +113,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
         this.room = opts.room;
         this.client = opts.client;
+        this.pendingEventOrdering = opts.pendingEventOrdering ?? PendingEventOrdering.Chronological;
         this.timelineSet = new EventTimelineSet(this.room, {
             timelineSupport: true,
             pendingEvents: true,
@@ -300,6 +305,19 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             bundledRelationship = this.getRootEventBundledRelationship();
         }
 
+        let pendingEvents: MatrixEvent[];
+        if (this.pendingEventOrdering === PendingEventOrdering.Detached) {
+            pendingEvents = this.room.getPendingEvents()
+                .filter(ev => ev.isRelation(THREAD_RELATION_TYPE.name) && this.id === ev.threadRootId);
+            await Promise.all(pendingEvents.map(ev => this.processEvent(ev)));
+        } else {
+            pendingEvents = this.events
+                .filter(ev => ev.isRelation(THREAD_RELATION_TYPE.name))
+                .filter(ev => ev.status !== EventStatus.SENT && ev.status !== EventStatus.CANCELLED);
+        }
+        this.lastPendingEvent = pendingEvents.length ? pendingEvents[pendingEvents.length - 1] : undefined;
+        this.pendingReplyCount = pendingEvents.length;
+
         if (Thread.hasServerSideSupport && bundledRelationship) {
             this.replyCount = bundledRelationship.count;
             this._currentUserParticipated = !!bundledRelationship.current_user_participated;
@@ -393,14 +411,14 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
      * exclude annotations from that number
      */
     public get length(): number {
-        return this.replyCount;
+        return this.replyCount + this.pendingReplyCount;
     }
 
     /**
      * A getter for the last event added to the thread, if known.
      */
     public get replyToEvent(): Optional<MatrixEvent> {
-        return this.lastEvent ?? this.lastReply();
+        return this.lastPendingEvent ?? this.lastEvent ?? this.lastReply();
     }
 
     public get events(): MatrixEvent[] {

From fa2eeac5b827bac79af8e1ccb4763a856118231d Mon Sep 17 00:00:00 2001
From: Janne Mareike Koschinski <jannemk@element.io>
Date: Fri, 2 Dec 2022 15:50:19 +0100
Subject: [PATCH 16/60] Improve perceived performance for threads (#2901)

* Improve perceived performance for threads
* Improve method naming and make it private
---
 src/models/thread.ts | 45 +++++++++++++++++++++++++++-----------------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/src/models/thread.ts b/src/models/thread.ts
index d641ba8ec3b..93b6e046024 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -132,7 +132,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
         // even if this thread is thought to be originating from this client, we initialise it as we may be in a
         // gappy sync and a thread around this event may already exist.
-        this.initialiseThread();
+        this.updateThreadMetadata();
         this.setEventMetadata(this.rootEvent);
     }
 
@@ -193,7 +193,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             this._currentUserParticipated = false;
             this.emit(ThreadEvent.Delete, this);
         } else {
-            await this.initialiseThread();
+            await this.updateThreadMetadata();
         }
     };
 
@@ -214,7 +214,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         if (this.lastEvent === event) return;
         if (!event.isRelation(THREAD_RELATION_TYPE.name)) return;
 
-        await this.initialiseThread();
+        await this.updateThreadMetadata();
         this.emit(ThreadEvent.NewReply, this, event);
     };
 
@@ -238,7 +238,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
     public addEvents(events: MatrixEvent[], toStartOfTimeline: boolean): void {
         events.forEach(ev => this.addEvent(ev, toStartOfTimeline, false));
-        this.initialiseThread();
+        this.updateThreadMetadata();
     }
 
     /**
@@ -283,7 +283,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
         if (emit) {
             this.emit(ThreadEvent.NewReply, this, event);
-            this.initialiseThread();
+            this.updateThreadMetadata();
         }
     }
 
@@ -298,11 +298,19 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         return rootEvent?.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
     }
 
-    public async initialiseThread(): Promise<void> {
-        let bundledRelationship = this.getRootEventBundledRelationship();
-        if (Thread.hasServerSideSupport) {
-            await this.fetchRootEvent();
-            bundledRelationship = this.getRootEventBundledRelationship();
+    private async processRootEvent(): Promise<void> {
+        const bundledRelationship = this.getRootEventBundledRelationship();
+        if (Thread.hasServerSideSupport && bundledRelationship) {
+            this.replyCount = bundledRelationship.count;
+            this._currentUserParticipated = !!bundledRelationship.current_user_participated;
+
+            const mapper = this.client.getEventMapper();
+            // re-insert roomId
+            this.lastEvent = mapper({
+                ...bundledRelationship.latest_event,
+                room_id: this.roomId,
+            });
+            await this.processEvent(this.lastEvent);
         }
 
         let pendingEvents: MatrixEvent[];
@@ -317,15 +325,18 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         }
         this.lastPendingEvent = pendingEvents.length ? pendingEvents[pendingEvents.length - 1] : undefined;
         this.pendingReplyCount = pendingEvents.length;
+    }
 
-        if (Thread.hasServerSideSupport && bundledRelationship) {
-            this.replyCount = bundledRelationship.count;
-            this._currentUserParticipated = !!bundledRelationship.current_user_participated;
-
-            const mapper = this.client.getEventMapper();
-            this.lastEvent = mapper(bundledRelationship.latest_event);
-            await this.processEvent(this.lastEvent);
+    private async updateThreadMetadata(): Promise<void> {
+        if (Thread.hasServerSideSupport) {
+            // Ensure we show *something* as soon as possible, we'll update it as soon as we get better data, but we
+            // don't want the thread preview to be empty if we can avoid it
+            if (!this.initialEventsFetched) {
+                await this.processRootEvent();
+            }
+            await this.fetchRootEvent();
         }
+        await this.processRootEvent();
 
         if (!this.initialEventsFetched) {
             this.initialEventsFetched = true;

From 53a45a34dffc500a21af7774c1a9217f5733cf0f Mon Sep 17 00:00:00 2001
From: Germain <germains@element.io>
Date: Fri, 2 Dec 2022 15:41:15 +0000
Subject: [PATCH 17/60] Fix highlight notifications increasing when total
 notification is zero (#2937)

---
 spec/unit/notifications.spec.ts |  4 ++--
 src/client.ts                   |  3 +--
 src/models/room.ts              |  2 +-
 src/models/thread.ts            | 13 ++++++-------
 4 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/spec/unit/notifications.spec.ts b/spec/unit/notifications.spec.ts
index d7936014b7d..e7e637d4acc 100644
--- a/spec/unit/notifications.spec.ts
+++ b/spec/unit/notifications.spec.ts
@@ -114,8 +114,8 @@ describe("fixNotificationCountOnDecryption", () => {
 
         fixNotificationCountOnDecryption(mockClient, event);
 
-        expect(room.getRoomUnreadNotificationCount(NotificationCountType.Total)).toBe(0);
-        expect(room.getRoomUnreadNotificationCount(NotificationCountType.Highlight)).toBe(0);
+        expect(room.getRoomUnreadNotificationCount(NotificationCountType.Total)).toBe(1);
+        expect(room.getRoomUnreadNotificationCount(NotificationCountType.Highlight)).toBe(1);
     });
 
     it("changes the thread count to highlight on decryption", () => {
diff --git a/src/client.ts b/src/client.ts
index 355a0af0e33..9abcd967f70 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -9379,7 +9379,6 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
 
     const isThreadEvent = !!event.threadRootId && !event.isThreadRoot;
 
-    const totalCount = room.getUnreadCountForEventContext(NotificationCountType.Total, event);
     const currentCount = room.getUnreadCountForEventContext(NotificationCountType.Highlight, event);
 
     // Ensure the unread counts are kept up to date if the event is encrypted
@@ -9387,7 +9386,7 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
     // have encrypted events to avoid other code from resetting 'highlight' to zero.
     const oldHighlight = !!oldActions?.tweaks?.highlight;
     const newHighlight = !!actions?.tweaks?.highlight;
-    if ((oldHighlight !== newHighlight || currentCount > 0) && totalCount > 0) {
+    if (oldHighlight !== newHighlight || currentCount > 0) {
         // TODO: Handle mentions received while the client is offline
         // See also https://github.com/vector-im/element-web/issues/9069
         const hasReadEvent = isThreadEvent
diff --git a/src/models/room.ts b/src/models/room.ts
index 7c01fca5ca7..ceac37135c8 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -1696,7 +1696,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             Array.from(this.threads)
                 .forEach(([, thread]) => {
                     if (thread.length === 0) return;
-                    const currentUserParticipated = thread.events.some(event => {
+                    const currentUserParticipated = thread.timeline.some(event => {
                         return event.getSender() === this.client.getUserId();
                     });
                     if (filterType !== ThreadFilterType.My || currentUserParticipated) {
diff --git a/src/models/thread.ts b/src/models/thread.ts
index 93b6e046024..c595995b1cc 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -82,6 +82,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
      * A reference to all the events ID at the bottom of the threads
      */
     public readonly timelineSet: EventTimelineSet;
+    public timeline: MatrixEvent[] = [];
 
     private _currentUserParticipated = false;
 
@@ -186,7 +187,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
     private onRedaction = async (event: MatrixEvent): Promise<void> => {
         if (event.threadRootId !== this.id) return; // ignore redactions for other timelines
         if (this.replyCount <= 0) {
-            for (const threadEvent of this.events) {
+            for (const threadEvent of this.timeline) {
                 this.clearEventMetadata(threadEvent);
             }
             this.lastEvent = this.rootEvent;
@@ -233,6 +234,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
                     roomState: this.roomState,
                 },
             );
+            this.timeline = this.events;
         }
     }
 
@@ -292,6 +294,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             this.setEventMetadata(event);
             await this.fetchEditsWhereNeeded(event);
         }
+        this.timeline = this.events;
     }
 
     private getRootEventBundledRelationship(rootEvent = this.rootEvent): IThreadBundledRelationship | undefined {
@@ -403,8 +406,8 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
      * Return last reply to the thread, if known.
      */
     public lastReply(matches: (ev: MatrixEvent) => boolean = (): boolean => true): MatrixEvent | null {
-        for (let i = this.events.length - 1; i >= 0; i--) {
-            const event = this.events[i];
+        for (let i = this.timeline.length - 1; i >= 0; i--) {
+            const event = this.timeline[i];
             if (matches(event)) {
                 return event;
             }
@@ -452,10 +455,6 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         return this.timelineSet;
     }
 
-    public get timeline(): MatrixEvent[] {
-        return this.events;
-    }
-
     public addReceipt(event: MatrixEvent, synthetic: boolean): void {
         throw new Error("Unsupported function on the thread model");
     }

From 8a7fd270e473329ed1fc4619a92cff557a0486c1 Mon Sep 17 00:00:00 2001
From: Janne Mareike Koschinski <jannemk@element.io>
Date: Fri, 2 Dec 2022 17:11:18 +0100
Subject: [PATCH 18/60] Move updated threads to the end of the thread list
 (#2923)

* Move updated threads to the end of the thread list
* Write new tests
---
 .../matrix-client-event-timeline.spec.ts      | 154 +++++++++++++++++-
 src/models/room.ts                            |  14 +-
 2 files changed, 160 insertions(+), 8 deletions(-)

diff --git a/spec/integ/matrix-client-event-timeline.spec.ts b/spec/integ/matrix-client-event-timeline.spec.ts
index 4bf36baa88c..663af8fbfcd 100644
--- a/spec/integ/matrix-client-event-timeline.spec.ts
+++ b/spec/integ/matrix-client-event-timeline.spec.ts
@@ -27,11 +27,13 @@ import {
     MatrixEvent,
     PendingEventOrdering,
     Room,
+    RoomEvent,
 } from "../../src/matrix";
 import { logger } from "../../src/logger";
 import { encodeUri } from "../../src/utils";
 import { TestClient } from "../TestClient";
 import { FeatureSupport, Thread, THREAD_RELATION_TYPE } from "../../src/models/thread";
+import { emitPromise } from "../test-utils/test-utils";
 
 const userId = "@alice:localhost";
 const userName = "Alice";
@@ -1093,10 +1095,27 @@ describe("MatrixClient event timelines", function() {
             return request;
         }
 
-        function respondToContext(): ExpectedHttpRequest {
+        function respondToThread(
+            root: Partial<IEvent>,
+            replies: Partial<IEvent>[],
+        ): ExpectedHttpRequest {
+            const request = httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
+                encodeURIComponent(root.event_id!) + "/" +
+                encodeURIComponent(THREAD_RELATION_TYPE.name) + "?dir=b&limit=1");
+            request.respond(200, function() {
+                return {
+                    original_event: root,
+                    chunk: [replies],
+                    // no next batch as this is the oldest end of the timeline
+                };
+            });
+            return request;
+        }
+
+        function respondToContext(event: Partial<IEvent> = THREAD_ROOT): ExpectedHttpRequest {
             const request = httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/context/$eventId", {
                 $roomId: roomId,
-                $eventId: THREAD_ROOT.event_id!,
+                $eventId: event.event_id!,
             }));
             request.respond(200, {
                 end: `${Direction.Forward}${RANDOM_TOKEN}1`,
@@ -1104,10 +1123,18 @@ describe("MatrixClient event timelines", function() {
                 state: [],
                 events_before: [],
                 events_after: [],
-                event: THREAD_ROOT,
+                event: event,
             });
             return request;
         }
+        function respondToEvent(event: Partial<IEvent> = THREAD_ROOT): ExpectedHttpRequest {
+            const request = httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/event/$eventId", {
+                $roomId: roomId,
+                $eventId: event.event_id!,
+            }));
+            request.respond(200, event);
+            return request;
+        }
         function respondToMessagesRequest(): ExpectedHttpRequest {
             const request = httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/messages", {
                 $roomId: roomId,
@@ -1193,6 +1220,127 @@ describe("MatrixClient event timelines", function() {
                 expect(myThreads.getPendingEvents()).toHaveLength(0);
                 expect(room.getPendingEvents()).toHaveLength(1);
             });
+
+            it("should handle thread updates by reordering the thread list", async () => {
+                // Test data for a second thread
+                const THREAD2_ROOT = utils.mkEvent({
+                    room: roomId,
+                    user: userId,
+                    type: "m.room.message",
+                    content: {
+                        "body": "thread root",
+                        "msgtype": "m.text",
+                    },
+                    unsigned: {
+                        "m.relations": {
+                            "io.element.thread": {
+                                //"latest_event": undefined,
+                                "count": 1,
+                                "current_user_participated": true,
+                            },
+                        },
+                    },
+                    event: false,
+                });
+
+                const THREAD2_REPLY = utils.mkEvent({
+                    room: roomId,
+                    user: userId,
+                    type: "m.room.message",
+                    content: {
+                        "body": "thread reply",
+                        "msgtype": "m.text",
+                        "m.relates_to": {
+                            // We can't use the const here because we change server support mode for test
+                            rel_type: "io.element.thread",
+                            event_id: THREAD_ROOT.event_id,
+                        },
+                    },
+                    event: false,
+                });
+
+                // @ts-ignore we know this is a defined path for THREAD ROOT
+                THREAD2_ROOT.unsigned["m.relations"]["io.element.thread"].latest_event = THREAD2_REPLY;
+
+                // Test data for a second reply to the first thread
+                const THREAD_REPLY2 = utils.mkEvent({
+                    room: roomId,
+                    user: userId,
+                    type: "m.room.message",
+                    content: {
+                        "body": "thread reply",
+                        "msgtype": "m.text",
+                        "m.relates_to": {
+                            // We can't use the const here because we change server support mode for test
+                            rel_type: "io.element.thread",
+                            event_id: THREAD_ROOT.event_id,
+                        },
+                    },
+                    event: false,
+                });
+
+                // Test data for the first thread, with the second reply
+                const THREAD_ROOT_UPDATED = {
+                    ...THREAD_ROOT,
+                    unsigned: {
+                        ...THREAD_ROOT.unsigned,
+                        "m.relations": {
+                            ...THREAD_ROOT.unsigned!["m.relations"],
+                            "io.element.thread": {
+                                ...THREAD_ROOT.unsigned!["m.relations"]!["io.element.thread"],
+                                count: 2,
+                                latest_event: THREAD_REPLY2,
+                            },
+                        },
+                    },
+                };
+
+                // Response with test data for the thread list request
+                const threadsResponse = {
+                    chunk: [THREAD2_ROOT, THREAD_ROOT],
+                    state: [],
+                    next_batch: RANDOM_TOKEN as string | null,
+                };
+
+                // @ts-ignore
+                client.clientOpts.experimentalThreadSupport = true;
+                Thread.setServerSideSupport(FeatureSupport.Stable);
+                Thread.setServerSideListSupport(FeatureSupport.Stable);
+                Thread.setServerSideFwdPaginationSupport(FeatureSupport.Stable);
+
+                await client.stopClient(); // we don't need the client to be syncing at this time
+                const room = client.getRoom(roomId)!;
+
+                // Setup room threads
+                const timelineSets = await room!.createThreadsTimelineSets();
+                expect(timelineSets).not.toBeNull();
+                respondToThreads(threadsResponse);
+                respondToThreads(threadsResponse);
+                respondToEvent(THREAD_ROOT);
+                respondToEvent(THREAD_ROOT);
+                respondToEvent(THREAD2_ROOT);
+                respondToEvent(THREAD2_ROOT);
+                respondToThread(THREAD_ROOT, [THREAD_REPLY]);
+                respondToThread(THREAD2_ROOT, [THREAD2_REPLY]);
+                await flushHttp(room.fetchRoomThreads());
+                const [allThreads] = timelineSets!;
+                const timeline = allThreads.getLiveTimeline()!;
+                // Test threads are in chronological order
+                expect(timeline.getEvents().map(it => it.event.event_id))
+                    .toEqual([THREAD_ROOT.event_id, THREAD2_ROOT.event_id]);
+
+                // Test adding a second event to the first thread
+                const thread = room.getThread(THREAD_ROOT.event_id!)!;
+                const prom = emitPromise(allThreads!, RoomEvent.Timeline);
+                await thread.addEvent(client.getEventMapper()(THREAD_REPLY2), false);
+                respondToEvent(THREAD_ROOT_UPDATED);
+                respondToEvent(THREAD_ROOT_UPDATED);
+                await httpBackend.flushAllExpected();
+                await prom;
+                // Test threads are in chronological order
+                expect(timeline!.getEvents().map(it => it.event.event_id))
+                    .toEqual([THREAD2_ROOT.event_id, THREAD_ROOT.event_id]);
+            });
         });
 
         describe("without server compatibility", function() {
diff --git a/src/models/room.ts b/src/models/room.ts
index ceac37135c8..3952ed7d9cb 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -1843,7 +1843,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     }
 
     private onThreadNewReply(thread: Thread): void {
-        this.updateThreadRootEvents(thread, false);
+        this.updateThreadRootEvents(thread, false, true);
     }
 
     private onThreadDelete(thread: Thread): void {
@@ -1968,11 +1968,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         ));
     }
 
-    private updateThreadRootEvents = (thread: Thread, toStartOfTimeline: boolean): void => {
+    private updateThreadRootEvents = (thread: Thread, toStartOfTimeline: boolean, recreateEvent: boolean): void => {
         if (thread.length) {
-            this.updateThreadRootEvent(this.threadsTimelineSets?.[0], thread, toStartOfTimeline);
+            this.updateThreadRootEvent(this.threadsTimelineSets?.[0], thread, toStartOfTimeline, recreateEvent);
             if (thread.hasCurrentUserParticipated) {
-                this.updateThreadRootEvent(this.threadsTimelineSets?.[1], thread, toStartOfTimeline);
+                this.updateThreadRootEvent(this.threadsTimelineSets?.[1], thread, toStartOfTimeline, recreateEvent);
             }
         }
     };
@@ -1981,8 +1981,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         timelineSet: Optional<EventTimelineSet>,
         thread: Thread,
         toStartOfTimeline: boolean,
+        recreateEvent: boolean,
     ): void => {
         if (timelineSet && thread.rootEvent) {
+            if (recreateEvent) {
+                timelineSet.removeEvent(thread.id);
+            }
             if (Thread.hasServerSideSupport) {
                 timelineSet.addLiveEvent(thread.rootEvent, {
                     duplicateStrategy: DuplicateStrategy.Replace,
@@ -2046,7 +2050,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
 
         if (this.threadsReady) {
-            this.updateThreadRootEvents(thread, toStartOfTimeline);
+            this.updateThreadRootEvents(thread, toStartOfTimeline, false);
         }
 
         this.emit(ThreadEvent.New, thread, toStartOfTimeline);

From 779980476273a7356131dc63dd3fd4bbdf420523 Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Fri, 2 Dec 2022 16:27:59 +0000
Subject: [PATCH 19/60] Move @types deps into devDeps (#2927)

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 969c71cba4a..5cfc418633d 100644
--- a/package.json
+++ b/package.json
@@ -54,7 +54,6 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.5",
-    "@types/sdp-transform": "^2.4.5",
     "another-json": "^0.2.0",
     "bs58": "^5.0.0",
     "content-type": "^1.0.4",
@@ -86,6 +85,7 @@
     "@types/domexception": "^4.0.0",
     "@types/jest": "^29.0.0",
     "@types/node": "18",
+    "@types/sdp-transform": "^2.4.5",
     "@typescript-eslint/eslint-plugin": "^5.6.0",
     "@typescript-eslint/parser": "^5.6.0",
     "allchange": "^1.0.6",

From 11d8f562c5776ef694690428169330a338d98d38 Mon Sep 17 00:00:00 2001
From: Michael Weimann <michaelw@matrix.org>
Date: Mon, 5 Dec 2022 14:31:58 +0100
Subject: [PATCH 20/60] Redo key sharing after own device verification (#2921)

---
 .../setDeviceVerification.spec.ts             | 60 +++++++++++++++++++
 src/crypto/index.ts                           |  3 +
 2 files changed, 63 insertions(+)
 create mode 100644 spec/unit/crypto/verification/setDeviceVerification.spec.ts

diff --git a/spec/unit/crypto/verification/setDeviceVerification.spec.ts b/spec/unit/crypto/verification/setDeviceVerification.spec.ts
new file mode 100644
index 00000000000..3d64153ab59
--- /dev/null
+++ b/spec/unit/crypto/verification/setDeviceVerification.spec.ts
@@ -0,0 +1,60 @@
+/*
+Copyright 2022 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 '../../../olm-loader';
+
+import { CRYPTO_ENABLED, MatrixClient } from "../../../../src/client";
+import { TestClient } from "../../../TestClient";
+
+const Olm = global.Olm;
+
+describe("crypto.setDeviceVerification", () => {
+    const userId = "@alice:example.com";
+    const deviceId1 = "device1";
+    let client: MatrixClient;
+
+    if (!CRYPTO_ENABLED) {
+        return;
+    }
+
+    beforeAll(async () => {
+        await Olm.init();
+    });
+
+    beforeEach(async () => {
+        client = (new TestClient(userId, deviceId1)).client;
+        await client.initCrypto();
+    });
+
+    it("client should provide crypto", () => {
+        expect(client.crypto).not.toBeUndefined();
+    });
+
+    describe("when setting an own device as verified", () => {
+        beforeEach(async () => {
+            jest.spyOn(client.crypto!, "cancelAndResendAllOutgoingKeyRequests");
+            await client.crypto!.setDeviceVerification(
+                userId,
+                deviceId1,
+                true,
+            );
+        });
+
+        it("cancelAndResendAllOutgoingKeyRequests should be called", () => {
+            expect(client.crypto!.cancelAndResendAllOutgoingKeyRequests).toHaveBeenCalled();
+        });
+    });
+});
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 0f203bc25cc..2d6995a58bb 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -2270,6 +2270,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                 await upload({ shouldEmit: true });
                 // XXX: we'll need to wait for the device list to be updated
             }
+
+            // redo key requests after verification
+            this.cancelAndResendAllOutgoingKeyRequests();
         }
 
         const deviceObj = DeviceInfo.fromStorage(dev, deviceId);

From 4a4d4938563c56d0797b1dc125da811118561ccf Mon Sep 17 00:00:00 2001
From: kegsay <kegan@matrix.org>
Date: Mon, 5 Dec 2022 17:00:06 +0000
Subject: [PATCH 21/60] bugfix: sliding sync initial room timelines shouldn't
 notify (#2933)

* bugfix: sliding sync initial room timelines shouldn't notify

Flag timeline events as `fromCache` when `initial: true` rooms
are received. This stops notifications appearing inappropriately
when you scroll the room list or spider the room list, as it
causes `liveEvent=false`.

* Use num_live to detect liveness; with jest test

* Linting

* jsdoc

Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>
---
 spec/integ/sliding-sync-sdk.spec.ts | 42 ++++++++++++++++++++++++++++-
 src/sliding-sync-sdk.ts             | 28 ++++++++++++++++---
 src/sliding-sync.ts                 |  1 +
 3 files changed, 66 insertions(+), 5 deletions(-)

diff --git a/spec/integ/sliding-sync-sdk.spec.ts b/spec/integ/sliding-sync-sdk.spec.ts
index 72a7eeaa2e9..7a37f572bba 100644
--- a/spec/integ/sliding-sync-sdk.spec.ts
+++ b/spec/integ/sliding-sync-sdk.spec.ts
@@ -23,7 +23,7 @@ import { TestClient } from "../TestClient";
 import { IRoomEvent, IStateEvent } from "../../src/sync-accumulator";
 import {
     MatrixClient, MatrixEvent, NotificationCountType, JoinRule, MatrixError,
-    EventType, IPushRules, PushRuleKind, TweakName, ClientEvent, RoomMemberEvent,
+    EventType, IPushRules, PushRuleKind, TweakName, ClientEvent, RoomMemberEvent, RoomEvent, Room, IRoomTimelineData,
 } from "../../src";
 import { SlidingSyncSdk } from "../../src/sliding-sync-sdk";
 import { SyncState } from "../../src/sync";
@@ -170,6 +170,7 @@ describe("SlidingSyncSdk", () => {
             const roomE = "!e_with_invite:localhost";
             const roomF = "!f_calc_room_name:localhost";
             const roomG = "!g_join_invite_counts:localhost";
+            const roomH = "!g_num_live:localhost";
             const data: Record<string, MSC3575RoomData> = {
                 [roomA]: {
                     name: "A",
@@ -275,6 +276,18 @@ describe("SlidingSyncSdk", () => {
                     invited_count: 2,
                     initial: true,
                 },
+                [roomH]: {
+                    name: "H",
+                    required_state: [],
+                    timeline: [
+                        mkOwnStateEvent(EventType.RoomCreate, { creator: selfUserId }, ""),
+                        mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
+                        mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
+                        mkOwnEvent(EventType.RoomMessage, { body: "live event" }),
+                    ],
+                    initial: true,
+                    num_live: 1,
+                },
             };
 
             it("can be created with required_state and timeline", () => {
@@ -326,6 +339,33 @@ describe("SlidingSyncSdk", () => {
                 expect(gotRoom.getJoinedMemberCount()).toEqual(data[roomG].joined_count);
             });
 
+            it("can be created with live events", () => {
+                let seenLiveEvent = false;
+                const listener = (
+                    ev: MatrixEvent,
+                    room?: Room,
+                    toStartOfTimeline?: boolean,
+                    deleted?: boolean,
+                    timelineData?: IRoomTimelineData,
+                ) => {
+                    if (timelineData?.liveEvent) {
+                        assertTimelineEvents([ev], data[roomH].timeline.slice(-1));
+                        seenLiveEvent = true;
+                    }
+                };
+                client!.on(RoomEvent.Timeline, listener);
+                mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomH, data[roomH]);
+                client!.off(RoomEvent.Timeline, listener);
+                const gotRoom = client!.getRoom(roomH);
+                expect(gotRoom).toBeDefined();
+                if (gotRoom == null) { return; }
+                expect(gotRoom.name).toEqual(data[roomH].name);
+                expect(gotRoom.getMyMembership()).toEqual("join");
+                // check the entire timeline is correct
+                assertTimelineEvents(gotRoom.getLiveTimeline().getEvents(), data[roomH].timeline);
+                expect(seenLiveEvent).toBe(true);
+            });
+
             it("can be created with invite_state", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomE, data[roomE]);
                 const gotRoom = client!.getRoom(roomE);
diff --git a/src/sliding-sync-sdk.ts b/src/sliding-sync-sdk.ts
index 03a17bed327..c99f61f13b9 100644
--- a/src/sliding-sync-sdk.ts
+++ b/src/sliding-sync-sdk.ts
@@ -681,7 +681,7 @@ export class SlidingSyncSdk {
             }
         } */
 
-        this.injectRoomEvents(room, stateEvents, timelineEvents, false);
+        this.injectRoomEvents(room, stateEvents, timelineEvents, roomData.num_live);
 
         // we deliberately don't add ephemeral events to the timeline
         room.addEphemeralEvents(ephemeralEvents);
@@ -725,17 +725,19 @@ export class SlidingSyncSdk {
      * @param {MatrixEvent[]} stateEventList A list of state events. This is the state
      * at the *START* of the timeline list if it is supplied.
      * @param {MatrixEvent[]} [timelineEventList] A list of timeline events. Lower index
-     * @param {boolean} fromCache whether the sync response came from cache
      * is earlier in time. Higher index is later.
+     * @param {number} numLive the number of events in timelineEventList which just happened,
+     * supplied from the server.
      */
     public injectRoomEvents(
         room: Room,
         stateEventList: MatrixEvent[],
         timelineEventList?: MatrixEvent[],
-        fromCache = false,
+        numLive?: number,
     ): void {
         timelineEventList = timelineEventList || [];
         stateEventList = stateEventList || [];
+        numLive = numLive || 0;
 
         // If there are no events in the timeline yet, initialise it with
         // the given state events
@@ -774,13 +776,31 @@ export class SlidingSyncSdk {
             room.currentState.setStateEvents(stateEventList);
         }
 
+        // the timeline is broken into 'live' events which just happened and normal timeline events
+        // which are still to be appended to the end of the live timeline but happened a while ago.
+        // The live events are marked as fromCache=false to ensure that downstream components know
+        // this is a live event, not historical (from a remote server cache).
+
+        let liveTimelineEvents: MatrixEvent[] = [];
+        if (numLive > 0) {
+            // last numLive events are live
+            liveTimelineEvents = timelineEventList.slice(-1 * numLive);
+            // everything else is not live
+            timelineEventList = timelineEventList.slice(0, -1 * liveTimelineEvents.length);
+        }
+
         // execute the timeline events. This will continue to diverge the current state
         // if the timeline has any state events in it.
         // This also needs to be done before running push rules on the events as they need
         // to be decorated with sender etc.
         room.addLiveEvents(timelineEventList, {
-            fromCache: fromCache,
+            fromCache: true,
         });
+        if (liveTimelineEvents.length > 0) {
+            room.addLiveEvents(liveTimelineEvents, {
+                fromCache: false,
+            });
+        }
 
         room.recalculate();
 
diff --git a/src/sliding-sync.ts b/src/sliding-sync.ts
index 171bf55c32d..cda2737d984 100644
--- a/src/sliding-sync.ts
+++ b/src/sliding-sync.ts
@@ -95,6 +95,7 @@ export interface MSC3575RoomData {
     limited?: boolean;
     is_dm?: boolean;
     prev_batch?: string;
+    num_live?: number;
 }
 
 interface ListResponse {

From 2c8eece5ca5333c6e6a14e8ed53f359ed0e9e9bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=A0imon=20Brandner?= <simon.bra.ag@gmail.com>
Date: Mon, 5 Dec 2022 18:44:13 +0100
Subject: [PATCH 22/60] Don't expose `calls` on `GroupCall` (#2941)

---
 spec/test-utils/webrtc.ts          |  51 +++++++++++++-
 spec/unit/webrtc/call.spec.ts      |   4 +-
 spec/unit/webrtc/callFeed.spec.ts  |  55 ++++++++++-----
 spec/unit/webrtc/groupCall.spec.ts | 106 ++++++++++++-----------------
 src/webrtc/call.ts                 |  52 +++++++-------
 src/webrtc/callFeed.ts             |  34 +++++++++
 src/webrtc/groupCall.ts            |   2 +-
 7 files changed, 197 insertions(+), 107 deletions(-)

diff --git a/spec/test-utils/webrtc.ts b/spec/test-utils/webrtc.ts
index 6a1b1a35794..c2f1a0b25a3 100644
--- a/spec/test-utils/webrtc.ts
+++ b/spec/test-utils/webrtc.ts
@@ -26,6 +26,7 @@ import {
     MatrixClient,
     MatrixEvent,
     Room,
+    RoomMember,
     RoomState,
     RoomStateEvent,
     RoomStateEventHandlerMap,
@@ -33,7 +34,7 @@ import {
 import { TypedEventEmitter } from "../../src/models/typed-event-emitter";
 import { ReEmitter } from "../../src/ReEmitter";
 import { SyncState } from "../../src/sync";
-import { CallEvent, CallEventHandlerMap, MatrixCall } from "../../src/webrtc/call";
+import { CallEvent, CallEventHandlerMap, CallState, MatrixCall } from "../../src/webrtc/call";
 import { CallEventHandlerEvent, CallEventHandlerEventHandlerMap } from "../../src/webrtc/callEventHandler";
 import { CallFeed } from "../../src/webrtc/callFeed";
 import { GroupCallEventHandlerMap } from "../../src/webrtc/groupCall";
@@ -83,6 +84,17 @@ export const DUMMY_SDP = (
 export const USERMEDIA_STREAM_ID = "mock_stream_from_media_handler";
 export const SCREENSHARE_STREAM_ID = "mock_screen_stream_from_media_handler";
 
+export const FAKE_ROOM_ID = "!fake:test.dummy";
+export const FAKE_CONF_ID = "fakegroupcallid";
+
+export const FAKE_USER_ID_1 = "@alice:test.dummy";
+export const FAKE_DEVICE_ID_1 = "@AAAAAA";
+export const FAKE_SESSION_ID_1 = "alice1";
+export const FAKE_USER_ID_2 = "@bob:test.dummy";
+export const FAKE_DEVICE_ID_2 = "@BBBBBB";
+export const FAKE_SESSION_ID_2 = "bob1";
+export const FAKE_USER_ID_3 = "@charlie:test.dummy";
+
 class MockMediaStreamAudioSourceNode {
     public connect() {}
 }
@@ -431,6 +443,43 @@ export class MockCallMatrixClient extends TypedEventEmitter<EmittedEvents, Emitt
     }
 }
 
+export class MockMatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap> {
+    constructor(public roomId: string, public groupCallId?: string) {
+        super();
+    }
+
+    public state = CallState.Ringing;
+    public opponentUserId = FAKE_USER_ID_1;
+    public opponentDeviceId = FAKE_DEVICE_ID_1;
+    public opponentMember = { userId: this.opponentUserId };
+    public callId = "1";
+    public localUsermediaFeed = {
+        setAudioVideoMuted: jest.fn<void, [boolean, boolean]>(),
+        stream: new MockMediaStream("stream"),
+    };
+    public remoteUsermediaFeed?: CallFeed;
+    public remoteScreensharingFeed?: CallFeed;
+
+    public reject = jest.fn<void, []>();
+    public answerWithCallFeeds = jest.fn<void, [CallFeed[]]>();
+    public hangup = jest.fn<void, []>();
+
+    public sendMetadataUpdate = jest.fn<void, []>();
+
+    public on = jest.fn();
+    public removeListener = jest.fn();
+
+    public getOpponentMember(): Partial<RoomMember> {
+        return this.opponentMember;
+    }
+
+    public getOpponentDeviceId(): string | undefined {
+        return this.opponentDeviceId;
+    }
+
+    public typed(): MatrixCall { return this as unknown as MatrixCall; }
+}
+
 export class MockCallFeed {
     constructor(
         public userId: string,
diff --git a/spec/unit/webrtc/call.spec.ts b/spec/unit/webrtc/call.spec.ts
index ee52a518a36..d1cb5d29616 100644
--- a/spec/unit/webrtc/call.spec.ts
+++ b/spec/unit/webrtc/call.spec.ts
@@ -1392,7 +1392,7 @@ describe('Call', function() {
         it("ends call on onHangupReceived() if state is ringing", async () => {
             expect(call.callHasEnded()).toBe(false);
 
-            call.state = CallState.Ringing;
+            (call as any).state = CallState.Ringing;
             call.onHangupReceived({} as MCallHangupReject);
 
             expect(call.callHasEnded()).toBe(true);
@@ -1424,7 +1424,7 @@ describe('Call', function() {
     )("ends call on onRejectReceived() if in correct state (state=%s)", async (state: CallState) => {
         expect(call.callHasEnded()).toBe(false);
 
-        call.state = state;
+        (call as any).state = state;
         call.onRejectReceived({} as MCallHangupReject);
 
         expect(call.callHasEnded()).toBe(
diff --git a/spec/unit/webrtc/callFeed.spec.ts b/spec/unit/webrtc/callFeed.spec.ts
index 635fa14fd8f..e14a1a0c56b 100644
--- a/spec/unit/webrtc/callFeed.spec.ts
+++ b/spec/unit/webrtc/callFeed.spec.ts
@@ -17,13 +17,30 @@ limitations under the License.
 import { SDPStreamMetadataPurpose } from "../../../src/webrtc/callEventTypes";
 import { CallFeed } from "../../../src/webrtc/callFeed";
 import { TestClient } from "../../TestClient";
-import { MockMediaStream, MockMediaStreamTrack } from "../../test-utils/webrtc";
+import { MockMatrixCall, MockMediaStream, MockMediaStreamTrack } from "../../test-utils/webrtc";
+import { CallEvent, CallState } from "../../../src/webrtc/call";
 
 describe("CallFeed", () => {
-    let client;
+    const roomId = "room1";
+    let client: TestClient;
+    let call: MockMatrixCall;
+    let feed: CallFeed;
 
     beforeEach(() => {
         client = new TestClient("@alice:foo", "somedevice", "token", undefined, {});
+        call = new MockMatrixCall(roomId);
+
+        feed = new CallFeed({
+            client: client.client,
+            call: call.typed(),
+            roomId,
+            userId: "user1",
+            // @ts-ignore Mock
+            stream: new MockMediaStream("stream1"),
+            purpose: SDPStreamMetadataPurpose.Usermedia,
+            audioMuted: false,
+            videoMuted: false,
+        });
     });
 
     afterEach(() => {
@@ -31,21 +48,6 @@ describe("CallFeed", () => {
     });
 
     describe("muting", () => {
-        let feed: CallFeed;
-
-        beforeEach(() => {
-            feed = new CallFeed({
-                client,
-                roomId: "room1",
-                userId: "user1",
-                // @ts-ignore Mock
-                stream: new MockMediaStream("stream1"),
-                purpose: SDPStreamMetadataPurpose.Usermedia,
-                audioMuted: false,
-                videoMuted: false,
-            });
-        });
-
         describe("muting by default", () => {
             it("should mute audio by default", () => {
                 expect(feed.isAudioMuted()).toBeTruthy();
@@ -86,4 +88,23 @@ describe("CallFeed", () => {
             });
         });
     });
+
+    describe("connected", () => {
+        it.each([true, false])("should always be connected, if isLocal()", (val: boolean) => {
+            // @ts-ignore
+            feed._connected = val;
+            jest.spyOn(feed, "isLocal").mockReturnValue(true);
+
+            expect(feed.connected).toBeTruthy();
+        });
+
+        it.each([
+            [CallState.Connected, true],
+            [CallState.Connecting, false],
+        ])("should react to call state, when !isLocal()", (state: CallState, expected: Boolean) => {
+            call.emit(CallEvent.State, state);
+
+            expect(feed.connected).toBe(expected);
+        });
+    });
 });
diff --git a/spec/unit/webrtc/groupCall.spec.ts b/spec/unit/webrtc/groupCall.spec.ts
index 3c9266b98c8..ad77e15bdc7 100644
--- a/spec/unit/webrtc/groupCall.spec.ts
+++ b/spec/unit/webrtc/groupCall.spec.ts
@@ -33,6 +33,16 @@ import {
     MockMediaStream,
     MockMediaStreamTrack,
     MockRTCPeerConnection,
+    MockMatrixCall,
+    FAKE_ROOM_ID,
+    FAKE_USER_ID_1,
+    FAKE_CONF_ID,
+    FAKE_DEVICE_ID_2,
+    FAKE_SESSION_ID_2,
+    FAKE_USER_ID_2,
+    FAKE_DEVICE_ID_1,
+    FAKE_SESSION_ID_1,
+    FAKE_USER_ID_3,
 } from '../../test-utils/webrtc';
 import { SDPStreamMetadataKey, SDPStreamMetadataPurpose } from "../../../src/webrtc/callEventTypes";
 import { sleep } from "../../../src/utils";
@@ -41,16 +51,6 @@ import { CallFeed } from '../../../src/webrtc/callFeed';
 import { CallEvent, CallState } from '../../../src/webrtc/call';
 import { flushPromises } from '../../test-utils/flushPromises';
 
-const FAKE_ROOM_ID = "!fake:test.dummy";
-const FAKE_CONF_ID = "fakegroupcallid";
-
-const FAKE_USER_ID_1 = "@alice:test.dummy";
-const FAKE_DEVICE_ID_1 = "@AAAAAA";
-const FAKE_SESSION_ID_1 = "alice1";
-const FAKE_USER_ID_2 = "@bob:test.dummy";
-const FAKE_DEVICE_ID_2 = "@BBBBBB";
-const FAKE_SESSION_ID_2 = "bob1";
-const FAKE_USER_ID_3 = "@charlie:test.dummy";
 const FAKE_STATE_EVENTS = [
     {
         getContent: () => ({
@@ -123,42 +123,6 @@ const createAndEnterGroupCall = async (cli: MatrixClient, room: Room): Promise<G
     return groupCall;
 };
 
-class MockCall {
-    constructor(public roomId: string, public groupCallId: string) {
-    }
-
-    public state = CallState.Ringing;
-    public opponentUserId = FAKE_USER_ID_1;
-    public opponentDeviceId = FAKE_DEVICE_ID_1;
-    public opponentMember = { userId: this.opponentUserId };
-    public callId = "1";
-    public localUsermediaFeed = {
-        setAudioVideoMuted: jest.fn<void, [boolean, boolean]>(),
-        stream: new MockMediaStream("stream"),
-    };
-    public remoteUsermediaFeed?: CallFeed;
-    public remoteScreensharingFeed?: CallFeed;
-
-    public reject = jest.fn<void, []>();
-    public answerWithCallFeeds = jest.fn<void, [CallFeed[]]>();
-    public hangup = jest.fn<void, []>();
-
-    public sendMetadataUpdate = jest.fn<void, []>();
-
-    public on = jest.fn();
-    public removeListener = jest.fn();
-
-    public getOpponentMember(): Partial<RoomMember> {
-        return this.opponentMember;
-    }
-
-    public getOpponentDeviceId(): string {
-        return this.opponentDeviceId;
-    }
-
-    public typed(): MatrixCall { return this as unknown as MatrixCall; }
-}
-
 describe('Group Call', function() {
     beforeEach(function() {
         installWebRTCMocks();
@@ -351,7 +315,7 @@ describe('Group Call', function() {
         });
 
         describe("call feeds changing", () => {
-            let call: MockCall;
+            let call: MockMatrixCall;
             const currentFeed = new MockCallFeed(FAKE_USER_ID_1, FAKE_DEVICE_ID_1, new MockMediaStream("current"));
             const newFeed = new MockCallFeed(FAKE_USER_ID_1, FAKE_DEVICE_ID_1, new MockMediaStream("new"));
 
@@ -361,13 +325,13 @@ describe('Group Call', function() {
 
                 jest.spyOn(groupCall, "emit");
 
-                call = new MockCall(room.roomId, groupCall.groupCallId);
+                call = new MockMatrixCall(room.roomId, groupCall.groupCallId);
 
                 await groupCall.create();
             });
 
             it("ignores changes, if we can't get user id of opponent", async () => {
-                const call = new MockCall(room.roomId, groupCall.groupCallId);
+                const call = new MockMatrixCall(room.roomId, groupCall.groupCallId);
                 jest.spyOn(call, "getOpponentMember").mockReturnValue({ userId: undefined });
 
                 // @ts-ignore Mock
@@ -514,10 +478,11 @@ describe('Group Call', function() {
             });
 
             it("sends metadata updates before unmuting in PTT mode", async () => {
-                const mockCall = new MockCall(FAKE_ROOM_ID, groupCall.groupCallId);
+                const mockCall = new MockMatrixCall(FAKE_ROOM_ID, groupCall.groupCallId);
+                // @ts-ignore
                 groupCall.calls.set(
                     mockCall.getOpponentMember() as RoomMember,
-                    new Map([[mockCall.getOpponentDeviceId(), mockCall.typed()]]),
+                    new Map([[mockCall.getOpponentDeviceId()!, mockCall.typed()]]),
                 );
 
                 let metadataUpdateResolve: () => void;
@@ -539,10 +504,11 @@ describe('Group Call', function() {
             });
 
             it("sends metadata updates after muting in PTT mode", async () => {
-                const mockCall = new MockCall(FAKE_ROOM_ID, groupCall.groupCallId);
+                const mockCall = new MockMatrixCall(FAKE_ROOM_ID, groupCall.groupCallId);
+                // @ts-ignore
                 groupCall.calls.set(
                     mockCall.getOpponentMember() as RoomMember,
-                    new Map([[mockCall.getOpponentDeviceId(), mockCall.typed()]]),
+                    new Map([[mockCall.getOpponentDeviceId()!, mockCall.typed()]]),
                 );
 
                 // the call starts muted, so unmute to get in the right state to test
@@ -698,6 +664,7 @@ describe('Group Call', function() {
 
                 expect(client1.sendToDevice).toHaveBeenCalled();
 
+                // @ts-ignore
                 const oldCall = groupCall1.calls.get(
                     groupCall1.room.getMember(client2.userId)!,
                 )!.get(client2.deviceId)!;
@@ -719,6 +686,7 @@ describe('Group Call', function() {
                 // to even be created...
                 let newCall: MatrixCall | undefined;
                 while (
+                    // @ts-ignore
                     (newCall = groupCall1.calls.get(
                         groupCall1.room.getMember(client2.userId)!,
                     )?.get(client2.deviceId)) === undefined
@@ -763,6 +731,7 @@ describe('Group Call', function() {
                 groupCall1.setMicrophoneMuted(false);
                 groupCall1.setLocalVideoMuted(false);
 
+                // @ts-ignore
                 const call = groupCall1.calls.get(
                     groupCall1.room.getMember(client2.userId)!,
                 )!.get(client2.deviceId)!;
@@ -874,7 +843,10 @@ describe('Group Call', function() {
                 // It takes a bit of time for the calls to get created
                 await sleep(10);
 
-                const call = groupCall.calls.get(groupCall.room.getMember(FAKE_USER_ID_2)!)!.get(FAKE_DEVICE_ID_2)!;
+                // @ts-ignore
+                const call = groupCall.calls
+                    .get(groupCall.room.getMember(FAKE_USER_ID_2)!)!
+                    .get(FAKE_DEVICE_ID_2)!;
                 call.getOpponentMember = () => ({ userId: call.invitee }) as RoomMember;
                 // @ts-ignore Mock
                 call.pushRemoteFeed(new MockMediaStream("stream", [
@@ -897,7 +869,10 @@ describe('Group Call', function() {
                 // It takes a bit of time for the calls to get created
                 await sleep(10);
 
-                const call = groupCall.calls.get(groupCall.room.getMember(FAKE_USER_ID_2)!)!.get(FAKE_DEVICE_ID_2)!;
+                // @ts-ignore
+                const call = groupCall.calls
+                    .get(groupCall.room.getMember(FAKE_USER_ID_2)!)!
+                    .get(FAKE_DEVICE_ID_2)!;
                 call.getOpponentMember = () => ({ userId: call.invitee }) as RoomMember;
                 // @ts-ignore Mock
                 call.pushRemoteFeed(new MockMediaStream("stream", [
@@ -939,7 +914,7 @@ describe('Group Call', function() {
         });
 
         it("ignores incoming calls for other rooms", async () => {
-            const mockCall = new MockCall("!someotherroom.fake.dummy", groupCall.groupCallId);
+            const mockCall = new MockMatrixCall("!someotherroom.fake.dummy", groupCall.groupCallId);
 
             mockClient.emit(CallEventHandlerEvent.Incoming, mockCall as unknown as MatrixCall);
 
@@ -948,7 +923,7 @@ describe('Group Call', function() {
         });
 
         it("rejects incoming calls for the wrong group call", async () => {
-            const mockCall = new MockCall(room.roomId, "not " + groupCall.groupCallId);
+            const mockCall = new MockMatrixCall(room.roomId, "not " + groupCall.groupCallId);
 
             mockClient.emit(CallEventHandlerEvent.Incoming, mockCall as unknown as MatrixCall);
 
@@ -956,7 +931,7 @@ describe('Group Call', function() {
         });
 
         it("ignores incoming calls not in the ringing state", async () => {
-            const mockCall = new MockCall(room.roomId, groupCall.groupCallId);
+            const mockCall = new MockMatrixCall(room.roomId, groupCall.groupCallId);
             mockCall.state = CallState.Connected;
 
             mockClient.emit(CallEventHandlerEvent.Incoming, mockCall as unknown as MatrixCall);
@@ -966,12 +941,13 @@ describe('Group Call', function() {
         });
 
         it("answers calls for the right room & group call ID", async () => {
-            const mockCall = new MockCall(room.roomId, groupCall.groupCallId);
+            const mockCall = new MockMatrixCall(room.roomId, groupCall.groupCallId);
 
             mockClient.emit(CallEventHandlerEvent.Incoming, mockCall as unknown as MatrixCall);
 
             expect(mockCall.reject).not.toHaveBeenCalled();
             expect(mockCall.answerWithCallFeeds).toHaveBeenCalled();
+            // @ts-ignore
             expect(groupCall.calls).toEqual(new Map([[
                 groupCall.room.getMember(FAKE_USER_ID_1)!,
                 new Map([[FAKE_DEVICE_ID_1, mockCall]]),
@@ -979,8 +955,8 @@ describe('Group Call', function() {
         });
 
         it("replaces calls if it already has one with the same user", async () => {
-            const oldMockCall = new MockCall(room.roomId, groupCall.groupCallId);
-            const newMockCall = new MockCall(room.roomId, groupCall.groupCallId);
+            const oldMockCall = new MockMatrixCall(room.roomId, groupCall.groupCallId);
+            const newMockCall = new MockMatrixCall(room.roomId, groupCall.groupCallId);
             newMockCall.opponentMember = oldMockCall.opponentMember; // Ensure referential equality
             newMockCall.callId = "not " + oldMockCall.callId;
 
@@ -989,6 +965,7 @@ describe('Group Call', function() {
 
             expect(oldMockCall.hangup).toHaveBeenCalled();
             expect(newMockCall.answerWithCallFeeds).toHaveBeenCalled();
+            // @ts-ignore
             expect(groupCall.calls).toEqual(new Map([[
                 groupCall.room.getMember(FAKE_USER_ID_1)!,
                 new Map([[FAKE_DEVICE_ID_1, newMockCall]]),
@@ -999,7 +976,7 @@ describe('Group Call', function() {
             // First we leave the call since we have already entered
             groupCall.leave();
 
-            const call = new MockCall(room.roomId, groupCall.groupCallId);
+            const call = new MockMatrixCall(room.roomId, groupCall.groupCallId);
             mockClient.callEventHandler!.calls = new Map<string, MatrixCall>([
                 [call.callId, call.typed()],
             ]);
@@ -1072,7 +1049,10 @@ describe('Group Call', function() {
             // It takes a bit of time for the calls to get created
             await sleep(10);
 
-            const call = groupCall.calls.get(groupCall.room.getMember(FAKE_USER_ID_2)!)!.get(FAKE_DEVICE_ID_2)!;
+            // @ts-ignore
+            const call = groupCall.calls
+                .get(groupCall.room.getMember(FAKE_USER_ID_2)!)!
+                .get(FAKE_DEVICE_ID_2)!;
             call.getOpponentMember = () => ({ userId: call.invitee }) as RoomMember;
             call.onNegotiateReceived({
                 getContent: () => ({
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index 8b4882c960a..ad5e6668bcd 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -334,7 +334,6 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     public roomId?: string;
     public callId: string;
     public invitee?: string;
-    public state = CallState.Fledgling;
     public hangupParty?: CallParty;
     public hangupReason?: string;
     public direction?: CallDirection;
@@ -346,6 +345,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     // This should be set by the consumer on incoming & outgoing calls.
     public isPtt = false;
 
+    private _state = CallState.Fledgling;
     private readonly client: MatrixClient;
     private readonly forceTURN?: boolean;
     private readonly turnServers: Array<TurnServer>;
@@ -482,6 +482,16 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         return this.remoteAssertedIdentity;
     }
 
+    public get state(): CallState {
+        return this._state;
+    }
+
+    private set state(state: CallState) {
+        const oldState = this._state;
+        this._state = state;
+        this.emit(CallEvent.State, state, oldState);
+    }
+
     public get type(): CallType {
         return (this.hasLocalUserMediaVideoTrack || this.hasRemoteUserMediaVideoTrack)
             ? CallType.Video
@@ -646,6 +656,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         this.feeds.push(new CallFeed({
             client: this.client,
+            call: this,
             roomId: this.roomId,
             userId,
             deviceId: this.getOpponentDeviceId(),
@@ -689,6 +700,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         this.feeds.push(new CallFeed({
             client: this.client,
+            call: this,
             roomId: this.roomId,
             audioMuted: false,
             videoMuted: false,
@@ -928,7 +940,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             return;
         }
 
-        this.setState(CallState.Ringing);
+        this.state = CallState.Ringing;
 
         if (event.getLocalAge()) {
             // Time out the call if it's ringing for too long
@@ -936,7 +948,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 if (this.state == CallState.Ringing) {
                     logger.debug(`Call ${this.callId} invite has expired. Hanging up.`);
                     this.hangupParty = CallParty.Remote; // effectively
-                    this.setState(CallState.Ended);
+                    this.state = CallState.Ended;
                     this.stopAllMedia();
                     if (this.peerConn!.signalingState != 'closed') {
                         this.peerConn!.close();
@@ -963,7 +975,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // perverse as it may seem, sometimes we want to instantiate a call with a
         // hangup message (because when getting the state of the room on load, events
         // come in reverse order and we want to remember that a call has been hung up)
-        this.setState(CallState.Ended);
+        this.state = CallState.Ended;
     }
 
     private shouldAnswerWithMediaType(
@@ -1004,7 +1016,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             const answerWithAudio = this.shouldAnswerWithMediaType(audio, this.hasRemoteUserMediaAudioTrack, "audio");
             const answerWithVideo = this.shouldAnswerWithMediaType(video, this.hasRemoteUserMediaVideoTrack, "video");
 
-            this.setState(CallState.WaitLocalMedia);
+            this.state = CallState.WaitLocalMedia;
             this.waitForLocalAVStream = true;
 
             try {
@@ -1034,7 +1046,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 if (answerWithVideo) {
                     // Try to answer without video
                     logger.warn(`Call ${this.callId} Failed to getUserMedia(), trying to getUserMedia() without video`);
-                    this.setState(prevState);
+                    this.state = prevState;
                     this.waitForLocalAVStream = false;
                     await this.answer(answerWithAudio, false);
                 } else {
@@ -1043,7 +1055,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 }
             }
         } else if (this.waitForLocalAVStream) {
-            this.setState(CallState.WaitLocalMedia);
+            this.state = CallState.WaitLocalMedia;
         }
     }
 
@@ -1495,7 +1507,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             });
         }
 
-        this.setState(CallState.CreateOffer);
+        this.state = CallState.CreateOffer;
 
         logger.debug(`Call ${this.callId} gotUserMediaForInvite`);
         // Now we wait for the negotiationneeded event
@@ -1530,7 +1542,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             this.inviteOrAnswerSent = true;
         } catch (error) {
             // We've failed to answer: back to the ringing state
-            this.setState(CallState.Ringing);
+            this.state = CallState.Ringing;
             if (error instanceof MatrixError && error.event) this.client.cancelPendingEvent(error.event);
 
             let code = CallErrorCode.SendAnswer;
@@ -1627,7 +1639,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             this.pushLocalFeed(feed);
         }
 
-        this.setState(CallState.CreateAnswer);
+        this.state = CallState.CreateAnswer;
 
         let answer: RTCSessionDescriptionInit;
         try {
@@ -1645,7 +1657,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             // make sure we're still going
             if (this.callHasEnded()) return;
 
-            this.setState(CallState.Connecting);
+            this.state = CallState.Connecting;
 
             // Allow a short time for initial candidates to be gathered
             await new Promise(resolve => {
@@ -1762,7 +1774,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         this.chooseOpponent(event);
         await this.addBufferedIceCandidates();
 
-        this.setState(CallState.Connecting);
+        this.state = CallState.Connecting;
 
         const sdpStreamMetadata = content[SDPStreamMetadataKey];
         if (sdpStreamMetadata) {
@@ -2034,7 +2046,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         this.sendCandidateQueue();
         if (this.state === CallState.CreateOffer) {
             this.inviteOrAnswerSent = true;
-            this.setState(CallState.InviteSent);
+            this.state = CallState.InviteSent;
             this.inviteTimeout = setTimeout(() => {
                 this.inviteTimeout = undefined;
                 if (this.state === CallState.InviteSent) {
@@ -2088,7 +2100,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // chrome doesn't implement any of the 'onstarted' events yet
         if (["connected", "completed"].includes(this.peerConn?.iceConnectionState ?? '')) {
             clearTimeout(this.iceDisconnectedTimeout);
-            this.setState(CallState.Connected);
+            this.state = CallState.Connected;
 
             if (!this.callLengthInterval) {
                 this.callLengthInterval = setInterval(() => {
@@ -2112,7 +2124,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 logger.info(`Hanging up call ${this.callId} (ICE disconnected for too long)`);
                 this.hangup(CallErrorCode.IceFailed, false);
             }, 30 * 1000);
-            this.setState(CallState.Connecting);
+            this.state = CallState.Connecting;
         }
 
         // In PTT mode, override feed status to muted when we lose connection to
@@ -2244,12 +2256,6 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         this.terminate(CallParty.Remote, CallErrorCode.AnsweredElsewhere, true);
     };
 
-    private setState(state: CallState): void {
-        const oldState = this.state;
-        this.state = state;
-        this.emit(CallEvent.State, state, oldState);
-    }
-
     /**
      * Internal
      * @param {string} eventType
@@ -2444,7 +2450,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         this.hangupParty = hangupParty;
         this.hangupReason = hangupReason;
-        this.setState(CallState.Ended);
+        this.state = CallState.Ended;
 
         if (this.inviteTimeout) {
             clearTimeout(this.inviteTimeout);
@@ -2578,7 +2584,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         if (!audio) {
             throw new Error("You CANNOT start a call without audio");
         }
-        this.setState(CallState.WaitLocalMedia);
+        this.state = CallState.WaitLocalMedia;
 
         try {
             const stream = await this.client.getMediaHandler().getUserMediaStream(audio, video);
diff --git a/src/webrtc/callFeed.ts b/src/webrtc/callFeed.ts
index bc1c344505c..14abc30d22a 100644
--- a/src/webrtc/callFeed.ts
+++ b/src/webrtc/callFeed.ts
@@ -20,6 +20,7 @@ import { MatrixClient } from "../client";
 import { RoomMember } from "../models/room-member";
 import { logger } from "../logger";
 import { TypedEventEmitter } from "../models/typed-event-emitter";
+import { CallEvent, CallState, MatrixCall } from "./call";
 
 const POLLING_INTERVAL = 200; // ms
 export const SPEAKING_THRESHOLD = -60; // dB
@@ -40,6 +41,10 @@ export interface ICallFeedOpts {
      * Whether or not the remote SDPStreamMetadata says video is muted
      */
     videoMuted: boolean;
+    /**
+     * The MatrixCall which is the source of this CallFeed
+     */
+    call?: MatrixCall;
 }
 
 export enum CallFeedEvent {
@@ -47,6 +52,7 @@ export enum CallFeedEvent {
     MuteStateChanged = "mute_state_changed",
     LocalVolumeChanged = "local_volume_changed",
     VolumeChanged = "volume_changed",
+    ConnectedChanged = "connected_changed",
     Speaking = "speaking",
     Disposed = "disposed",
 }
@@ -56,6 +62,7 @@ type EventHandlerMap = {
     [CallFeedEvent.MuteStateChanged]: (audioMuted: boolean, videoMuted: boolean) => void;
     [CallFeedEvent.LocalVolumeChanged]: (localVolume: number) => void;
     [CallFeedEvent.VolumeChanged]: (volume: number) => void;
+    [CallFeedEvent.ConnectedChanged]: (connected: boolean) => void;
     [CallFeedEvent.Speaking]: (speaking: boolean) => void;
     [CallFeedEvent.Disposed]: () => void;
 };
@@ -69,6 +76,7 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
     public speakingVolumeSamples: number[];
 
     private client: MatrixClient;
+    private call?: MatrixCall;
     private roomId?: string;
     private audioMuted: boolean;
     private videoMuted: boolean;
@@ -81,11 +89,13 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
     private speaking = false;
     private volumeLooperTimeout?: ReturnType<typeof setTimeout>;
     private _disposed = false;
+    private _connected = false;
 
     public constructor(opts: ICallFeedOpts) {
         super();
 
         this.client = opts.client;
+        this.call = opts.call;
         this.roomId = opts.roomId;
         this.userId = opts.userId;
         this.deviceId = opts.deviceId;
@@ -101,6 +111,21 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
         if (this.hasAudioTrack) {
             this.initVolumeMeasuring();
         }
+
+        if (opts.call) {
+            opts.call.addListener(CallEvent.State, this.onCallState);
+            this.onCallState(opts.call.state);
+        }
+    }
+
+    public get connected(): boolean {
+        // Local feeds are always considered connected
+        return this.isLocal() || this._connected;
+    }
+
+    private set connected(connected: boolean) {
+        this._connected = connected;
+        this.emit(CallFeedEvent.ConnectedChanged, this.connected);
     }
 
     private get hasAudioTrack(): boolean {
@@ -145,6 +170,14 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
         this.emit(CallFeedEvent.NewStream, this.stream);
     };
 
+    private onCallState = (state: CallState): void => {
+        if (state === CallState.Connected) {
+            this.connected = true;
+        } else if (state === CallState.Connecting) {
+            this.connected = false;
+        }
+    };
+
     /**
      * Returns callRoom member
      * @returns member of the callRoom
@@ -297,6 +330,7 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
     public dispose(): void {
         clearTimeout(this.volumeLooperTimeout);
         this.stream?.removeEventListener("addtrack", this.onAddTrack);
+        this.call?.removeListener(CallEvent.State, this.onCallState);
         if (this.audioContext) {
             this.audioContext = undefined;
             this.analyser = undefined;
diff --git a/src/webrtc/groupCall.ts b/src/webrtc/groupCall.ts
index fde46182bc1..5941b6a3728 100644
--- a/src/webrtc/groupCall.ts
+++ b/src/webrtc/groupCall.ts
@@ -168,11 +168,11 @@ export class GroupCall extends TypedEventEmitter<
     public localCallFeed?: CallFeed;
     public localScreenshareFeed?: CallFeed;
     public localDesktopCapturerSourceId?: string;
-    public readonly calls = new Map<RoomMember, Map<string, MatrixCall>>();
     public readonly userMediaFeeds: CallFeed[] = [];
     public readonly screenshareFeeds: CallFeed[] = [];
     public groupCallId: string;
 
+    private readonly calls = new Map<RoomMember, Map<string, MatrixCall>>(); // RoomMember -> device ID -> MatrixCall
     private callHandlers = new Map<string, Map<string, ICallHandlers>>(); // User ID -> device ID -> handlers
     private activeSpeakerLoopInterval?: ReturnType<typeof setTimeout>;
     private retryCallLoopInterval?: ReturnType<typeof setTimeout>;

From 683e7fba4ab3861bf9c822308fd69f17016618f1 Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Tue, 6 Dec 2022 10:31:48 +0000
Subject: [PATCH 23/60] Add a message ID on each to-device message (#2938)

To make it easier to track down where to-device messages are getting lost,
add a custom property to each one, and log its value. Synapse will also log
this property.
---
 package.json                                |  4 ++-
 spec/unit/crypto.spec.ts                    | 37 +++++++++++++--------
 spec/unit/crypto/algorithms/megolm.spec.ts  |  3 ++
 src/@types/event.ts                         |  2 ++
 src/ToDeviceMessageQueue.ts                 | 10 ++++--
 src/crypto/OutgoingRoomKeyRequestManager.ts |  9 +++--
 src/crypto/SecretStorage.ts                 |  5 +++
 src/crypto/algorithms/megolm.ts             | 18 +++++++---
 src/crypto/index.ts                         | 10 ++++--
 src/webrtc/call.ts                          |  4 ++-
 yarn.lock                                   | 10 ++++++
 11 files changed, 85 insertions(+), 27 deletions(-)

diff --git a/package.json b/package.json
index 5cfc418633d..02a849ac859 100644
--- a/package.json
+++ b/package.json
@@ -63,7 +63,8 @@
     "p-retry": "4",
     "qs": "^6.9.6",
     "sdp-transform": "^2.14.1",
-    "unhomoglyph": "^1.0.6"
+    "unhomoglyph": "^1.0.6",
+    "uuid": "7"
   },
   "devDependencies": {
     "@babel/cli": "^7.12.10",
@@ -86,6 +87,7 @@
     "@types/jest": "^29.0.0",
     "@types/node": "18",
     "@types/sdp-transform": "^2.4.5",
+    "@types/uuid": "7",
     "@typescript-eslint/eslint-plugin": "^5.6.0",
     "@typescript-eslint/parser": "^5.6.0",
     "allchange": "^1.0.6",
diff --git a/spec/unit/crypto.spec.ts b/spec/unit/crypto.spec.ts
index 68c8264b6f8..b319a5f26ad 100644
--- a/spec/unit/crypto.spec.ts
+++ b/spec/unit/crypto.spec.ts
@@ -1010,18 +1010,24 @@ describe("Crypto", function() {
 
         it("encrypts and sends to devices", async () => {
             client.httpBackend
-                .when("PUT", "/sendToDevice/m.room.encrypted", {
-                    messages: {
-                        "@bob:example.org": {
-                            bobweb: encryptedPayload,
-                            bobmobile: encryptedPayload,
-                        },
-                        "@carol:example.org": {
-                            caroldesktop: encryptedPayload,
+                .when("PUT", "/sendToDevice/m.room.encrypted")
+                .check((request) => {
+                    const data = request.data;
+                    delete data.messages["@bob:example.org"]["bobweb"]["org.matrix.msgid"];
+                    delete data.messages["@bob:example.org"]["bobmobile"]["org.matrix.msgid"];
+                    delete data.messages["@carol:example.org"]["caroldesktop"]["org.matrix.msgid"];
+                    expect(data).toStrictEqual({
+                        messages: {
+                            "@bob:example.org": {
+                                bobweb: encryptedPayload,
+                                bobmobile: encryptedPayload,
+                            },
+                            "@carol:example.org": {
+                                caroldesktop: encryptedPayload,
+                            },
                         },
-                    },
-                })
-                .respond(200, {});
+                    });
+                }).respond(200, {});
 
             await Promise.all([
                 client.client.encryptAndSendToDevices(
@@ -1044,9 +1050,14 @@ describe("Crypto", function() {
             });
 
             client.httpBackend
-                .when("PUT", "/sendToDevice/m.room.encrypted", {
+                .when("PUT", "/sendToDevice/m.room.encrypted")
+                .check((req) => {
+                    const data = req.data;
+                    delete data.messages["@bob:example.org"]["bobweb"]["org.matrix.msgid"];
                     // Carol is nowhere to be seen
-                    messages: { "@bob:example.org": { bobweb: encryptedPayload } },
+                    expect(data).toStrictEqual({
+                        messages: { "@bob:example.org": { bobweb: encryptedPayload } },
+                    });
                 })
                 .respond(200, {});
 
diff --git a/spec/unit/crypto/algorithms/megolm.spec.ts b/spec/unit/crypto/algorithms/megolm.spec.ts
index a1519d4ab61..b631201996a 100644
--- a/spec/unit/crypto/algorithms/megolm.spec.ts
+++ b/spec/unit/crypto/algorithms/megolm.spec.ts
@@ -558,7 +558,9 @@ describe("MegolmDecryption", function() {
         const [msgtype, contentMap] = mocked(aliceClient.sendToDevice).mock.calls[0];
         expect(msgtype).toMatch(/^(org.matrix|m).room_key.withheld$/);
         delete contentMap["@bob:example.com"].bobdevice1.session_id;
+        delete contentMap["@bob:example.com"].bobdevice1["org.matrix.msgid"];
         delete contentMap["@bob:example.com"].bobdevice2.session_id;
+        delete contentMap["@bob:example.com"].bobdevice2["org.matrix.msgid"];
         expect(contentMap).toStrictEqual({
             '@bob:example.com': {
                 bobdevice1: {
@@ -755,6 +757,7 @@ describe("MegolmDecryption", function() {
         expect(aliceClient.sendToDevice).toHaveBeenCalled();
         const [msgtype, contentMap] = mocked(aliceClient.sendToDevice).mock.calls[0];
         expect(msgtype).toMatch(/^(org.matrix|m).room_key.withheld$/);
+        delete contentMap["@bob:example.com"]["bobdevice"]["org.matrix.msgid"];
         expect(contentMap).toStrictEqual({
             '@bob:example.com': {
                 bobdevice: {
diff --git a/src/@types/event.ts b/src/@types/event.ts
index 168097925b2..ab07c01d776 100644
--- a/src/@types/event.ts
+++ b/src/@types/event.ts
@@ -120,6 +120,8 @@ export enum RoomType {
     ElementVideo = "io.element.video",
 }
 
+export const ToDeviceMessageId = "org.matrix.msgid";
+
 /**
  * Identifier for an [MSC3088](https://github.com/matrix-org/matrix-doc/pull/3088)
  * room purpose. Note that this reference is UNSTABLE and subject to breaking changes,
diff --git a/src/ToDeviceMessageQueue.ts b/src/ToDeviceMessageQueue.ts
index 0b5b1786a63..bf881395b2e 100644
--- a/src/ToDeviceMessageQueue.ts
+++ b/src/ToDeviceMessageQueue.ts
@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { ToDeviceMessageId } from './@types/event';
 import { logger } from "./logger";
 import { MatrixError, MatrixClient } from "./matrix";
 import { IndexedToDeviceBatch, ToDeviceBatch, ToDeviceBatchWithTxnId, ToDevicePayload } from "./models/ToDeviceMessage";
@@ -54,12 +55,15 @@ export class ToDeviceMessageQueue {
                 txnId: this.client.makeTxnId(),
             };
             batches.push(batchWithTxnId);
-            const recips = batchWithTxnId.batch.map((msg) => `${msg.userId}:${msg.deviceId}`);
-            logger.info(`Created batch of to-device messages with txn id ${batchWithTxnId.txnId} for ${recips}`);
+            const msgmap = batchWithTxnId.batch.map(
+                (msg) => `${msg.userId}/${msg.deviceId} (msgid ${msg.payload[ToDeviceMessageId]})`,
+            );
+            logger.info(
+                `Enqueuing batch of to-device messages. type=${batch.eventType} txnid=${batchWithTxnId.txnId}`, msgmap,
+            );
         }
 
         await this.client.store.saveToDeviceBatches(batches);
-        logger.info(`Enqueued to-device messages with txn ids ${batches.map((batch) => batch.txnId)}`);
         this.sendQueue();
     }
 
diff --git a/src/crypto/OutgoingRoomKeyRequestManager.ts b/src/crypto/OutgoingRoomKeyRequestManager.ts
index 42723434778..cb93851b9d1 100644
--- a/src/crypto/OutgoingRoomKeyRequestManager.ts
+++ b/src/crypto/OutgoingRoomKeyRequestManager.ts
@@ -14,11 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { v4 as uuidv4 } from "uuid";
+
 import { logger } from '../logger';
 import { MatrixClient } from "../client";
 import { IRoomKeyRequestBody, IRoomKeyRequestRecipient } from "./index";
 import { CryptoStore, OutgoingRoomKeyRequest } from './store/base';
-import { EventType } from "../@types/event";
+import { EventType, ToDeviceMessageId } from "../@types/event";
 
 /**
  * Internal module. Management of outgoing room key requests.
@@ -483,7 +485,10 @@ export class OutgoingRoomKeyRequestManager {
             if (!contentMap[recip.userId]) {
                 contentMap[recip.userId] = {};
             }
-            contentMap[recip.userId][recip.deviceId] = message;
+            contentMap[recip.userId][recip.deviceId] = {
+                ...message,
+                [ToDeviceMessageId]: uuidv4(),
+            };
         }
 
         return this.baseApis.sendToDevice(EventType.RoomKeyRequest, contentMap, txnId);
diff --git a/src/crypto/SecretStorage.ts b/src/crypto/SecretStorage.ts
index 5c13ba4b0bb..a7e1e7d738f 100644
--- a/src/crypto/SecretStorage.ts
+++ b/src/crypto/SecretStorage.ts
@@ -14,6 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { v4 as uuidv4 } from 'uuid';
+
 import { logger } from '../logger';
 import * as olmlib from './olmlib';
 import { encodeBase64 } from './olmlib';
@@ -25,6 +27,7 @@ import { ClientEvent, ClientEventHandlerMap, MatrixClient } from "../client";
 import { IAddSecretStorageKeyOpts, ISecretStorageKeyInfo } from './api';
 import { TypedEventEmitter } from '../models/typed-event-emitter';
 import { defer, IDeferred } from "../utils";
+import { ToDeviceMessageId } from "../@types/event";
 
 export const SECRET_STORAGE_ALGORITHM_V1_AES = "m.secret_storage.v1.aes-hmac-sha2";
 
@@ -407,6 +410,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
             action: "request",
             requesting_device_id: this.baseApis.deviceId,
             request_id: requestId,
+            [ToDeviceMessageId]: uuidv4(),
         };
         const toDevice = {};
         for (const device of devices) {
@@ -490,6 +494,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                     algorithm: olmlib.OLM_ALGORITHM,
                     sender_key: this.baseApis.crypto!.olmDevice.deviceCurve25519Key,
                     ciphertext: {},
+                    [ToDeviceMessageId]: uuidv4(),
                 };
                 await olmlib.ensureOlmSessionsForDevices(
                     this.baseApis.crypto!.olmDevice,
diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index cbad327a608..1d164cc2334 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -20,6 +20,8 @@ limitations under the License.
  * @module crypto/algorithms/megolm
  */
 
+import { v4 as uuidv4 } from "uuid";
+
 import { logger } from '../../logger';
 import * as olmlib from "../olmlib";
 import {
@@ -37,7 +39,7 @@ import { DeviceInfo } from "../deviceinfo";
 import { IOlmSessionResult } from "../olmlib";
 import { DeviceInfoMap } from "../DeviceList";
 import { MatrixEvent } from "../../models/event";
-import { EventType, MsgType } from '../../@types/event';
+import { EventType, MsgType, ToDeviceMessageId } from '../../@types/event';
 import { IEncryptedContent, IEventDecryptionResult, IMegolmSessionData, IncomingRoomKeyRequest } from "../index";
 import { RoomKeyRequestState } from '../OutgoingRoomKeyRequestManager';
 import { OlmGroupSessionExtraData } from "../../@types/crypto";
@@ -655,9 +657,13 @@ class MegolmEncryption extends EncryptionAlgorithm {
             const deviceInfo = blockedInfo.deviceInfo;
             const deviceId = deviceInfo.deviceId;
 
-            const message = Object.assign({}, payload);
-            message.code = blockedInfo.code;
-            message.reason = blockedInfo.reason;
+            const message = {
+                ...payload,
+                code: blockedInfo.code,
+                reason: blockedInfo.reason,
+                [ToDeviceMessageId]: uuidv4(),
+            };
+
             if (message.code === "m.no_olm") {
                 delete message.room_id;
                 delete message.session_id;
@@ -759,6 +765,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
             algorithm: olmlib.OLM_ALGORITHM,
             sender_key: this.olmDevice.deviceCurve25519Key,
             ciphertext: {},
+            [ToDeviceMessageId]: uuidv4(),
         };
         await olmlib.encryptMessageForDevice(
             encryptedContent.ciphertext,
@@ -1667,6 +1674,7 @@ class MegolmDecryption extends DecryptionAlgorithm {
                 algorithm: olmlib.OLM_ALGORITHM,
                 sender_key: this.olmDevice.deviceCurve25519Key,
                 ciphertext: {},
+                [ToDeviceMessageId]: uuidv4(),
             };
             await olmlib.encryptMessageForDevice(
                 encryptedContent.ciphertext,
@@ -1748,6 +1756,7 @@ class MegolmDecryption extends DecryptionAlgorithm {
                 algorithm: olmlib.OLM_ALGORITHM,
                 sender_key: this.olmDevice.deviceCurve25519Key,
                 ciphertext: {},
+                [ToDeviceMessageId]: uuidv4,
             };
 
             return this.olmlib.encryptMessageForDevice(
@@ -1923,6 +1932,7 @@ class MegolmDecryption extends DecryptionAlgorithm {
                         algorithm: olmlib.OLM_ALGORITHM,
                         sender_key: this.olmDevice.deviceCurve25519Key!,
                         ciphertext: {},
+                        [ToDeviceMessageId]: uuidv4(),
                     };
                     contentMap[userId][deviceInfo.deviceId] = encryptedContent;
                     promises.push(
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 2d6995a58bb..d71fadf9073 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -22,9 +22,10 @@ limitations under the License.
  */
 
 import anotherjson from "another-json";
+import { v4 as uuidv4 } from "uuid";
 
 import type { PkDecryption, PkSigning } from "@matrix-org/olm";
-import { EventType } from "../@types/event";
+import { EventType, ToDeviceMessageId } from "../@types/event";
 import { TypedReEmitter } from '../ReEmitter';
 import { logger } from '../logger';
 import { IExportedDevice, OlmDevice } from "./OlmDevice";
@@ -234,6 +235,7 @@ export interface IEncryptedContent {
     algorithm: string;
     sender_key: string;
     ciphertext: Record<string, string>;
+    [ToDeviceMessageId]: string;
 }
 /* eslint-enable camelcase */
 
@@ -3173,6 +3175,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                     algorithm: olmlib.OLM_ALGORITHM,
                     sender_key: this.olmDevice.deviceCurve25519Key!,
                     ciphertext: {},
+                    [ToDeviceMessageId]: uuidv4(),
                 };
 
                 toDeviceBatch.batch.push({
@@ -3232,8 +3235,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
     private onToDeviceEvent = (event: MatrixEvent): void => {
         try {
-            logger.log(`received to_device ${event.getType()} from: ` +
-                `${event.getSender()} id: ${event.getId()}`);
+            logger.log(`received to-device ${event.getType()} from: ` +
+                `${event.getSender()} id: ${event.getContent()[ToDeviceMessageId]}`);
 
             if (event.getType() == "m.room_key"
                 || event.getType() == "m.forwarded_room_key") {
@@ -3516,6 +3519,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             algorithm: olmlib.OLM_ALGORITHM,
             sender_key: this.olmDevice.deviceCurve25519Key,
             ciphertext: {},
+            [ToDeviceMessageId]: uuidv4(),
         };
         await olmlib.encryptMessageForDevice(
             encryptedContent.ciphertext,
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index ad5e6668bcd..178f75608d7 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -22,12 +22,13 @@ limitations under the License.
  * @module webrtc/call
  */
 
+import { v4 as uuidv4 } from "uuid";
 import { parse as parseSdp, write as writeSdp } from "sdp-transform";
 
 import { logger } from '../logger';
 import * as utils from '../utils';
 import { MatrixEvent } from '../models/event';
-import { EventType } from '../@types/event';
+import { EventType, ToDeviceMessageId } from '../@types/event';
 import { RoomMember } from '../models/room-member';
 import { randomString } from '../randomstring';
 import {
@@ -2278,6 +2279,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 sender_session_id: this.client.getSessionId(),
                 dest_session_id: this.opponentSessionId,
                 seq: toDeviceSeq,
+                [ToDeviceMessageId]: uuidv4(),
             };
 
             this.emit(CallEvent.SendVoipEvent, {
diff --git a/yarn.lock b/yarn.lock
index 77cca92702e..413b7bfc9f1 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1759,6 +1759,11 @@
   resolved "https://registry.yarnpkg.com/@types/tough-cookie/-/tough-cookie-4.0.2.tgz#6286b4c7228d58ab7866d19716f3696e03a09397"
   integrity sha512-Q5vtl1W5ue16D+nIaW8JWebSSraJVlK+EthKn7e7UcD4KWsaSJ8BqGPXNaPghgtcn/fhvrN17Tv8ksUsQpiplw==
 
+"@types/uuid@7":
+  version "7.0.5"
+  resolved "https://registry.yarnpkg.com/@types/uuid/-/uuid-7.0.5.tgz#b1d2f772142a301538fae9bdf9cf15b9f2573a29"
+  integrity sha512-hKB88y3YHL8oPOs/CNlaXtjWn93+Bs48sDQR37ZUqG2tLeCS7EA1cmnkKsuQsub9OKEB/y/Rw9zqJqqNSbqVlQ==
+
 "@types/webidl-conversions@*":
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/@types/webidl-conversions/-/webidl-conversions-7.0.0.tgz#2b8e60e33906459219aa587e9d1a612ae994cfe7"
@@ -6967,6 +6972,11 @@ util@~0.12.0:
     is-typed-array "^1.1.3"
     which-typed-array "^1.1.2"
 
+uuid@7:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/uuid/-/uuid-7.0.3.tgz#c5c9f2c8cf25dc0a372c4df1441c41f5bd0c680b"
+  integrity sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==
+
 uuid@8.3.2, uuid@^8.3.2:
   version "8.3.2"
   resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"

From ccab6985ad5567960fa9bc4cd95fc39241560b80 Mon Sep 17 00:00:00 2001
From: RiotRobot <releases@riot.im>
Date: Tue, 6 Dec 2022 12:34:38 +0000
Subject: [PATCH 24/60] Resetting package fields for development

---
 package.json | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 98dfac3d3bf..9ad98499a73 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,7 @@
   "keywords": [
     "matrix-org"
   ],
-  "main": "./lib/index.js",
+  "main": "./src/index.ts",
   "browser": "./lib/browser-index.js",
   "matrix_src_main": "./src/index.ts",
   "matrix_src_browser": "./src/browser-index.js",
@@ -138,6 +138,5 @@
     "outputDirectory": "coverage",
     "outputName": "jest-sonar-report.xml",
     "relativePaths": true
-  },
-  "typings": "./lib/index.d.ts"
+  }
 }

From 6f81371e61ff5ebe9966a4aca92a0c73513d4fa5 Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Tue, 6 Dec 2022 16:45:21 +0000
Subject: [PATCH 25/60] Fix the message ID on key-share messages (#2945)

https://github.com/matrix-org/matrix-js-sdk/pull/2938 introduced message IDs on
outgoing to-device messages, but a typo meant that the IDs on key-share
messages were excessive.
---
 src/crypto/algorithms/megolm.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index 1d164cc2334..9ba33e32a78 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -1756,7 +1756,7 @@ class MegolmDecryption extends DecryptionAlgorithm {
                 algorithm: olmlib.OLM_ALGORITHM,
                 sender_key: this.olmDevice.deviceCurve25519Key,
                 ciphertext: {},
-                [ToDeviceMessageId]: uuidv4,
+                [ToDeviceMessageId]: uuidv4(),
             };
 
             return this.olmlib.encryptMessageForDevice(

From 8d018f9c2d3376c24a601722c53302fe3adbe48c Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Tue, 6 Dec 2022 18:21:44 +0000
Subject: [PATCH 26/60] Enable noImplicitAny (#2895)

* Stash noImplicitAny work

* Enable noImplicitAny

* Update olm

* Fun

* Fix msgid stuff

* Fix tests

* Attempt to fix Browserify
---
 .github/workflows/static_analysis.yml         |  37 +-
 package.json                                  |   8 +-
 spec/TestClient.ts                            |   2 +-
 spec/browserify/setupTests.ts                 |  16 +-
 spec/browserify/sync-browserify.spec.ts       |  21 +-
 spec/integ/devicelist-integ.spec.ts           |  91 +--
 spec/integ/matrix-client-crypto.spec.ts       | 140 ++--
 .../matrix-client-event-timeline.spec.ts      |  62 +-
 spec/integ/matrix-client-methods.spec.ts      |   6 +-
 spec/integ/matrix-client-opts.spec.ts         |   8 +-
 .../integ/matrix-client-room-timeline.spec.ts |  29 +-
 spec/integ/matrix-client-syncing.spec.ts      | 597 +++++++++---------
 spec/integ/megolm-backup.spec.ts              |  13 +-
 spec/integ/sliding-sync-sdk.spec.ts           |  16 +-
 spec/integ/sliding-sync.spec.ts               |  50 +-
 spec/test-utils/test-utils.ts                 |   6 +-
 spec/unit/crypto.spec.ts                      |  46 +-
 spec/unit/crypto/CrossSigningInfo.spec.ts     |   2 +-
 spec/unit/crypto/DeviceList.spec.ts           |   7 +-
 spec/unit/crypto/algorithms/megolm.spec.ts    |  29 +-
 spec/unit/crypto/algorithms/olm.spec.ts       |  23 +-
 spec/unit/crypto/backup.spec.ts               | 162 ++---
 spec/unit/crypto/cross-signing.spec.ts        |  38 +-
 spec/unit/crypto/crypto-utils.ts              |   9 +-
 spec/unit/crypto/secrets.spec.ts              |  62 +-
 spec/unit/crypto/verification/sas.spec.ts     |  64 +-
 .../verification/secret_request.spec.ts       |   4 +-
 spec/unit/crypto/verification/util.ts         |  20 +-
 .../verification/verification_request.spec.ts |  12 +-
 spec/unit/matrix-client.spec.ts               | 272 ++++----
 spec/unit/models/MSC3089TreeSpace.spec.ts     |   6 +-
 spec/unit/models/event.spec.ts                |   4 +-
 spec/unit/notifications.spec.ts               |   2 +-
 spec/unit/read-receipt.spec.ts                |   2 +-
 spec/unit/realtime-callbacks.spec.ts          |   2 +-
 spec/unit/rendezvous/rendezvous.spec.ts       |   2 +-
 spec/unit/room-member.spec.ts                 |  65 +-
 spec/unit/room.spec.ts                        | 203 +++---
 spec/unit/scheduler.spec.ts                   |  45 +-
 spec/unit/sync-accumulator.spec.ts            |  34 +-
 spec/unit/utils.spec.ts                       |  12 +-
 spec/unit/webrtc/call.spec.ts                 |   6 +-
 src/@types/read_receipts.ts                   |   2 +-
 src/autodiscovery.ts                          |  24 +-
 src/{browser-index.js => browser-index.ts}    |  21 +-
 src/client.ts                                 |  97 +--
 src/crypto/CrossSigning.ts                    |   1 +
 src/crypto/EncryptionSetup.ts                 |   4 +-
 src/crypto/OlmDevice.ts                       |  53 +-
 src/crypto/SecretStorage.ts                   |  36 +-
 src/crypto/algorithms/base.ts                 |  12 +-
 src/crypto/algorithms/megolm.ts               |  38 +-
 src/crypto/algorithms/olm.ts                  |  12 +-
 src/crypto/backup.ts                          |   6 +-
 src/crypto/dehydration.ts                     |   2 +-
 src/crypto/deviceinfo.ts                      |   3 +-
 src/crypto/index.ts                           |  53 +-
 src/crypto/olmlib.ts                          |  12 +-
 src/crypto/store/base.ts                      |   2 +-
 src/crypto/store/localStorage-crypto-store.ts |  14 +-
 src/crypto/verification/QRCode.ts             |  10 +-
 src/crypto/verification/SAS.ts                |  42 +-
 src/filter-component.ts                       |   8 +-
 src/filter.ts                                 |   7 +-
 src/models/event.ts                           |  27 +-
 src/models/invites-ignorer.ts                 |  10 +-
 src/models/room-state.ts                      |  38 +-
 src/models/room-summary.ts                    |   4 +-
 src/models/room.ts                            |   6 +-
 src/pushprocessor.ts                          |   4 +-
 src/scheduler.ts                              |   2 +-
 src/sliding-sync-sdk.ts                       | 110 +++-
 src/sliding-sync.ts                           |  20 +-
 src/store/index.ts                            |   2 +-
 src/store/indexeddb-local-backend.ts          |   4 +-
 src/store/memory.ts                           |   2 +-
 src/store/stub.ts                             |   2 +-
 src/sync-accumulator.ts                       |  71 ++-
 src/sync.ts                                   |  16 +-
 src/utils.ts                                  |  16 +-
 src/webrtc/call.ts                            |   4 +-
 tsconfig.json                                 |   1 -
 yarn.lock                                     |   6 +-
 83 files changed, 1613 insertions(+), 1426 deletions(-)
 rename src/{browser-index.js => browser-index.ts} (76%)

diff --git a/.github/workflows/static_analysis.yml b/.github/workflows/static_analysis.yml
index 5f612727815..dfcaf62af0b 100644
--- a/.github/workflows/static_analysis.yml
+++ b/.github/workflows/static_analysis.yml
@@ -64,7 +64,7 @@ jobs:
 
       - name: Generate Docs
         run: "yarn run gendoc"
-        
+
       - name: Upload Artifact
         uses: actions/upload-artifact@v3
         with:
@@ -72,38 +72,3 @@ jobs:
           path: _docs
           # We'll only use this in a workflow_run, then we're done with it
           retention-days: 1
-
-  tsc-strict:
-    name: Typescript Strict Error Checker
-    if: github.event_name == 'pull_request'
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
-      checks: write
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Get diff lines
-        id: diff
-        uses: Equip-Collaboration/diff-line-numbers@v1.0.0
-        with:
-          include: '["\\.tsx?$"]'
-
-      - name: Detecting files changed
-        id: files
-        uses: futuratrepadeira/changed-files@v4.0.0
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          pattern: '^.*\.tsx?$'
-
-      - uses: t3chguy/typescript-check-action@main
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          use-check: false
-          check-fail-mode: added
-          output-behaviour: annotate
-          ts-extra-args: '--noImplicitAny'
-          files-changed: ${{ steps.files.outputs.files_updated }}
-          files-added: ${{ steps.files.outputs.files_created }}
-          files-deleted: ${{ steps.files.outputs.files_deleted }}
-          line-numbers: ${{ steps.diff.outputs.lineNumbers }}
diff --git a/package.json b/package.json
index 9ad98499a73..76529468dc1 100644
--- a/package.json
+++ b/package.json
@@ -14,7 +14,7 @@
     "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
     "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
     "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
-    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.js -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
+    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
     "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
     "gendoc": "typedoc",
     "lint": "yarn lint:types && yarn lint:js",
@@ -33,9 +33,9 @@
     "matrix-org"
   ],
   "main": "./src/index.ts",
-  "browser": "./lib/browser-index.js",
+  "browser": "./lib/browser-index.ts",
   "matrix_src_main": "./src/index.ts",
-  "matrix_src_browser": "./src/browser-index.js",
+  "matrix_src_browser": "./src/browser-index.ts",
   "matrix_lib_main": "./lib/index.js",
   "matrix_lib_typings": "./lib/index.d.ts",
   "author": "matrix.org",
@@ -80,7 +80,7 @@
     "@babel/preset-typescript": "^7.12.7",
     "@babel/register": "^7.12.10",
     "@casualbot/jest-sonar-reporter": "^2.2.5",
-    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.13.tgz",
+    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
     "@types/bs58": "^4.0.1",
     "@types/content-type": "^1.1.5",
     "@types/domexception": "^4.0.0",
diff --git a/spec/TestClient.ts b/spec/TestClient.ts
index 249f5b39e16..02d26b6a76f 100644
--- a/spec/TestClient.ts
+++ b/spec/TestClient.ts
@@ -183,7 +183,7 @@ export class TestClient {
         this.httpBackend.when('POST', '/keys/query').respond<IDownloadKeyResult>(
             200, (_path, content) => {
                 Object.keys(response.device_keys).forEach((userId) => {
-                    expect(content.device_keys![userId]).toEqual([]);
+                    expect((content.device_keys! as Record<string, any>)[userId]).toEqual([]);
                 });
                 return response;
             });
diff --git a/spec/browserify/setupTests.ts b/spec/browserify/setupTests.ts
index a92a70e23b3..789c0218db3 100644
--- a/spec/browserify/setupTests.ts
+++ b/spec/browserify/setupTests.ts
@@ -15,19 +15,7 @@ limitations under the License.
 */
 
 import "../../dist/browser-matrix"; // uses browser-matrix instead of the src
-import type { MatrixClient, ClientEvent } from "../../src";
-
-declare global {
-    // eslint-disable-next-line @typescript-eslint/no-namespace
-    namespace NodeJS {
-        interface Global {
-            matrixcs: {
-                MatrixClient: typeof MatrixClient;
-                ClientEvent: typeof ClientEvent;
-            };
-        }
-    }
-}
+import type { default as BrowserMatrix } from "../../src/browser-index";
 
 // stub for browser-matrix browserify tests
 // @ts-ignore
@@ -43,4 +31,4 @@ afterAll(() => {
 global.matrixcs = {
     ...global.matrixcs,
     timeoutSignal: () => new AbortController().signal,
-};
+} as typeof BrowserMatrix;
diff --git a/spec/browserify/sync-browserify.spec.ts b/spec/browserify/sync-browserify.spec.ts
index 172cb0c475d..6898c3e1cdc 100644
--- a/spec/browserify/sync-browserify.spec.ts
+++ b/spec/browserify/sync-browserify.spec.ts
@@ -16,7 +16,7 @@ limitations under the License.
 
 import HttpBackend from "matrix-mock-request";
 
-import "./setupTests";// uses browser-matrix instead of the src
+import "./setupTests"; // uses browser-matrix instead of the src
 import type { MatrixClient } from "../../src";
 
 const USER_ID = "@user:test.server";
@@ -65,15 +65,16 @@ describe("Browserify Test", function() {
         const syncData = {
             next_batch: "batch1",
             rooms: {
-                join: {},
-            },
-        };
-        syncData.rooms.join[ROOM_ID] = {
-            timeline: {
-                events: [
-                    event,
-                ],
-                limited: false,
+                join: {
+                    [ROOM_ID]: {
+                        timeline: {
+                            events: [
+                                event,
+                            ],
+                            limited: false,
+                        },
+                    },
+                },
             },
         };
 
diff --git a/spec/integ/devicelist-integ.spec.ts b/spec/integ/devicelist-integ.spec.ts
index acd8f9c8081..5b980149b02 100644
--- a/spec/integ/devicelist-integ.spec.ts
+++ b/spec/integ/devicelist-integ.spec.ts
@@ -30,7 +30,7 @@ const ROOM_ID = "!room:id";
  *
  * @return {object} sync response
  */
-function getSyncResponse(roomMembers) {
+function getSyncResponse(roomMembers: string[]) {
     const stateEvents = [
         testUtils.mkEvent({
             type: 'm.room.encryption',
@@ -43,12 +43,10 @@ function getSyncResponse(roomMembers) {
 
     Array.prototype.push.apply(
         stateEvents,
-        roomMembers.map(
-            (m) => testUtils.mkMembership({
-                mship: 'join',
-                sender: m,
-            }),
-        ),
+        roomMembers.map((m) => testUtils.mkMembership({
+            mship: 'join',
+            sender: m,
+        })),
     );
 
     const syncResponse = {
@@ -73,8 +71,8 @@ describe("DeviceList management:", function() {
         return;
     }
 
-    let sessionStoreBackend;
-    let aliceTestClient;
+    let aliceTestClient: TestClient;
+    let sessionStoreBackend: Storage;
 
     async function createTestClient() {
         const testClient = new TestClient(
@@ -97,7 +95,10 @@ describe("DeviceList management:", function() {
     });
 
     it("Alice shouldn't do a second /query for non-e2e-capable devices", function() {
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
+        aliceTestClient.expectKeyQuery({
+            device_keys: { '@alice:localhost': {} },
+            failures: {},
+        });
         return aliceTestClient.start().then(function() {
             const syncResponse = getSyncResponse(['@bob:xyz']);
             aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
@@ -138,7 +139,10 @@ describe("DeviceList management:", function() {
 
     it.skip("We should not get confused by out-of-order device query responses", () => {
         // https://github.com/vector-im/element-web/issues/3126
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} } });
+        aliceTestClient.expectKeyQuery({
+            device_keys: { '@alice:localhost': {} },
+            failures: {},
+        });
         return aliceTestClient.start().then(() => {
             aliceTestClient.httpBackend.when('GET', '/sync').respond(
                 200, getSyncResponse(['@bob:xyz', '@chris:abc']));
@@ -164,11 +168,12 @@ describe("DeviceList management:", function() {
                 aliceTestClient.httpBackend.flush('/keys/query', 1).then(
                     () => aliceTestClient.httpBackend.flush('/send/', 1),
                 ),
-                aliceTestClient.client.crypto.deviceList.saveIfDirty(),
+                aliceTestClient.client.crypto!.deviceList.saveIfDirty(),
             ]);
         }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                expect(data.syncToken).toEqual(1);
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                expect(data!.syncToken).toEqual(1);
             });
 
             // invalidate bob's and chris's device lists in separate syncs
@@ -201,15 +206,16 @@ describe("DeviceList management:", function() {
             return aliceTestClient.httpBackend.flush('/keys/query', 1);
         }).then((flushed) => {
             expect(flushed).toEqual(0);
-            return aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
         }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus['@bob:xyz'];
                 if (bobStat != 1 && bobStat != 2) {
                     throw new Error('Unexpected status for bob: wanted 1 or 2, got ' +
                         bobStat);
                 }
-                const chrisStat = data.trackingStatus['@chris:abc'];
+                const chrisStat = data!.trackingStatus['@chris:abc'];
                 if (chrisStat != 1 && chrisStat != 2) {
                     throw new Error(
                         'Unexpected status for chris: wanted 1 or 2, got ' + chrisStat,
@@ -234,12 +240,13 @@ describe("DeviceList management:", function() {
             // wait for the client to stop processing the response
             return aliceTestClient.client.downloadKeys(['@bob:xyz']);
         }).then(() => {
-            return aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
         }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus['@bob:xyz'];
                 expect(bobStat).toEqual(3);
-                const chrisStat = data.trackingStatus['@chris:abc'];
+                const chrisStat = data!.trackingStatus['@chris:abc'];
                 if (chrisStat != 1 && chrisStat != 2) {
                     throw new Error(
                         'Unexpected status for chris: wanted 1 or 2, got ' + bobStat,
@@ -255,15 +262,16 @@ describe("DeviceList management:", function() {
             // wait for the client to stop processing the response
             return aliceTestClient.client.downloadKeys(['@chris:abc']);
         }).then(() => {
-            return aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
         }).then(() => {
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
-                const chrisStat = data.trackingStatus['@bob:xyz'];
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus['@bob:xyz'];
+                const chrisStat = data!.trackingStatus['@bob:xyz'];
 
                 expect(bobStat).toEqual(3);
                 expect(chrisStat).toEqual(3);
-                expect(data.syncToken).toEqual(3);
+                expect(data!.syncToken).toEqual(3);
             });
         });
     });
@@ -285,10 +293,11 @@ describe("DeviceList management:", function() {
                 },
             );
             await aliceTestClient.httpBackend.flush('/keys/query', 1);
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
 
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus['@bob:xyz'];
 
                 // Alice should be tracking bob's device list
                 expect(bobStat).toBeGreaterThan(
@@ -322,10 +331,11 @@ describe("DeviceList management:", function() {
             );
 
             await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
 
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus['@bob:xyz'];
 
                 // Alice should have marked bob's device list as untracked
                 expect(bobStat).toEqual(
@@ -359,15 +369,14 @@ describe("DeviceList management:", function() {
             );
 
             await aliceTestClient.flushSync();
-            await aliceTestClient.client.crypto.deviceList.saveIfDirty();
+            await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
 
-            aliceTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data.trackingStatus['@bob:xyz'];
+            // @ts-ignore accessing a protected field
+            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                const bobStat = data!.trackingStatus['@bob:xyz'];
 
                 // Alice should have marked bob's device list as untracked
-                expect(bobStat).toEqual(
-                    0,
-                );
+                expect(bobStat).toEqual(0);
             });
         });
 
@@ -388,9 +397,7 @@ describe("DeviceList management:", function() {
                     const bobStat = data!.trackingStatus['@bob:xyz'];
 
                     // Alice should have marked bob's device list as untracked
-                    expect(bobStat).toEqual(
-                        0,
-                    );
+                    expect(bobStat).toEqual(0);
                 });
             } finally {
                 anotherTestClient.stop();
diff --git a/spec/integ/matrix-client-crypto.spec.ts b/spec/integ/matrix-client-crypto.spec.ts
index 847bb8528ae..adb7dd25b9a 100644
--- a/spec/integ/matrix-client-crypto.spec.ts
+++ b/spec/integ/matrix-client-crypto.spec.ts
@@ -28,12 +28,14 @@ limitations under the License.
 // load olm before the sdk if possible
 import '../olm-loader';
 
+import type { Session } from "@matrix-org/olm";
 import { logger } from '../../src/logger';
 import * as testUtils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
-import { CRYPTO_ENABLED, IUploadKeysRequest } from "../../src/client";
+import { CRYPTO_ENABLED, IClaimKeysRequest, IQueryKeysRequest, IUploadKeysRequest } from "../../src/client";
 import { ClientEvent, IContent, ISendEventResponse, MatrixClient, MatrixEvent } from "../../src/matrix";
 import { DeviceInfo } from '../../src/crypto/deviceinfo';
+import { IDeviceKeys, IOneTimeKey } from "../../src/crypto/dehydration";
 
 let aliTestClient: TestClient;
 const roomId = "!room:localhost";
@@ -47,11 +49,7 @@ const bobAccessToken = "fewgfkuesa";
 let aliMessages: IContent[];
 let bobMessages: IContent[];
 
-// IMessage isn't exported by src/crypto/algorithms/olm.ts
-interface OlmPayload {
-    type: number;
-    body: string;
-}
+type OlmPayload = ReturnType<Session["encrypt"]>;
 
 async function bobUploadsDeviceKeys(): Promise<void> {
     bobTestClient.expectDeviceKeyUpload();
@@ -71,12 +69,12 @@ function expectQueryKeys(querier: TestClient, uploader: TestClient): Promise<num
     // can't query keys before bob has uploaded them
     expect(uploader.deviceKeys).toBeTruthy();
 
-    const uploaderKeys = {};
-    uploaderKeys[uploader.deviceId!] = uploader.deviceKeys;
+    const uploaderKeys: Record<string, IDeviceKeys> = {};
+    uploaderKeys[uploader.deviceId!] = uploader.deviceKeys!;
     querier.httpBackend.when("POST", "/keys/query")
-        .respond(200, function(_path, content: IUploadKeysRequest) {
+        .respond(200, function(_path, content: IQueryKeysRequest) {
             expect(content.device_keys![uploader.userId!]).toEqual([]);
-            const result = {};
+            const result: Record<string, Record<string, IDeviceKeys>> = {};
             result[uploader.userId!] = uploaderKeys;
             return { device_keys: result };
         });
@@ -94,7 +92,7 @@ async function expectAliClaimKeys(): Promise<void> {
     const keys = await bobTestClient.awaitOneTimeKeyUpload();
     aliTestClient.httpBackend.when(
         "POST", "/keys/claim",
-    ).respond(200, function(_path, content: IUploadKeysRequest) {
+    ).respond(200, function(_path, content: IClaimKeysRequest) {
         const claimType = content.one_time_keys![bobUserId][bobDeviceId];
         expect(claimType).toEqual("signed_curve25519");
         let keyId = '';
@@ -105,7 +103,7 @@ async function expectAliClaimKeys(): Promise<void> {
                 }
             }
         }
-        const result = {};
+        const result: Record<string, Record<string, Record<string, IOneTimeKey>>> = {};
         result[bobUserId] = {};
         result[bobUserId][bobDeviceId] = {};
         result[bobUserId][bobDeviceId][keyId] = keys[keyId];
@@ -276,22 +274,21 @@ async function recvMessage(
         next_batch: "x",
         rooms: {
             join: {
-
+                [roomId]: {
+                    timeline: {
+                        events: [
+                            testUtils.mkEvent({
+                                type: "m.room.encrypted",
+                                room: roomId,
+                                content: message,
+                                sender: sender,
+                            }),
+                        ],
+                    },
+                },
             },
         },
     };
-    syncData.rooms.join[roomId] = {
-        timeline: {
-            events: [
-                testUtils.mkEvent({
-                    type: "m.room.encrypted",
-                    room: roomId,
-                    content: message,
-                    sender: sender,
-                }),
-            ],
-        },
-    };
     httpBackend.when("GET", "/sync").respond(200, syncData);
 
     const eventPromise = new Promise<MatrixEvent>((resolve) => {
@@ -335,24 +332,25 @@ function firstSync(testClient: TestClient): Promise<void> {
     const syncData = {
         next_batch: "x",
         rooms: {
-            join: { },
-        },
-    };
-    syncData.rooms.join[roomId] = {
-        state: {
-            events: [
-                testUtils.mkMembership({
-                    mship: "join",
-                    user: aliUserId,
-                }),
-                testUtils.mkMembership({
-                    mship: "join",
-                    user: bobUserId,
-                }),
-            ],
-        },
-        timeline: {
-            events: [],
+            join: {
+                [roomId]: {
+                    state: {
+                        events: [
+                            testUtils.mkMembership({
+                                mship: "join",
+                                user: aliUserId,
+                            }),
+                            testUtils.mkMembership({
+                                mship: "join",
+                                user: bobUserId,
+                            }),
+                        ],
+                    },
+                    timeline: {
+                        events: [],
+                    },
+                },
+            },
         },
     };
 
@@ -424,7 +422,7 @@ describe("MatrixClient crypto", () => {
             },
         };
 
-        const bobKeys = {};
+        const bobKeys: Record<string, typeof bobDeviceKeys> = {};
         bobKeys[bobDeviceId] = bobDeviceKeys;
         aliTestClient.httpBackend.when(
             "POST", "/keys/query",
@@ -460,7 +458,7 @@ describe("MatrixClient crypto", () => {
             },
         };
 
-        const bobKeys = {};
+        const bobKeys: Record<string, typeof bobDeviceKeys> = {};
         bobKeys[bobDeviceId] = bobDeviceKeys;
         aliTestClient.httpBackend.when(
             "POST", "/keys/query",
@@ -515,22 +513,21 @@ describe("MatrixClient crypto", () => {
             next_batch: "x",
             rooms: {
                 join: {
-
+                    [roomId]: {
+                        timeline: {
+                            events: [
+                                testUtils.mkEvent({
+                                    type: "m.room.encrypted",
+                                    room: roomId,
+                                    content: message,
+                                    sender: "@bogus:sender",
+                                }),
+                            ],
+                        },
+                    },
                 },
             },
         };
-        syncData.rooms.join[roomId] = {
-            timeline: {
-                events: [
-                    testUtils.mkEvent({
-                        type: "m.room.encrypted",
-                        room: roomId,
-                        content: message,
-                        sender: "@bogus:sender",
-                    }),
-                ],
-            },
-        };
         bobTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
 
         const eventPromise = new Promise<MatrixEvent>((resolve) => {
@@ -607,20 +604,21 @@ describe("MatrixClient crypto", () => {
         const syncData = {
             next_batch: '2',
             rooms: {
-                join: {},
-            },
-        };
-        syncData.rooms.join[roomId] = {
-            state: {
-                events: [
-                    testUtils.mkEvent({
-                        type: 'm.room.encryption',
-                        skey: '',
-                        content: {
-                            algorithm: 'm.olm.v1.curve25519-aes-sha2',
+                join: {
+                    [roomId]: {
+                        state: {
+                            events: [
+                                testUtils.mkEvent({
+                                    type: 'm.room.encryption',
+                                    skey: '',
+                                    content: {
+                                        algorithm: 'm.olm.v1.curve25519-aes-sha2',
+                                    },
+                                }),
+                            ],
                         },
-                    }),
-                ],
+                    },
+                },
             },
         };
 
diff --git a/spec/integ/matrix-client-event-timeline.spec.ts b/spec/integ/matrix-client-event-timeline.spec.ts
index 663af8fbfcd..5bbb8275972 100644
--- a/spec/integ/matrix-client-event-timeline.spec.ts
+++ b/spec/integ/matrix-client-event-timeline.spec.ts
@@ -536,20 +536,20 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            let tl0;
-            let tl3;
+            let tl0: EventTimeline;
+            let tl3: EventTimeline;
             return Promise.all([
                 client.getEventTimeline(timelineSet, EVENTS[0].event_id!,
                 ).then(function(tl) {
                     expect(tl!.getEvents().length).toEqual(1);
-                    tl0 = tl;
+                    tl0 = tl!;
                     return client.getEventTimeline(timelineSet, EVENTS[2].event_id!);
                 }).then(function(tl) {
                     expect(tl!.getEvents().length).toEqual(1);
                     return client.getEventTimeline(timelineSet, EVENTS[3].event_id!);
                 }).then(function(tl) {
                     expect(tl!.getEvents().length).toEqual(1);
-                    tl3 = tl;
+                    tl3 = tl!;
                     return client.getEventTimeline(timelineSet, EVENTS[1].event_id!);
                 }).then(function(tl) {
                     // we expect it to get merged in with event 2
@@ -953,11 +953,11 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            let tl;
+            let tl: EventTimeline;
             return Promise.all([
                 client.getEventTimeline(timelineSet, EVENTS[0].event_id!,
                 ).then(function(tl0) {
-                    tl = tl0;
+                    tl = tl0!;
                     return client.paginateEventTimeline(tl, { backwards: true });
                 }).then(function(success) {
                     expect(success).toBeTruthy();
@@ -1043,11 +1043,11 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            let tl;
+            let tl: EventTimeline;
             return Promise.all([
                 client.getEventTimeline(timelineSet, EVENTS[0].event_id!,
                 ).then(function(tl0) {
-                    tl = tl0;
+                    tl = tl0!;
                     return client.paginateEventTimeline(
                         tl, { backwards: false, limit: 20 });
                 }).then(function(success) {
@@ -1569,16 +1569,17 @@ describe("MatrixClient event timelines", function() {
         const syncData = {
             next_batch: "batch1",
             rooms: {
-                join: {},
-            },
-        };
-        syncData.rooms.join[roomId] = {
-            timeline: {
-                events: [
-                    event,
-                    redaction,
-                ],
-                limited: false,
+                join: {
+                    [roomId]: {
+                        timeline: {
+                            events: [
+                                event,
+                                redaction,
+                            ],
+                            limited: false,
+                        },
+                    },
+                },
             },
         };
         httpBackend.when("GET", "/sync").respond(200, syncData);
@@ -1595,18 +1596,19 @@ describe("MatrixClient event timelines", function() {
             const sync2 = {
                 next_batch: "batch2",
                 rooms: {
-                    join: {},
-                },
-            };
-            sync2.rooms.join[roomId] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            user: otherUserId, msg: "world",
-                        }),
-                    ],
-                    limited: true,
-                    prev_batch: "newerTok",
+                    join: {
+                        [roomId]: {
+                            timeline: {
+                                events: [
+                                    utils.mkMessage({
+                                        user: otherUserId, msg: "world",
+                                    }),
+                                ],
+                                limited: true,
+                                prev_batch: "newerTok",
+                            },
+                        },
+                    },
                 },
             };
             httpBackend.when("GET", "/sync").respond(200, sync2);
diff --git a/spec/integ/matrix-client-methods.spec.ts b/spec/integ/matrix-client-methods.spec.ts
index f2ff9e6df77..93c3d353727 100644
--- a/spec/integ/matrix-client-methods.spec.ts
+++ b/spec/integ/matrix-client-methods.spec.ts
@@ -618,13 +618,13 @@ describe("MatrixClient", function() {
     });
 
     describe("partitionThreadedEvents", function() {
-        let room;
+        let room: Room;
         beforeEach(() => {
             room = new Room("!STrMRsukXHtqQdSeHa:matrix.org", client!, userId);
         });
 
         it("returns empty arrays when given an empty arrays", function() {
-            const events = [];
+            const events: MatrixEvent[] = [];
             const [timeline, threaded] = room.partitionThreadedEvents(events);
             expect(timeline).toEqual([]);
             expect(threaded).toEqual([]);
@@ -1645,7 +1645,7 @@ const buildEventCreate = () => new MatrixEvent({
     "user_id": "@andybalaam-test1:matrix.org",
 });
 
-function assertObjectContains(obj: object, expected: any): void {
+function assertObjectContains(obj: Record<string, any>, expected: any): void {
     for (const k in expected) {
         if (expected.hasOwnProperty(k)) {
             expect(obj[k]).toEqual(expected[k]);
diff --git a/spec/integ/matrix-client-opts.spec.ts b/spec/integ/matrix-client-opts.spec.ts
index 5ea4fba7718..41532ea526b 100644
--- a/spec/integ/matrix-client-opts.spec.ts
+++ b/spec/integ/matrix-client-opts.spec.ts
@@ -1,7 +1,7 @@
 import HttpBackend from "matrix-mock-request";
 
 import * as utils from "../test-utils/test-utils";
-import { MatrixClient } from "../../src/matrix";
+import { ClientEvent, MatrixClient } from "../../src/matrix";
 import { MatrixScheduler } from "../../src/scheduler";
 import { MemoryStore } from "../../src/store/memory";
 import { MatrixError } from "../../src/http-api";
@@ -65,7 +65,7 @@ describe("MatrixClient opts", function() {
     });
 
     describe("without opts.store", function() {
-        let client;
+        let client: MatrixClient;
         beforeEach(function() {
             client = new MatrixClient({
                 fetchFn: httpBackend.fetchFn as typeof global.fetch,
@@ -98,7 +98,7 @@ describe("MatrixClient opts", function() {
                 "m.room.message", "m.room.name", "m.room.member", "m.room.member",
                 "m.room.create",
             ];
-            client.on("event", function(event) {
+            client.on(ClientEvent.Event, function(event) {
                 expect(expectedEventTypes.indexOf(event.getType())).not.toEqual(
                     -1,
                 );
@@ -125,7 +125,7 @@ describe("MatrixClient opts", function() {
     });
 
     describe("without opts.scheduler", function() {
-        let client;
+        let client: MatrixClient;
         beforeEach(function() {
             client = new MatrixClient({
                 fetchFn: httpBackend.fetchFn as typeof global.fetch,
diff --git a/spec/integ/matrix-client-room-timeline.spec.ts b/spec/integ/matrix-client-room-timeline.spec.ts
index f89ab04e2b8..3c2aa77a6e3 100644
--- a/spec/integ/matrix-client-room-timeline.spec.ts
+++ b/spec/integ/matrix-client-room-timeline.spec.ts
@@ -18,7 +18,16 @@ import HttpBackend from "matrix-mock-request";
 
 import * as utils from "../test-utils/test-utils";
 import { EventStatus } from "../../src/models/event";
-import { MatrixError, ClientEvent, IEvent, MatrixClient, RoomEvent } from "../../src";
+import {
+    MatrixError,
+    ClientEvent,
+    IEvent,
+    MatrixClient,
+    RoomEvent,
+    ISyncResponse,
+    IMinimalEvent,
+    IRoomEvent, Room,
+} from "../../src";
 import { TestClient } from "../TestClient";
 
 describe("MatrixClient room timelines", function() {
@@ -39,7 +48,7 @@ describe("MatrixClient room timelines", function() {
             name: "Old room name",
         },
     });
-    let NEXT_SYNC_DATA;
+    let NEXT_SYNC_DATA: Partial<ISyncResponse>;
     const SYNC_DATA = {
         next_batch: "s_5_3",
         rooms: {
@@ -88,7 +97,7 @@ describe("MatrixClient room timelines", function() {
                     },
                 },
                 leave: {},
-            },
+            } as unknown as ISyncResponse["rooms"],
         };
         events.forEach(function(e) {
             if (e.room_id !== roomId) {
@@ -96,11 +105,11 @@ describe("MatrixClient room timelines", function() {
             }
             if (e.state_key) {
                 // push the current
-                NEXT_SYNC_DATA.rooms.join[roomId].timeline.events.push(e);
+                NEXT_SYNC_DATA.rooms!.join[roomId].timeline.events.push(e as unknown as IRoomEvent);
             } else if (["m.typing", "m.receipt"].indexOf(e.type!) !== -1) {
-                NEXT_SYNC_DATA.rooms.join[roomId].ephemeral.events.push(e);
+                NEXT_SYNC_DATA.rooms!.join[roomId].ephemeral.events.push(e as unknown as IMinimalEvent);
             } else {
-                NEXT_SYNC_DATA.rooms.join[roomId].timeline.events.push(e);
+                NEXT_SYNC_DATA.rooms!.join[roomId].timeline.events.push(e as unknown as IRoomEvent);
             }
         });
     }
@@ -237,7 +246,7 @@ describe("MatrixClient room timelines", function() {
     });
 
     describe("paginated events", function() {
-        let sbEvents;
+        let sbEvents: Partial<IEvent>[];
         const sbEndTok = "pagin_end";
 
         beforeEach(function() {
@@ -559,7 +568,7 @@ describe("MatrixClient room timelines", function() {
                 utils.mkMessage({ user: userId, room: roomId }),
             ];
             setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;
+            NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
 
             return Promise.all([
                 httpBackend!.flush("/versions", 1),
@@ -593,7 +602,7 @@ describe("MatrixClient room timelines", function() {
                 utils.mkMessage({ user: userId, room: roomId }),
             ];
             setNextSyncData(eventData);
-            NEXT_SYNC_DATA.rooms.join[roomId].timeline.limited = true;
+            NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
 
             return Promise.all([
                 httpBackend!.flush("/sync", 1),
@@ -638,7 +647,7 @@ describe("MatrixClient room timelines", function() {
             end: "end_token",
         };
 
-        let room;
+        let room: Room;
         beforeEach(async () => {
             setNextSyncData(initialSyncEventData);
 
diff --git a/spec/integ/matrix-client-syncing.spec.ts b/spec/integ/matrix-client-syncing.spec.ts
index 8c3969bee7d..dbb891449cc 100644
--- a/spec/integ/matrix-client-syncing.spec.ts
+++ b/spec/integ/matrix-client-syncing.spec.ts
@@ -33,7 +33,7 @@ import {
     IJoinedRoom,
     IStateEvent,
     IMinimalEvent,
-    NotificationCountType,
+    NotificationCountType, IEphemeral,
 } from "../../src";
 import { UNREAD_THREAD_NOTIFICATIONS } from '../../src/@types/sync';
 import * as utils from "../test-utils/test-utils";
@@ -524,105 +524,101 @@ describe("MatrixClient syncing", () => {
         const syncData = {
             rooms: {
                 join: {
-
-                },
-            },
-        };
-        syncData.rooms.join[roomOne] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomOne, user: otherUserId, msg: "hello",
-                    }),
-                ],
-            },
-            state: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.room.name", room: roomOne, user: otherUserId,
-                        content: {
-                            name: "Old room name",
+                    [roomOne]: {
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: roomOne, user: otherUserId, msg: "hello",
+                                }),
+                            ],
                         },
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: otherUserId,
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: selfUserId,
-                    }),
-                    utils.mkEvent({
-                        type: "m.room.create", room: roomOne, user: selfUserId,
-                        content: {
-                            creator: selfUserId,
+                        state: {
+                            events: [
+                                utils.mkEvent({
+                                    type: "m.room.name", room: roomOne, user: otherUserId,
+                                    content: {
+                                        name: "Old room name",
+                                    },
+                                }),
+                                utils.mkMembership({
+                                    room: roomOne, mship: "join", user: otherUserId,
+                                }),
+                                utils.mkMembership({
+                                    room: roomOne, mship: "join", user: selfUserId,
+                                }),
+                                utils.mkEvent({
+                                    type: "m.room.create", room: roomOne, user: selfUserId,
+                                    content: {
+                                        creator: selfUserId,
+                                    },
+                                }),
+                            ],
                         },
-                    }),
-                ],
-            },
-        };
-        syncData.rooms.join[roomTwo] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomTwo, user: otherUserId, msg: "hiii",
-                    }),
-                ],
-            },
-            state: {
-                events: [
-                    utils.mkMembership({
-                        room: roomTwo, mship: "join", user: otherUserId,
-                        name: otherDisplayName,
-                    }),
-                    utils.mkMembership({
-                        room: roomTwo, mship: "join", user: selfUserId,
-                    }),
-                    utils.mkEvent({
-                        type: "m.room.create", room: roomTwo, user: selfUserId,
-                        content: {
-                            creator: selfUserId,
+                    },
+                    [roomTwo]: {
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: roomTwo, user: otherUserId, msg: "hiii",
+                                }),
+                            ],
                         },
-                    }),
-                ],
+                        state: {
+                            events: [
+                                utils.mkMembership({
+                                    room: roomTwo, mship: "join", user: otherUserId,
+                                    name: otherDisplayName,
+                                }),
+                                utils.mkMembership({
+                                    room: roomTwo, mship: "join", user: selfUserId,
+                                }),
+                                utils.mkEvent({
+                                    type: "m.room.create", room: roomTwo, user: selfUserId,
+                                    content: {
+                                        creator: selfUserId,
+                                    },
+                                }),
+                            ],
+                        },
+                    },
+                },
             },
         };
 
         const nextSyncData = {
             rooms: {
                 join: {
-
+                    [roomOne]: {
+                        state: {
+                            events: [
+                                utils.mkEvent({
+                                    type: "m.room.name", room: roomOne, user: selfUserId,
+                                    content: { name: "A new room name" },
+                                }),
+                            ],
+                        },
+                    },
+                    [roomTwo]: {
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: roomTwo, user: otherUserId, msg: msgText,
+                                }),
+                            ],
+                        },
+                        ephemeral: {
+                            events: [
+                                utils.mkEvent({
+                                    type: "m.typing", room: roomTwo,
+                                    content: { user_ids: [otherUserId] },
+                                }),
+                            ],
+                        },
+                    },
                 },
             },
         };
 
-        nextSyncData.rooms.join[roomOne] = {
-            state: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.room.name", room: roomOne, user: selfUserId,
-                        content: { name: "A new room name" },
-                    }),
-                ],
-            },
-        };
-
-        nextSyncData.rooms.join[roomTwo] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomTwo, user: otherUserId, msg: msgText,
-                    }),
-                ],
-            },
-            ephemeral: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.typing", room: roomTwo,
-                        content: { user_ids: [otherUserId] },
-                    }),
-                ],
-            },
-        };
-
         it("should continually recalculate the right room name.", () => {
             httpBackend!.when("GET", "/sync").respond(200, syncData);
             httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
@@ -635,9 +631,7 @@ describe("MatrixClient syncing", () => {
             ]).then(() => {
                 const room = client!.getRoom(roomOne)!;
                 // should have clobbered the name to the one from /events
-                expect(room.name).toEqual(
-                    nextSyncData.rooms.join[roomOne].state.events[0].content.name,
-                );
+                expect(room.name).toEqual(nextSyncData.rooms.join[roomOne].state.events[0].content?.name);
             });
         });
 
@@ -742,46 +736,48 @@ describe("MatrixClient syncing", () => {
                 const normalFirstSync = {
                     next_batch: "batch_token",
                     rooms: {
-                        join: {},
-                    },
-                };
-                normalFirstSync.rooms.join[roomOne] = {
-                    timeline: {
-                        events: [normalMessageEvent],
-                        prev_batch: "pagTok",
-                    },
-                    state: {
-                        events: [roomCreateEvent],
+                        join: {
+                            [roomOne]: {
+                                timeline: {
+                                    events: [normalMessageEvent],
+                                    prev_batch: "pagTok",
+                                },
+                                state: {
+                                    events: [roomCreateEvent],
+                                },
+                            },
+                        },
                     },
                 };
 
                 const nextSyncData = {
                     next_batch: "batch_token",
                     rooms: {
-                        join: {},
-                    },
-                };
-                nextSyncData.rooms.join[roomOne] = {
-                    timeline: {
-                        events: [
-                            // In subsequent syncs, a marker event in timeline
-                            // range should normally trigger
-                            // `timelineNeedsRefresh=true` but this marker isn't
-                            // being sent by the room creator so it has no
-                            // special meaning in existing room versions.
-                            utils.mkEvent({
-                                type: UNSTABLE_MSC2716_MARKER.name,
-                                room: roomOne,
-                                // The important part we're testing is here!
-                                // `userC` is not the room creator.
-                                user: userC,
-                                skey: "",
-                                content: {
-                                    "m.insertion_id": "$abc",
+                        join: {
+                            [roomOne]: {
+                                timeline: {
+                                    events: [
+                                        // In subsequent syncs, a marker event in timeline
+                                        // range should normally trigger
+                                        // `timelineNeedsRefresh=true` but this marker isn't
+                                        // being sent by the room creator so it has no
+                                        // special meaning in existing room versions.
+                                        utils.mkEvent({
+                                            type: UNSTABLE_MSC2716_MARKER.name,
+                                            room: roomOne,
+                                            // The important part we're testing is here!
+                                            // `userC` is not the room creator.
+                                            user: userC,
+                                            skey: "",
+                                            content: {
+                                                "m.insertion_id": "$abc",
+                                            },
+                                        }),
+                                    ],
+                                    prev_batch: "pagTok",
                                 },
-                            }),
-                        ],
-                        prev_batch: "pagTok",
+                            },
+                        },
                     },
                 };
 
@@ -831,16 +827,17 @@ describe("MatrixClient syncing", () => {
                     const normalFirstSync = {
                         next_batch: "batch_token",
                         rooms: {
-                            join: {},
-                        },
-                    };
-                    normalFirstSync.rooms.join[roomOne] = {
-                        timeline: {
-                            events: [normalMessageEvent],
-                            prev_batch: "pagTok",
-                        },
-                        state: {
-                            events: [roomCreateEvent],
+                            join: {
+                                [roomOne]: {
+                                    timeline: {
+                                        events: [normalMessageEvent],
+                                        prev_batch: "pagTok",
+                                    },
+                                    state: {
+                                        events: [roomCreateEvent],
+                                    },
+                                },
+                            },
                         },
                     };
 
@@ -849,16 +846,17 @@ describe("MatrixClient syncing", () => {
                         const syncData = {
                             next_batch: "batch_token",
                             rooms: {
-                                join: {},
-                            },
-                        };
-                        syncData.rooms.join[roomOne] = {
-                            timeline: {
-                                events: [normalMessageEvent],
-                                prev_batch: "pagTok",
-                            },
-                            state: {
-                                events: [roomCreateEvent],
+                                join: {
+                                    [roomOne]: {
+                                        timeline: {
+                                            events: [normalMessageEvent],
+                                            prev_batch: "pagTok",
+                                        },
+                                        state: {
+                                            events: [roomCreateEvent],
+                                        },
+                                    },
+                                },
                             },
                         };
 
@@ -879,16 +877,17 @@ describe("MatrixClient syncing", () => {
                         const syncData = {
                             next_batch: "batch_token",
                             rooms: {
-                                join: {},
-                            },
-                        };
-                        syncData.rooms.join[roomOne] = {
-                            timeline: {
-                                events: [markerEventFromRoomCreator],
-                                prev_batch: "pagTok",
-                            },
-                            state: {
-                                events: [roomCreateEvent],
+                                join: {
+                                    [roomOne]: {
+                                        timeline: {
+                                            events: [markerEventFromRoomCreator],
+                                            prev_batch: "pagTok",
+                                        },
+                                        state: {
+                                            events: [roomCreateEvent],
+                                        },
+                                    },
+                                },
                             },
                         };
 
@@ -909,19 +908,20 @@ describe("MatrixClient syncing", () => {
                         const syncData = {
                             next_batch: "batch_token",
                             rooms: {
-                                join: {},
-                            },
-                        };
-                        syncData.rooms.join[roomOne] = {
-                            timeline: {
-                                events: [normalMessageEvent],
-                                prev_batch: "pagTok",
-                            },
-                            state: {
-                                events: [
-                                    roomCreateEvent,
-                                    markerEventFromRoomCreator,
-                                ],
+                                join: {
+                                    [roomOne]: {
+                                        timeline: {
+                                            events: [normalMessageEvent],
+                                            prev_batch: "pagTok",
+                                        },
+                                        state: {
+                                            events: [
+                                                roomCreateEvent,
+                                                markerEventFromRoomCreator,
+                                            ],
+                                        },
+                                    },
+                                },
                             },
                         };
 
@@ -942,17 +942,18 @@ describe("MatrixClient syncing", () => {
                         const nextSyncData = {
                             next_batch: "batch_token",
                             rooms: {
-                                join: {},
-                            },
-                        };
-                        nextSyncData.rooms.join[roomOne] = {
-                            timeline: {
-                                events: [
-                                    // In subsequent syncs, a marker event in timeline
-                                    // range should trigger `timelineNeedsRefresh=true`
-                                    markerEventFromRoomCreator,
-                                ],
-                                prev_batch: "pagTok",
+                                join: {
+                                    [roomOne]: {
+                                        timeline: {
+                                            events: [
+                                                // In subsequent syncs, a marker event in timeline
+                                                // range should trigger `timelineNeedsRefresh=true`
+                                                markerEventFromRoomCreator,
+                                            ],
+                                            prev_batch: "pagTok",
+                                        },
+                                    },
+                                },
                             },
                         };
 
@@ -993,24 +994,25 @@ describe("MatrixClient syncing", () => {
                         const nextSyncData = {
                             next_batch: "batch_token",
                             rooms: {
-                                join: {},
-                            },
-                        };
-                        nextSyncData.rooms.join[roomOne] = {
-                            timeline: {
-                                events: [
-                                    utils.mkMessage({
-                                        room: roomOne, user: otherUserId, msg: "hello again",
-                                    }),
-                                ],
-                                prev_batch: "pagTok",
-                            },
-                            state: {
-                                events: [
-                                    // In subsequent syncs, a marker event in state
-                                    // should trigger `timelineNeedsRefresh=true`
-                                    markerEventFromRoomCreator,
-                                ],
+                                join: {
+                                    [roomOne]: {
+                                        timeline: {
+                                            events: [
+                                                utils.mkMessage({
+                                                    room: roomOne, user: otherUserId, msg: "hello again",
+                                                }),
+                                            ],
+                                            prev_batch: "pagTok",
+                                        },
+                                        state: {
+                                            events: [
+                                                // In subsequent syncs, a marker event in state
+                                                // should trigger `timelineNeedsRefresh=true`
+                                                markerEventFromRoomCreator,
+                                            ],
+                                        },
+                                    },
+                                },
                             },
                         };
 
@@ -1095,19 +1097,20 @@ describe("MatrixClient syncing", () => {
                 const limitedSyncData = {
                     next_batch: "batch_token",
                     rooms: {
-                        join: {},
-                    },
-                };
-                limitedSyncData.rooms.join[roomOne] = {
-                    timeline: {
-                        events: [
-                            utils.mkMessage({
-                                room: roomOne, user: otherUserId, msg: "world",
-                            }),
-                        ],
-                        // The important part, make the sync `limited`
-                        limited: true,
-                        prev_batch: "newerTok",
+                        join: {
+                            [roomOne]: {
+                                timeline: {
+                                    events: [
+                                        utils.mkMessage({
+                                            room: roomOne, user: otherUserId, msg: "world",
+                                        }),
+                                    ],
+                                    // The important part, make the sync `limited`
+                                    limited: true,
+                                    prev_batch: "newerTok",
+                                },
+                            },
+                        },
                     },
                 };
                 httpBackend!.when("GET", "/sync").respond(200, limitedSyncData);
@@ -1167,7 +1170,7 @@ describe("MatrixClient syncing", () => {
 
                 const eventsInRoom = syncData.rooms.join[roomOne].timeline.events;
                 const contextUrl = `/rooms/${encodeURIComponent(roomOne)}/context/` +
-                    `${encodeURIComponent(eventsInRoom[0].event_id)}`;
+                    `${encodeURIComponent(eventsInRoom[0].event_id!)}`;
                 httpBackend!.when("GET", contextUrl)
                     .respond(200, () => {
                         return {
@@ -1202,17 +1205,18 @@ describe("MatrixClient syncing", () => {
             const syncData = {
                 next_batch: "batch_token",
                 rooms: {
-                    join: {},
-                },
-            };
-            syncData.rooms.join[roomOne] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomOne, user: otherUserId, msg: "hello",
-                        }),
-                    ],
-                    prev_batch: "pagTok",
+                    join: {
+                        [roomOne]: {
+                            timeline: {
+                                events: [
+                                    utils.mkMessage({
+                                        room: roomOne, user: otherUserId, msg: "hello",
+                                    }),
+                                ],
+                                prev_batch: "pagTok",
+                            },
+                        },
+                    },
                 },
             };
 
@@ -1229,17 +1233,18 @@ describe("MatrixClient syncing", () => {
             const syncData = {
                 next_batch: "batch_token",
                 rooms: {
-                    join: {},
-                },
-            };
-            syncData.rooms.join[roomTwo] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomTwo, user: otherUserId, msg: "roomtwo",
-                        }),
-                    ],
-                    prev_batch: "roomtwotok",
+                    join: {
+                        [roomTwo]: {
+                            timeline: {
+                                events: [
+                                    utils.mkMessage({
+                                        room: roomTwo, user: otherUserId, msg: "roomtwo",
+                                    }),
+                                ],
+                                prev_batch: "roomtwotok",
+                            },
+                        },
+                    },
                 },
             };
 
@@ -1261,18 +1266,19 @@ describe("MatrixClient syncing", () => {
             const syncData = {
                 next_batch: "batch_token",
                 rooms: {
-                    join: {},
-                },
-            };
-            syncData.rooms.join[roomOne] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomOne, user: otherUserId, msg: "world",
-                        }),
-                    ],
-                    limited: true,
-                    prev_batch: "newerTok",
+                    join: {
+                        [roomOne]: {
+                            timeline: {
+                                events: [
+                                    utils.mkMessage({
+                                        room: roomOne, user: otherUserId, msg: "world",
+                                    }),
+                                ],
+                                limited: true,
+                                prev_batch: "newerTok",
+                            },
+                        },
+                    },
                 },
             };
             httpBackend!.when("GET", "/sync").respond(200, syncData);
@@ -1304,42 +1310,44 @@ describe("MatrixClient syncing", () => {
         const syncData = {
             rooms: {
                 join: {
-
-                },
-            },
-        };
-        syncData.rooms.join[roomOne] = {
-            timeline: {
-                events: [
-                    utils.mkMessage({
-                        room: roomOne, user: otherUserId, msg: "hello",
-                    }),
-                    utils.mkMessage({
-                        room: roomOne, user: otherUserId, msg: "world",
-                    }),
-                ],
-            },
-            state: {
-                events: [
-                    utils.mkEvent({
-                        type: "m.room.name", room: roomOne, user: otherUserId,
-                        content: {
-                            name: "Old room name",
-                        },
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: otherUserId,
-                    }),
-                    utils.mkMembership({
-                        room: roomOne, mship: "join", user: selfUserId,
-                    }),
-                    utils.mkEvent({
-                        type: "m.room.create", room: roomOne, user: selfUserId,
-                        content: {
-                            creator: selfUserId,
+                    [roomOne]: {
+                        ephemeral: {
+                            events: [],
+                        } as IEphemeral,
+                        timeline: {
+                            events: [
+                                utils.mkMessage({
+                                    room: roomOne, user: otherUserId, msg: "hello",
+                                }),
+                                utils.mkMessage({
+                                    room: roomOne, user: otherUserId, msg: "world",
+                                }),
+                            ],
                         },
-                    }),
-                ],
+                        state: {
+                            events: [
+                                utils.mkEvent({
+                                    type: "m.room.name", room: roomOne, user: otherUserId,
+                                    content: {
+                                        name: "Old room name",
+                                    },
+                                }),
+                                utils.mkMembership({
+                                    room: roomOne, mship: "join", user: otherUserId,
+                                }),
+                                utils.mkMembership({
+                                    room: roomOne, mship: "join", user: selfUserId,
+                                }),
+                                utils.mkEvent({
+                                    type: "m.room.create", room: roomOne, user: selfUserId,
+                                    content: {
+                                        creator: selfUserId,
+                                    },
+                                }),
+                            ],
+                        } as Partial<IJoinedRoom>,
+                    },
+                },
             },
         };
 
@@ -1351,16 +1359,15 @@ describe("MatrixClient syncing", () => {
 
         it("should sync receipts from /sync.", () => {
             const ackEvent = syncData.rooms.join[roomOne].timeline.events[0];
-            const receipt = {};
-            receipt[ackEvent.event_id] = {
+            const receipt: Record<string, any> = {};
+            receipt[ackEvent.event_id!] = {
                 "m.read": {},
             };
-            receipt[ackEvent.event_id]["m.read"][userC] = {
+            receipt[ackEvent.event_id!]["m.read"][userC] = {
                 ts: 176592842636,
             };
             syncData.rooms.join[roomOne].ephemeral.events = [{
                 content: receipt,
-                room_id: roomOne,
                 type: "m.receipt",
             }];
             httpBackend!.when("GET", "/sync").respond(200, syncData);
@@ -1425,7 +1432,7 @@ describe("MatrixClient syncing", () => {
                     },
                 },
             },
-        };
+        } as unknown as ISyncResponse;
         it("should sync unread notifications.", () => {
             syncData.rooms.join[roomOne][UNREAD_THREAD_NOTIFICATIONS.name] = {
                 [THREAD_ID]: {
@@ -1509,18 +1516,18 @@ describe("MatrixClient syncing", () => {
             const syncData = {
                 next_batch: "batch_token",
                 rooms: {
-                    leave: {},
-                },
-            };
-
-            syncData.rooms.leave[roomTwo] = {
-                timeline: {
-                    events: [
-                        utils.mkMessage({
-                            room: roomTwo, user: otherUserId, msg: "hello",
-                        }),
-                    ],
-                    prev_batch: "pagTok",
+                    leave: {
+                        [roomTwo]: {
+                            timeline: {
+                                events: [
+                                    utils.mkMessage({
+                                        room: roomTwo, user: otherUserId, msg: "hello",
+                                    }),
+                                ],
+                                prev_batch: "pagTok",
+                            },
+                        },
+                    },
                 },
             };
 
diff --git a/spec/integ/megolm-backup.spec.ts b/spec/integ/megolm-backup.spec.ts
index 492e4f1dc13..9341d651189 100644
--- a/spec/integ/megolm-backup.spec.ts
+++ b/spec/integ/megolm-backup.spec.ts
@@ -126,12 +126,13 @@ describe("megolm key backups", function() {
         const syncResponse = {
             next_batch: 1,
             rooms: {
-                join: {},
-            },
-        };
-        syncResponse.rooms.join[ROOM_ID] = {
-            timeline: {
-                events: [ENCRYPTED_EVENT],
+                join: {
+                    [ROOM_ID]: {
+                        timeline: {
+                            events: [ENCRYPTED_EVENT],
+                        },
+                    },
+                },
             },
         };
 
diff --git a/spec/integ/sliding-sync-sdk.spec.ts b/spec/integ/sliding-sync-sdk.spec.ts
index 7a37f572bba..20dfa6141fa 100644
--- a/spec/integ/sliding-sync-sdk.spec.ts
+++ b/spec/integ/sliding-sync-sdk.spec.ts
@@ -119,13 +119,13 @@ describe("SlidingSyncSdk", () => {
     };
 
     // find an extension on a SlidingSyncSdk instance
-    const findExtension = (name: string): Extension => {
+    const findExtension = (name: string): Extension<any, any> => {
         expect(mockSlidingSync!.registerExtension).toHaveBeenCalled();
         const mockFn = mockSlidingSync!.registerExtension as jest.Mock;
         // find the extension
         for (let i = 0; i < mockFn.mock.calls.length; i++) {
-            const calledExtension = mockFn.mock.calls[i][0] as Extension;
-            if (calledExtension && calledExtension.name() === name) {
+            const calledExtension = mockFn.mock.calls[i][0] as Extension<any, any>;
+            if (calledExtension?.name() === name) {
                 return calledExtension;
             }
         }
@@ -581,7 +581,7 @@ describe("SlidingSyncSdk", () => {
     });
 
     describe("ExtensionE2EE", () => {
-        let ext: Extension;
+        let ext: Extension<any, any>;
 
         beforeAll(async () => {
             await setupClient({
@@ -647,7 +647,7 @@ describe("SlidingSyncSdk", () => {
     });
 
     describe("ExtensionAccountData", () => {
-        let ext: Extension;
+        let ext: Extension<any, any>;
 
         beforeAll(async () => {
             await setupClient();
@@ -773,7 +773,7 @@ describe("SlidingSyncSdk", () => {
     });
 
     describe("ExtensionToDevice", () => {
-        let ext: Extension;
+        let ext: Extension<any, any>;
 
         beforeAll(async () => {
             await setupClient();
@@ -871,7 +871,7 @@ describe("SlidingSyncSdk", () => {
     });
 
     describe("ExtensionTyping", () => {
-        let ext: Extension;
+        let ext: Extension<any, any>;
 
         beforeAll(async () => {
             await setupClient();
@@ -970,7 +970,7 @@ describe("SlidingSyncSdk", () => {
     });
 
     describe("ExtensionReceipts", () => {
-        let ext: Extension;
+        let ext: Extension<any, any>;
 
         const generateReceiptResponse = (
             userId: string, roomId: string, eventId: string, recType: string, ts: number,
diff --git a/spec/integ/sliding-sync.spec.ts b/spec/integ/sliding-sync.spec.ts
index 0b1e9fedd4b..c2a4b8e98fc 100644
--- a/spec/integ/sliding-sync.spec.ts
+++ b/spec/integ/sliding-sync.spec.ts
@@ -18,7 +18,15 @@ limitations under the License.
 import EventEmitter from "events";
 import MockHttpBackend from "matrix-mock-request";
 
-import { SlidingSync, SlidingSyncState, ExtensionState, SlidingSyncEvent } from "../../src/sliding-sync";
+import {
+    SlidingSync,
+    SlidingSyncState,
+    ExtensionState,
+    SlidingSyncEvent,
+    Extension,
+    SlidingSyncEventHandlerMap,
+    MSC3575RoomData,
+} from "../../src/sliding-sync";
 import { TestClient } from "../TestClient";
 import { logger } from "../../src/logger";
 import { MatrixClient } from "../../src";
@@ -94,7 +102,7 @@ describe("SlidingSync", () => {
                     is_dm: true,
                 },
             };
-            const ext = {
+            const ext: Extension<any, any> = {
                 name: () => "custom_extension",
                 onRequest: (initial) => { return { initial: initial }; },
                 onResponse: (res) => { return {}; },
@@ -107,7 +115,7 @@ describe("SlidingSync", () => {
             slidingSync.start();
 
             // expect everything to be sent
-            let txnId;
+            let txnId: string | undefined;
             httpBackend!.when("POST", syncUrl).check(function(req) {
                 const body = req.data;
                 logger.debug("got ", body);
@@ -390,8 +398,8 @@ describe("SlidingSync", () => {
                 }],
                 rooms: rooms,
             });
-            const listenerData = {};
-            const dataListener = (roomId, roomData) => {
+            const listenerData: Record<string, MSC3575RoomData> = {};
+            const dataListener: SlidingSyncEventHandlerMap[SlidingSyncEvent.RoomData] = (roomId, roomData) => {
                 expect(listenerData[roomId]).toBeFalsy();
                 listenerData[roomId] = roomData;
             };
@@ -912,7 +920,7 @@ describe("SlidingSync", () => {
             slidingSync = new SlidingSync(proxyBaseUrl, [], roomSubInfo, client!, 1);
             // modification before SlidingSync.start()
             const subscribePromise = slidingSync.modifyRoomSubscriptions(new Set([roomId]));
-            let txnId;
+            let txnId: string | undefined;
             httpBackend!.when("POST", syncUrl).check(function(req) {
                 const body = req.data;
                 logger.debug("got ", body);
@@ -944,7 +952,7 @@ describe("SlidingSync", () => {
                 ranges: [[0, 20]],
             };
             const promise = slidingSync.setList(0, newList);
-            let txnId;
+            let txnId: string | undefined;
             httpBackend!.when("POST", syncUrl).check(function(req) {
                 const body = req.data;
                 logger.debug("got ", body);
@@ -966,7 +974,7 @@ describe("SlidingSync", () => {
         });
         it("should resolve setListRanges during a connection", async () => {
             const promise = slidingSync.setListRanges(0, [[20, 40]]);
-            let txnId;
+            let txnId: string | undefined;
             httpBackend!.when("POST", syncUrl).check(function(req) {
                 const body = req.data;
                 logger.debug("got ", body);
@@ -992,7 +1000,7 @@ describe("SlidingSync", () => {
             const promise = slidingSync.modifyRoomSubscriptionInfo({
                 timeline_limit: 99,
             });
-            let txnId;
+            let txnId: string | undefined;
             httpBackend!.when("POST", syncUrl).check(function(req) {
                 const body = req.data;
                 logger.debug("got ", body);
@@ -1016,7 +1024,7 @@ describe("SlidingSync", () => {
         it("should reject earlier pending promises if a later transaction is acknowledged", async () => {
             // i.e if we have [A,B,C] and see txn_id=C then A,B should be rejected.
             const gotTxnIds: any[] = [];
-            const pushTxn = function(req) {
+            const pushTxn = function(req: MockHttpBackend["requests"][0]) {
                 gotTxnIds.push(req.data.txn_id);
             };
             const failPromise = slidingSync.setListRanges(0, [[20, 40]]);
@@ -1032,7 +1040,7 @@ describe("SlidingSync", () => {
             expect(failPromise2).rejects.toEqual(gotTxnIds[1]);
 
             const okPromise = slidingSync.setListRanges(0, [[0, 20]]);
-            let txnId;
+            let txnId: string | undefined;
             httpBackend!.when("POST", syncUrl).check((req) => {
                 txnId = req.data.txn_id;
             }).respond(200, () => {
@@ -1050,7 +1058,7 @@ describe("SlidingSync", () => {
         it("should not reject later pending promises if an earlier transaction is acknowledged", async () => {
             // i.e if we have [A,B,C] and see txn_id=B then C should not be rejected but A should.
             const gotTxnIds: any[] = [];
-            const pushTxn = function(req) {
+            const pushTxn = function(req: MockHttpBackend["requests"][0]) {
                 gotTxnIds.push(req.data?.txn_id);
             };
             const A = slidingSync.setListRanges(0, [[20, 40]]);
@@ -1087,7 +1095,7 @@ describe("SlidingSync", () => {
             promise.finally(() => {
                 pending = false;
             });
-            let txnId;
+            let txnId: string | undefined;
             httpBackend!.when("POST", syncUrl).check(function(req) {
                 const body = req.data;
                 logger.debug("got ", body);
@@ -1275,21 +1283,21 @@ describe("SlidingSync", () => {
 
         // Pre-extensions get called BEFORE processing the sync response
         const preExtName = "foobar";
-        let onPreExtensionRequest;
-        let onPreExtensionResponse;
+        let onPreExtensionRequest: Extension<any, any>["onRequest"];
+        let onPreExtensionResponse: Extension<any, any>["onResponse"];
 
         // Post-extensions get called AFTER processing the sync response
         const postExtName = "foobar2";
-        let onPostExtensionRequest;
-        let onPostExtensionResponse;
+        let onPostExtensionRequest: Extension<any, any>["onRequest"];
+        let onPostExtensionResponse: Extension<any, any>["onResponse"];
 
-        const extPre = {
+        const extPre: Extension<any, any> = {
             name: () => preExtName,
             onRequest: (initial) => { return onPreExtensionRequest(initial); },
             onResponse: (res) => { return onPreExtensionResponse(res); },
             when: () => ExtensionState.PreProcess,
         };
-        const extPost = {
+        const extPost: Extension<any, any> = {
             name: () => postExtName,
             onRequest: (initial) => { return onPostExtensionRequest(initial); },
             onResponse: (res) => { return onPostExtensionResponse(res); },
@@ -1421,7 +1429,7 @@ describe("SlidingSync", () => {
 });
 
 function timeout(delayMs: number, reason: string): { promise: Promise<never>, cancel: () => void } {
-    let timeoutId;
+    let timeoutId: NodeJS.Timeout;
     return {
         promise: new Promise((resolve, reject) => {
             timeoutId = setTimeout(() => {
@@ -1454,7 +1462,7 @@ function listenUntil<T>(
     const trace = new Error().stack?.split(`\n`)[2];
     const t = timeout(timeoutMs, "timed out waiting for event " + eventName + " " + trace);
     return Promise.race([new Promise<T>((resolve, reject) => {
-        const wrapper = (...args) => {
+        const wrapper = (...args: any[]) => {
             try {
                 const data = callback(...args);
                 if (data) {
diff --git a/spec/test-utils/test-utils.ts b/spec/test-utils/test-utils.ts
index 21ae4d18bad..3dd9c037844 100644
--- a/spec/test-utils/test-utils.ts
+++ b/spec/test-utils/test-utils.ts
@@ -332,7 +332,7 @@ export function mkReplyMessage(
  *
  * @constructor
  */
-export class MockStorageApi {
+export class MockStorageApi implements Storage {
     private data: Record<string, any> = {};
 
     public get length() {
@@ -354,6 +354,10 @@ export class MockStorageApi {
     public removeItem(k: string): void {
         delete this.data[k];
     }
+
+    public clear(): void {
+        this.data = {};
+    }
 }
 
 /**
diff --git a/spec/unit/crypto.spec.ts b/spec/unit/crypto.spec.ts
index b319a5f26ad..a4e1ec374e0 100644
--- a/spec/unit/crypto.spec.ts
+++ b/spec/unit/crypto.spec.ts
@@ -3,7 +3,7 @@ import '../olm-loader';
 import { EventEmitter } from "events";
 
 import type { PkDecryption, PkSigning } from "@matrix-org/olm";
-import { MatrixClient } from "../../src/client";
+import { IClaimOTKsResult, MatrixClient } from "../../src/client";
 import { Crypto } from "../../src/crypto";
 import { MemoryCryptoStore } from "../../src/crypto/store/memory-crypto-store";
 import { MockStorageApi } from "../MockStorageApi";
@@ -23,16 +23,16 @@ import { IRoomEncryption, RoomList } from "../../src/crypto/RoomList";
 
 const Olm = global.Olm;
 
-function awaitEvent(emitter, event) {
-    return new Promise((resolve, reject) => {
+function awaitEvent(emitter: EventEmitter, event: string): Promise<void> {
+    return new Promise((resolve) => {
         emitter.once(event, (result) => {
             resolve(result);
         });
     });
 }
 
-async function keyshareEventForEvent(client, event, index): Promise<MatrixEvent> {
-    const roomId = event.getRoomId();
+async function keyshareEventForEvent(client: MatrixClient, event: MatrixEvent, index?: number): Promise<MatrixEvent> {
+    const roomId = event.getRoomId()!;
     const eventContent = event.getWireContent();
     const key = await client.crypto!.olmDevice.getInboundGroupSessionKey(
         roomId,
@@ -42,16 +42,16 @@ async function keyshareEventForEvent(client, event, index): Promise<MatrixEvent>
     );
     const ksEvent = new MatrixEvent({
         type: "m.forwarded_room_key",
-        sender: client.getUserId(),
+        sender: client.getUserId()!,
         content: {
             "algorithm": olmlib.MEGOLM_ALGORITHM,
             "room_id": roomId,
             "sender_key": eventContent.sender_key,
-            "sender_claimed_ed25519_key": key.sender_claimed_ed25519_key,
+            "sender_claimed_ed25519_key": key?.sender_claimed_ed25519_key,
             "session_id": eventContent.session_id,
-            "session_key": key.key,
-            "chain_index": key.chain_index,
-            "forwarding_curve25519_key_chain": key.forwarding_curve_key_chain,
+            "session_key": key?.key,
+            "chain_index": key?.chain_index,
+            "forwarding_curve25519_key_chain": key?.forwarding_curve25519_key_chain,
             "org.matrix.msc3061.shared_history": true,
         },
     });
@@ -172,7 +172,8 @@ describe("Crypto", function() {
     });
 
     describe('Session management', function() {
-        const otkResponse = {
+        const otkResponse: IClaimOTKsResult = {
+            failures: {},
             one_time_keys: {
                 '@alice:home.server': {
                     aliceDevice: {
@@ -188,11 +189,12 @@ describe("Crypto", function() {
                 },
             },
         };
-        let crypto;
-        let mockBaseApis;
-        let mockRoomList;
 
-        let fakeEmitter;
+        let crypto: Crypto;
+        let mockBaseApis: MatrixClient;
+        let mockRoomList: RoomList;
+
+        let fakeEmitter: EventEmitter;
 
         beforeEach(async function() {
             const mockStorage = new MockStorageApi() as unknown as Storage;
@@ -219,8 +221,8 @@ describe("Crypto", function() {
                 sendToDevice: jest.fn(),
                 getKeyBackupVersion: jest.fn(),
                 isGuest: jest.fn(),
-            };
-            mockRoomList = {};
+            } as unknown as MatrixClient;
+            mockRoomList = {} as unknown as RoomList;
 
             fakeEmitter = new EventEmitter();
 
@@ -233,7 +235,7 @@ describe("Crypto", function() {
                 mockRoomList,
                 [],
             );
-            crypto.registerEventHandlers(fakeEmitter);
+            crypto.registerEventHandlers(fakeEmitter as any);
             await crypto.init();
         });
 
@@ -245,7 +247,7 @@ describe("Crypto", function() {
             const prom = new Promise<void>((resolve) => {
                 mockBaseApis.claimOneTimeKeys = function() {
                     resolve();
-                    return otkResponse;
+                    return Promise.resolve(otkResponse);
                 };
             });
 
@@ -989,7 +991,7 @@ describe("Crypto", function() {
             ensureOlmSessionsForDevices.mockResolvedValue({});
             encryptMessageForDevice = jest.spyOn(olmlib, "encryptMessageForDevice");
             encryptMessageForDevice.mockImplementation(async (...[result,,,,,, payload]) => {
-                result.plaintext = JSON.stringify(payload);
+                result.plaintext = { type: 0, body: JSON.stringify(payload) };
             });
 
             client = new TestClient("@alice:example.org", "aliceweb");
@@ -998,7 +1000,7 @@ describe("Crypto", function() {
             encryptedPayload = {
                 algorithm: "m.olm.v1.curve25519-aes-sha2",
                 sender_key: client.client.crypto!.olmDevice.deviceCurve25519Key,
-                ciphertext: { plaintext: JSON.stringify(payload) },
+                ciphertext: { plaintext: { type: 0, body: JSON.stringify(payload) } },
             };
         });
 
@@ -1046,7 +1048,7 @@ describe("Crypto", function() {
             encryptMessageForDevice.mockImplementation(async (...[result,,,, userId, device, payload]) => {
                 // Refuse to encrypt to Carol's desktop device
                 if (userId === "@carol:example.org" && device.deviceId === "caroldesktop") return;
-                result.plaintext = JSON.stringify(payload);
+                result.plaintext = { type: 0, body: JSON.stringify(payload) };
             });
 
             client.httpBackend
diff --git a/spec/unit/crypto/CrossSigningInfo.spec.ts b/spec/unit/crypto/CrossSigningInfo.spec.ts
index f6b64cac440..ad02fb217e7 100644
--- a/spec/unit/crypto/CrossSigningInfo.spec.ts
+++ b/spec/unit/crypto/CrossSigningInfo.spec.ts
@@ -232,7 +232,7 @@ describe.each([
         return store;
     }],
 ])("CrossSigning > createCryptoStoreCacheCallbacks [%s]", function(name, dbFactory) {
-    let store;
+    let store: IndexedDBCryptoStore;
 
     beforeAll(() => {
         store = dbFactory();
diff --git a/spec/unit/crypto/DeviceList.spec.ts b/spec/unit/crypto/DeviceList.spec.ts
index 448c92b28e2..38c0e2df89a 100644
--- a/spec/unit/crypto/DeviceList.spec.ts
+++ b/spec/unit/crypto/DeviceList.spec.ts
@@ -22,6 +22,7 @@ import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store
 import { DeviceList } from "../../../src/crypto/DeviceList";
 import { IDownloadKeyResult, MatrixClient } from "../../../src";
 import { OlmDevice } from "../../../src/crypto/OlmDevice";
+import { CryptoStore } from "../../../src/crypto/store/base";
 
 const signedDeviceList: IDownloadKeyResult = {
     "failures": {},
@@ -88,8 +89,8 @@ const signedDeviceList2: IDownloadKeyResult = {
 };
 
 describe('DeviceList', function() {
-    let downloadSpy;
-    let cryptoStore;
+    let downloadSpy: jest.Mock;
+    let cryptoStore: CryptoStore;
     let deviceLists: DeviceList[] = [];
 
     beforeEach(function() {
@@ -112,7 +113,7 @@ describe('DeviceList', function() {
             deviceId: 'HGKAWHRVJQ',
         } as unknown as MatrixClient;
         const mockOlm = {
-            verifySignature: function(key, message, signature) {},
+            verifySignature: function(key: string, message: string, signature: string) {},
         } as unknown as OlmDevice;
         const dl = new DeviceList(baseApis, cryptoStore, mockOlm, keyDownloadChunkSize);
         deviceLists.push(dl);
diff --git a/spec/unit/crypto/algorithms/megolm.spec.ts b/spec/unit/crypto/algorithms/megolm.spec.ts
index b631201996a..48bdbc4ad0c 100644
--- a/spec/unit/crypto/algorithms/megolm.spec.ts
+++ b/spec/unit/crypto/algorithms/megolm.spec.ts
@@ -17,6 +17,7 @@ limitations under the License.
 import { mocked, MockedObject } from 'jest-mock';
 
 import '../../../olm-loader';
+import type { OutboundGroupSession } from "@matrix-org/olm";
 import * as algorithms from "../../../../src/crypto/algorithms";
 import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
 import * as testUtils from "../../../test-utils/test-utils";
@@ -31,6 +32,7 @@ import { TypedEventEmitter } from '../../../../src/models/typed-event-emitter';
 import { ClientEvent, MatrixClient, RoomMember } from '../../../../src';
 import { DeviceInfo, IDevice } from '../../../../src/crypto/deviceinfo';
 import { DeviceTrustLevel } from '../../../../src/crypto/CrossSigning';
+import { MegolmEncryption as MegolmEncryptionClass } from "../../../../src/crypto/algorithms/megolm";
 
 const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
 const MegolmEncryption = algorithms.ENCRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
@@ -87,7 +89,7 @@ describe("MegolmDecryption", function() {
     });
 
     describe('receives some keys:', function() {
-        let groupSession;
+        let groupSession: OutboundGroupSession;
         beforeEach(async function() {
             groupSession = new global.Olm.OutboundGroupSession();
             groupSession.create();
@@ -298,10 +300,10 @@ describe("MegolmDecryption", function() {
         describe("session reuse and key reshares", () => {
             const rotationPeriodMs = 999 * 24 * 60 * 60 * 1000; // 999 days, so we don't have to deal with it
 
-            let megolmEncryption;
-            let aliceDeviceInfo;
-            let mockRoom;
-            let olmDevice;
+            let megolmEncryption: MegolmEncryptionClass;
+            let aliceDeviceInfo: DeviceInfo;
+            let mockRoom: Room;
+            let olmDevice: OlmDevice;
 
             beforeEach(async () => {
                 // @ts-ignore assigning to readonly prop
@@ -342,7 +344,7 @@ describe("MegolmDecryption", function() {
                         'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
                     ),
                     getFingerprint: jest.fn().mockReturnValue(''),
-                };
+                } as unknown as DeviceInfo;
 
                 mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
                     '@alice:home.server': {
@@ -365,7 +367,7 @@ describe("MegolmDecryption", function() {
                         algorithm: 'm.megolm.v1.aes-sha2',
                         rotation_period_ms: rotationPeriodMs,
                     },
-                });
+                }) as MegolmEncryptionClass;
 
                 // Splice the real method onto the mock object as megolm uses this method
                 // on the crypto class in order to encrypt / start sessions
@@ -381,7 +383,7 @@ describe("MegolmDecryption", function() {
                         [{ userId: "@alice:home.server" }],
                     ),
                     getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
-                };
+                } as unknown as Room;
             });
 
             it("should use larger otkTimeout when preparing to encrypt room", async () => {
@@ -397,11 +399,14 @@ describe("MegolmDecryption", function() {
             });
 
             it("should generate a new session if this one needs rotation", async () => {
+                // @ts-ignore - private method access
                 const session = await megolmEncryption.prepareNewSession(false);
                 session.creationTime -= rotationPeriodMs + 10000; // a smidge over the rotation time
                 // Inject expired session which needs rotation
+                // @ts-ignore - private field access
                 megolmEncryption.setupPromise = Promise.resolve(session);
 
+                // @ts-ignore - private method access
                 const prepareNewSessionSpy = jest.spyOn(megolmEncryption, "prepareNewSession");
                 await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
                     body: "Some text",
@@ -446,8 +451,8 @@ describe("MegolmDecryption", function() {
                 });
 
                 mockBaseApis.sendToDevice.mockClear();
-                await megolmEncryption.reshareKeyWithDevice(
-                    olmDevice.deviceCurve25519Key,
+                await megolmEncryption.reshareKeyWithDevice!(
+                    olmDevice.deviceCurve25519Key!,
                     ct1.session_id,
                     '@alice:home.server',
                     aliceDeviceInfo,
@@ -466,8 +471,8 @@ describe("MegolmDecryption", function() {
                 );
 
                 mockBaseApis.queueToDevice.mockClear();
-                await megolmEncryption.reshareKeyWithDevice(
-                    olmDevice.deviceCurve25519Key,
+                await megolmEncryption.reshareKeyWithDevice!(
+                    olmDevice.deviceCurve25519Key!,
                     ct1.session_id,
                     '@alice:home.server',
                     aliceDeviceInfo,
diff --git a/spec/unit/crypto/algorithms/olm.spec.ts b/spec/unit/crypto/algorithms/olm.spec.ts
index b24532091ae..932fb8016b4 100644
--- a/spec/unit/crypto/algorithms/olm.spec.ts
+++ b/spec/unit/crypto/algorithms/olm.spec.ts
@@ -31,17 +31,21 @@ function makeOlmDevice() {
     return olmDevice;
 }
 
-async function setupSession(initiator, opponent) {
+async function setupSession(initiator: OlmDevice, opponent: OlmDevice) {
     await opponent.generateOneTimeKeys(1);
     const keys = await opponent.getOneTimeKeys();
     const firstKey = Object.values(keys['curve25519'])[0];
 
-    const sid = await initiator.createOutboundSession(
-        opponent.deviceCurve25519Key, firstKey,
-    );
+    const sid = await initiator.createOutboundSession(opponent.deviceCurve25519Key!, firstKey);
     return sid;
 }
 
+function alwaysSucceed<T>(promise: Promise<T>): Promise<T | void> {
+    // swallow any exception thrown by a promise, so that
+    // Promise.all doesn't abort
+    return promise.catch(() => {});
+}
+
 describe("OlmDevice", function() {
     if (!global.Olm) {
         logger.warn('Not running megolm unit tests: libolm not present');
@@ -159,11 +163,6 @@ describe("OlmDevice", function() {
                     }, "ABCDEFG"),
                 ],
             };
-            function alwaysSucceed(promise) {
-                // swallow any exception thrown by a promise, so that
-                // Promise.all doesn't abort
-                return promise.catch(() => {});
-            }
 
             // start two tasks that try to ensure that there's an olm session
             const promises = Promise.all([
@@ -235,12 +234,6 @@ describe("OlmDevice", function() {
                 ],
             };
 
-            function alwaysSucceed(promise) {
-                // swallow any exception thrown by a promise, so that
-                // Promise.all doesn't abort
-                return promise.catch(() => {});
-            }
-
             const task1 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
                 aliceOlmDevice, baseApis, devicesByUserAB,
             ));
diff --git a/spec/unit/crypto/backup.spec.ts b/spec/unit/crypto/backup.spec.ts
index 0d0820cd3f8..60fddedc733 100644
--- a/spec/unit/crypto/backup.spec.ts
+++ b/spec/unit/crypto/backup.spec.ts
@@ -15,8 +15,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MockedObject } from "jest-mock";
-
 import '../../olm-loader';
 import { logger } from "../../../src/logger";
 import * as olmlib from "../../../src/crypto/olmlib";
@@ -30,7 +28,10 @@ import { Crypto } from "../../../src/crypto";
 import { resetCrossSigningKeys } from "./crypto-utils";
 import { BackupManager } from "../../../src/crypto/backup";
 import { StubStore } from "../../../src/store/stub";
-import { MatrixScheduler } from '../../../src';
+import { IndexedDBCryptoStore, MatrixScheduler } from '../../../src';
+import { CryptoStore } from "../../../src/crypto/store/base";
+import { MegolmDecryption as MegolmDecryptionClass } from "../../../src/crypto/algorithms/megolm";
+import { IKeyBackupInfo } from "../../../src/crypto/keybackup";
 
 const Olm = global.Olm;
 
@@ -102,29 +103,36 @@ const CURVE25519_BACKUP_INFO = {
     },
 };
 
-const AES256_BACKUP_INFO = {
+const AES256_BACKUP_INFO: IKeyBackupInfo = {
     algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
     version: '1',
-    auth_data: {
-        // FIXME: add iv and mac
-    },
+    auth_data: {} as IKeyBackupInfo["auth_data"],
 };
 
-const keys = {};
+const keys: Record<string, Uint8Array> = {};
 
-function getCrossSigningKey(type) {
-    return keys[type];
+function getCrossSigningKey(type: string) {
+    return Promise.resolve(keys[type]);
 }
 
-function saveCrossSigningKeys(k) {
+function saveCrossSigningKeys(k: Record<string, Uint8Array>) {
     Object.assign(keys, k);
 }
 
-function makeTestClient(cryptoStore) {
-    const scheduler = [
-        "getQueueForEvent", "queueEvent", "removeEventFromQueue",
+function makeTestScheduler(): MatrixScheduler {
+    return ([
+        "getQueueForEvent",
+        "queueEvent",
+        "removeEventFromQueue",
         "setProcessFunction",
-    ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
+    ] as const).reduce((r, k) => {
+        r[k] = jest.fn();
+        return r;
+    }, {} as MatrixScheduler);
+}
+
+function makeTestClient(cryptoStore: CryptoStore) {
+    const scheduler = makeTestScheduler();
     const store = new StubStore();
 
     return new MatrixClient({
@@ -151,36 +159,33 @@ describe("MegolmBackup", function() {
         return Olm.init();
     });
 
-    let olmDevice;
-    let mockOlmLib;
-    let mockCrypto;
-    let cryptoStore;
-    let megolmDecryption;
+    let olmDevice: OlmDevice;
+    let mockOlmLib: typeof olmlib;
+    let mockCrypto: Crypto;
+    let cryptoStore: CryptoStore;
+    let megolmDecryption: MegolmDecryptionClass;
     beforeEach(async function() {
         mockCrypto = testUtils.mock(Crypto, 'Crypto');
+        // @ts-ignore making mock
         mockCrypto.backupManager = testUtils.mock(BackupManager, "BackupManager");
-        mockCrypto.backupKey = new Olm.PkEncryption();
-        mockCrypto.backupKey.set_recipient_key(
-            "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
-        );
-        mockCrypto.backupInfo = CURVE25519_BACKUP_INFO;
+        mockCrypto.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
 
         cryptoStore = new MemoryCryptoStore();
 
         olmDevice = new OlmDevice(cryptoStore);
 
         // we stub out the olm encryption bits
-        mockOlmLib = {};
+        mockOlmLib = {} as unknown as typeof olmlib;
         mockOlmLib.ensureOlmSessionsForDevices = jest.fn();
         mockOlmLib.encryptMessageForDevice =
             jest.fn().mockResolvedValue(undefined);
     });
 
     describe("backup", function() {
-        let mockBaseApis;
+        let mockBaseApis: MatrixClient;
 
         beforeEach(function() {
-            mockBaseApis = {};
+            mockBaseApis = {} as unknown as MatrixClient;
 
             megolmDecryption = new MegolmDecryption({
                 userId: '@user:id',
@@ -188,8 +193,9 @@ describe("MegolmBackup", function() {
                 olmDevice: olmDevice,
                 baseApis: mockBaseApis,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             // clobber the setTimeout function to run 100x faster.
@@ -239,6 +245,7 @@ describe("MegolmBackup", function() {
             };
             mockCrypto.cancelRoomKeyRequest = function() {};
 
+            // @ts-ignore readonly field write
             mockCrypto.backupManager = {
                 backupGroupSession: jest.fn(),
             };
@@ -264,21 +271,22 @@ describe("MegolmBackup", function() {
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             return client.initCrypto()
                 .then(() => {
                     return cryptoStore.doTxn(
                         "readwrite",
-                        [cryptoStore.STORE_SESSION],
+                        [IndexedDBCryptoStore.STORE_SESSIONS],
                         (txn) => {
                             cryptoStore.addEndToEndInboundGroupSession(
                                 "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
                                 groupSession.session_id(),
                                 {
-                                    forwardingCurve25519KeyChain: undefined,
+                                    forwardingCurve25519KeyChain: undefined!,
                                     keysClaimed: {
                                         ed25519: "SENDER_ED25519",
                                     },
@@ -298,25 +306,25 @@ describe("MegolmBackup", function() {
                     });
                     let numCalls = 0;
                     return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function<T>(
+                        client.http.authedRequest = function(
                             method, path, queryParams, data, opts,
-                        ): Promise<T> {
+                        ): any {
                             ++numCalls;
                             expect(numCalls).toBeLessThanOrEqual(1);
                             if (numCalls >= 2) {
                                 // exit out of retry loop if there's something wrong
                                 reject(new Error("authedRequest called too many timmes"));
-                                return Promise.resolve({} as T);
+                                return Promise.resolve({});
                             }
                             expect(method).toBe("PUT");
                             expect(path).toBe("/room_keys/keys");
-                            expect(queryParams.version).toBe('1');
+                            expect(queryParams?.version).toBe('1');
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                                 groupSession.session_id(),
                             );
                             resolve();
-                            return Promise.resolve({} as T);
+                            return Promise.resolve({});
                         };
                         client.crypto!.backupManager.backupGroupSession(
                             "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
@@ -343,8 +351,9 @@ describe("MegolmBackup", function() {
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             return client.initCrypto()
@@ -354,13 +363,13 @@ describe("MegolmBackup", function() {
                 .then(() => {
                     return cryptoStore.doTxn(
                         "readwrite",
-                        [cryptoStore.STORE_SESSION],
+                        [IndexedDBCryptoStore.STORE_SESSIONS],
                         (txn) => {
                             cryptoStore.addEndToEndInboundGroupSession(
                                 "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
                                 groupSession.session_id(),
                                 {
-                                    forwardingCurve25519KeyChain: undefined,
+                                    forwardingCurve25519KeyChain: undefined!,
                                     keysClaimed: {
                                         ed25519: "SENDER_ED25519",
                                     },
@@ -381,25 +390,25 @@ describe("MegolmBackup", function() {
                     });
                     let numCalls = 0;
                     return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function<T>(
+                        client.http.authedRequest = function(
                             method, path, queryParams, data, opts,
-                        ): Promise<T> {
+                        ): any {
                             ++numCalls;
                             expect(numCalls).toBeLessThanOrEqual(1);
                             if (numCalls >= 2) {
                                 // exit out of retry loop if there's something wrong
                                 reject(new Error("authedRequest called too many timmes"));
-                                return Promise.resolve({} as T);
+                                return Promise.resolve({});
                             }
                             expect(method).toBe("PUT");
                             expect(path).toBe("/room_keys/keys");
-                            expect(queryParams.version).toBe('1');
+                            expect(queryParams?.version).toBe('1');
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                                 groupSession.session_id(),
                             );
                             resolve();
-                            return Promise.resolve({} as T);
+                            return Promise.resolve({});
                         };
                         client.crypto!.backupManager.backupGroupSession(
                             "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
@@ -426,8 +435,9 @@ describe("MegolmBackup", function() {
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             await client.initCrypto();
@@ -437,10 +447,10 @@ describe("MegolmBackup", function() {
             let numCalls = 0;
             await Promise.all([
                 new Promise<void>((resolve, reject) => {
-                    let backupInfo;
+                    let backupInfo: Record<string, any> | BodyInit | undefined;
                     client.http.authedRequest = function(
                         method, path, queryParams, data, opts,
-                    ) {
+                    ): any {
                         ++numCalls;
                         expect(numCalls).toBeLessThanOrEqual(2);
                         if (numCalls === 1) {
@@ -486,10 +496,7 @@ describe("MegolmBackup", function() {
             const ibGroupSession = new Olm.InboundGroupSession();
             ibGroupSession.create(groupSession.session_key());
 
-            const scheduler = [
-                "getQueueForEvent", "queueEvent", "removeEventFromQueue",
-                "setProcessFunction",
-            ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
+            const scheduler = makeTestScheduler();
             const store = new StubStore();
             const client = new MatrixClient({
                 baseUrl: "https://my.home.server",
@@ -509,20 +516,21 @@ describe("MegolmBackup", function() {
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             await client.initCrypto();
             await cryptoStore.doTxn(
                 "readwrite",
-                [cryptoStore.STORE_SESSION],
+                [IndexedDBCryptoStore.STORE_SESSIONS],
                 (txn) => {
                     cryptoStore.addEndToEndInboundGroupSession(
                         "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
                         groupSession.session_id(),
                         {
-                            forwardingCurve25519KeyChain: undefined,
+                            forwardingCurve25519KeyChain: undefined!,
                             keysClaimed: {
                                 ed25519: "SENDER_ED25519",
                             },
@@ -542,26 +550,26 @@ describe("MegolmBackup", function() {
             let numCalls = 0;
 
             await new Promise<void>((resolve, reject) => {
-                client.http.authedRequest = function<T>(
+                client.http.authedRequest = function(
                     method, path, queryParams, data, opts,
-                ): Promise<T> {
+                ): any {
                     ++numCalls;
                     expect(numCalls).toBeLessThanOrEqual(2);
                     if (numCalls >= 3) {
                         // exit out of retry loop if there's something wrong
                         reject(new Error("authedRequest called too many timmes"));
-                        return Promise.resolve({} as T);
+                        return Promise.resolve({});
                     }
                     expect(method).toBe("PUT");
                     expect(path).toBe("/room_keys/keys");
-                    expect(queryParams.version).toBe('1');
+                    expect(queryParams?.version).toBe('1');
                     expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
                     expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                         groupSession.session_id(),
                     );
                     if (numCalls > 1) {
                         resolve();
-                        return Promise.resolve({} as T);
+                        return Promise.resolve({});
                     } else {
                         return Promise.reject(
                             new Error("this is an expected failure"),
@@ -579,7 +587,7 @@ describe("MegolmBackup", function() {
     });
 
     describe("restore", function() {
-        let client;
+        let client: MatrixClient;
 
         beforeEach(function() {
             client = makeTestClient(cryptoStore);
@@ -590,8 +598,9 @@ describe("MegolmBackup", function() {
                 olmDevice: olmDevice,
                 baseApis: client,
                 roomId: ROOM_ID,
-            });
+            }) as MegolmDecryptionClass;
 
+            // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
             return client.initCrypto();
@@ -603,7 +612,7 @@ describe("MegolmBackup", function() {
 
         it('can restore from backup (Curve25519 version)', function() {
             client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
+                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
             return client.restoreKeyBackupWithRecoveryKey(
                 "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
@@ -620,7 +629,7 @@ describe("MegolmBackup", function() {
 
         it('can restore from backup (AES-256 version)', function() {
             client.http.authedRequest = function() {
-                return Promise.resolve(AES256_KEY_BACKUP_DATA);
+                return Promise.resolve<any>(AES256_KEY_BACKUP_DATA);
             };
             return client.restoreKeyBackupWithRecoveryKey(
                 "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
@@ -637,7 +646,7 @@ describe("MegolmBackup", function() {
 
         it('can restore backup by room (Curve25519 version)', function() {
             client.http.authedRequest = function() {
-                return Promise.resolve({
+                return Promise.resolve<any>({
                     rooms: {
                         [ROOM_ID]: {
                             sessions: {
@@ -649,7 +658,7 @@ describe("MegolmBackup", function() {
             };
             return client.restoreKeyBackupWithRecoveryKey(
                 "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                null, null, CURVE25519_BACKUP_INFO,
+                null!, null!, CURVE25519_BACKUP_INFO,
             ).then(() => {
                 return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
             }).then((res) => {
@@ -659,18 +668,18 @@ describe("MegolmBackup", function() {
 
         it('has working cache functions', async function() {
             const key = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]);
-            await client.crypto.storeSessionBackupPrivateKey(key);
-            const result = await client.crypto.getSessionBackupPrivateKey();
-            expect(new Uint8Array(result)).toEqual(key);
+            await client.crypto!.storeSessionBackupPrivateKey(key);
+            const result = await client.crypto!.getSessionBackupPrivateKey();
+            expect(new Uint8Array(result!)).toEqual(key);
         });
 
         it('caches session backup keys as it encounters them', async function() {
-            const cachedNull = await client.crypto.getSessionBackupPrivateKey();
+            const cachedNull = await client.crypto!.getSessionBackupPrivateKey();
             expect(cachedNull).toBeNull();
             client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
+                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
-            await new Promise((resolve) => {
+            await new Promise<void>((resolve) => {
                 client.restoreKeyBackupWithRecoveryKey(
                     "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
                     ROOM_ID,
@@ -679,7 +688,7 @@ describe("MegolmBackup", function() {
                     { cacheCompleteCallback: resolve },
                 );
             });
-            const cachedKey = await client.crypto.getSessionBackupPrivateKey();
+            const cachedKey = await client.crypto!.getSessionBackupPrivateKey();
             expect(cachedKey).not.toBeNull();
         });
 
@@ -688,7 +697,7 @@ describe("MegolmBackup", function() {
                 algorithm: "this.algorithm.does.not.exist",
             });
             client.http.authedRequest = function() {
-                return Promise.resolve(CURVE25519_KEY_BACKUP_DATA);
+                return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
 
             await expect(client.restoreKeyBackupWithRecoveryKey(
@@ -702,10 +711,7 @@ describe("MegolmBackup", function() {
 
     describe("flagAllGroupSessionsForBackup", () => {
         it("should return number of sesions needing backup", async () => {
-            const scheduler = [
-                "getQueueForEvent", "queueEvent", "removeEventFromQueue",
-                "setProcessFunction",
-            ].reduce((r, k) => {r[k] = jest.fn(); return r;}, {}) as MockedObject<MatrixScheduler>;
+            const scheduler = makeTestScheduler();
             const store = new StubStore();
             const client = new MatrixClient({
                 baseUrl: "https://my.home.server",
diff --git a/spec/unit/crypto/cross-signing.spec.ts b/spec/unit/crypto/cross-signing.spec.ts
index e9c112c5005..fe5b37eb206 100644
--- a/spec/unit/crypto/cross-signing.spec.ts
+++ b/spec/unit/crypto/cross-signing.spec.ts
@@ -18,23 +18,24 @@ limitations under the License.
 import '../../olm-loader';
 import anotherjson from 'another-json';
 import { PkSigning } from '@matrix-org/olm';
+import HttpBackend from "matrix-mock-request";
 
 import * as olmlib from "../../../src/crypto/olmlib";
 import { MatrixError } from '../../../src/http-api';
 import { logger } from '../../../src/logger';
 import { ICrossSigningKey, ICreateClientOpts, ISignedKey } from '../../../src/client';
-import { CryptoEvent } from '../../../src/crypto';
+import { CryptoEvent, IBootstrapCrossSigningOpts } from '../../../src/crypto';
 import { IDevice } from '../../../src/crypto/deviceinfo';
 import { TestClient } from '../../TestClient';
 import { resetCrossSigningKeys } from "./crypto-utils";
 
-const PUSH_RULES_RESPONSE = {
+const PUSH_RULES_RESPONSE: Response = {
     method: "GET",
     path: "/pushrules/",
     data: {},
 };
 
-const filterResponse = function(userId) {
+const filterResponse = function(userId: string): Response {
     const filterPath = "/user/" + encodeURIComponent(userId) + "/filter";
     return {
         method: "POST",
@@ -43,7 +44,13 @@ const filterResponse = function(userId) {
     };
 };
 
-function setHttpResponses(httpBackend, responses) {
+interface Response {
+    method: 'GET' | 'PUT' | 'POST' | 'DELETE';
+    path: string;
+    data: object;
+}
+
+function setHttpResponses(httpBackend: HttpBackend, responses: Response[]) {
     responses.forEach(response => {
         httpBackend
             .when(response.method, response.path)
@@ -54,13 +61,13 @@ function setHttpResponses(httpBackend, responses) {
 async function makeTestClient(
     userInfo: { userId: string, deviceId: string},
     options: Partial<ICreateClientOpts> = {},
-    keys = {},
+    keys: Record<string, Uint8Array> = {},
 ) {
-    function getCrossSigningKey(type) {
-        return keys[type];
+    function getCrossSigningKey(type: string) {
+        return keys[type] ?? null;
     }
 
-    function saveCrossSigningKeys(k) {
+    function saveCrossSigningKeys(k: Record<string, Uint8Array>) {
         Object.assign(keys, k);
     }
 
@@ -142,7 +149,9 @@ describe("Cross Signing", function() {
         alice.uploadKeySignatures = async () => ({ failures: {} });
         alice.setAccountData = async () => ({});
         alice.getAccountDataFromServer = async <T extends {[k: string]: any}>(): Promise<T | null> => ({} as T);
-        const authUploadDeviceSigningKeys = async func => await func({});
+        const authUploadDeviceSigningKeys: IBootstrapCrossSigningOpts["authUploadDeviceSigningKeys"] = async func => {
+            await func({});
+        };
 
         // Try bootstrap, expecting `authUploadDeviceSigningKeys` to pass
         // through failure, stopping before actually applying changes.
@@ -275,7 +284,7 @@ describe("Cross Signing", function() {
         );
 
         // feed sync result that includes master key, ssk, device key
-        const responses = [
+        const responses: Response[] = [
             PUSH_RULES_RESPONSE,
             {
                 method: "POST",
@@ -464,7 +473,7 @@ describe("Cross Signing", function() {
     });
 
     it.skip("should trust signatures received from other devices", async function() {
-        const aliceKeys: Record<string, PkSigning> = {};
+        const aliceKeys: Record<string, Uint8Array> = {};
         const { client: alice, httpBackend } = await makeTestClient(
             { userId: "@alice:example.com", deviceId: "Osborne2" },
             undefined,
@@ -494,8 +503,7 @@ describe("Cross Signing", function() {
         });
 
         // @ts-ignore private property
-        const deviceInfo = alice.crypto!.deviceList.devices["@alice:example.com"]
-            .Osborne2;
+        const deviceInfo = alice.crypto!.deviceList.devices["@alice:example.com"].Osborne2;
         const aliceDevice = {
             user_id: "@alice:example.com",
             device_id: "Osborne2",
@@ -549,7 +557,7 @@ describe("Cross Signing", function() {
         // - ssk
         // - master key signed by her usk (pretend that it was signed by another
         //   of Alice's devices)
-        const responses = [
+        const responses: Response[] = [
             PUSH_RULES_RESPONSE,
             {
                 method: "POST",
@@ -853,7 +861,7 @@ describe("Cross Signing", function() {
     });
 
     it("should offer to upgrade device verifications to cross-signing", async function() {
-        let upgradeResolveFunc;
+        let upgradeResolveFunc: Function;
 
         const { client: alice } = await makeTestClient(
             { userId: "@alice:example.com", deviceId: "Osborne2" },
diff --git a/spec/unit/crypto/crypto-utils.ts b/spec/unit/crypto/crypto-utils.ts
index 1391d79f193..76f2a083575 100644
--- a/spec/unit/crypto/crypto-utils.ts
+++ b/spec/unit/crypto/crypto-utils.ts
@@ -1,14 +1,16 @@
 import { IRecoveryKey } from '../../../src/crypto/api';
 import { CrossSigningLevel } from '../../../src/crypto/CrossSigning';
 import { IndexedDBCryptoStore } from '../../../src/crypto/store/indexeddb-crypto-store';
+import { MatrixClient } from "../../../src";
+import { CryptoEvent } from "../../../src/crypto";
 
 // needs to be phased out and replaced with bootstrapSecretStorage,
 // but that is doing too much extra stuff for it to be an easy transition.
 export async function resetCrossSigningKeys(
-    client,
+    client: MatrixClient,
     { level }: { level?: CrossSigningLevel} = {},
 ): Promise<void> {
-    const crypto = client.crypto;
+    const crypto = client.crypto!;
 
     const oldKeys = Object.assign({}, crypto.crossSigningInfo.keys);
     try {
@@ -28,7 +30,8 @@ export async function resetCrossSigningKeys(
         crypto.crossSigningInfo.keys = oldKeys;
         throw e;
     }
-    crypto.emit("crossSigning.keysChanged", {});
+    crypto.emit(CryptoEvent.KeysChanged, {});
+    // @ts-ignore
     await crypto.afterCrossSigningLocalKeyChange();
 }
 
diff --git a/spec/unit/crypto/secrets.spec.ts b/spec/unit/crypto/secrets.spec.ts
index 386df0d22b0..885f0f6c37d 100644
--- a/spec/unit/crypto/secrets.spec.ts
+++ b/spec/unit/crypto/secrets.spec.ts
@@ -16,6 +16,7 @@ limitations under the License.
 
 import '../../olm-loader';
 import * as olmlib from "../../../src/crypto/olmlib";
+import { IObject } from "../../../src/crypto/olmlib";
 import { SECRET_STORAGE_ALGORITHM_V1_AES } from "../../../src/crypto/SecretStorage";
 import { MatrixEvent } from "../../../src/models/event";
 import { TestClient } from '../../TestClient';
@@ -23,9 +24,11 @@ import { makeTestClients } from './verification/util';
 import { encryptAES } from "../../../src/crypto/aes";
 import { createSecretStorageKey, resetCrossSigningKeys } from "./crypto-utils";
 import { logger } from '../../../src/logger';
-import { ClientEvent, ICreateClientOpts } from '../../../src/client';
+import { ClientEvent, ICreateClientOpts, ICrossSigningKey, MatrixClient } from '../../../src/client';
 import { ISecretStorageKeyInfo } from '../../../src/crypto/api';
 import { DeviceInfo } from '../../../src/crypto/deviceinfo';
+import { ISignatures } from "../../../src/@types/signed";
+import { ICurve25519AuthData } from "../../../src/crypto/keybackup";
 
 async function makeTestClient(userInfo: { userId: string, deviceId: string}, options: Partial<ICreateClientOpts> = {}) {
     const client = (new TestClient(
@@ -48,9 +51,15 @@ async function makeTestClient(userInfo: { userId: string, deviceId: string}, opt
 
 // Wrapper around pkSign to return a signed object. pkSign returns the
 // signature, rather than the signed object.
-function sign(obj, key, userId) {
+function sign<T extends IObject | ICurve25519AuthData>(obj: T, key: Uint8Array, userId: string): T & {
+    signatures: ISignatures;
+    unsigned?: object;
+} {
     olmlib.pkSign(obj, key, userId, '');
-    return obj;
+    return obj as T & {
+        signatures: ISignatures;
+        unsigned?: object;
+    };
 }
 
 describe("Secrets", function() {
@@ -169,12 +178,12 @@ describe("Secrets", function() {
             return [newKeyId, key];
         });
 
-        let keys = {};
+        let keys: Record<string, Uint8Array> = {};
         const alice = await makeTestClient(
             { userId: "@alice:example.com", deviceId: "Osborne2" },
             {
                 cryptoCallbacks: {
-                    getCrossSigningKey: t => keys[t],
+                    getCrossSigningKey: t => Promise.resolve(keys[t]),
                     saveCrossSigningKeys: k => keys = k,
                     getSecretStorageKey: getKey,
                 },
@@ -227,7 +236,7 @@ describe("Secrets", function() {
                 cryptoCallbacks: {
                     onSecretRequested: (userId, deviceId, requestId, secretName, deviceTrust) => {
                         expect(secretName).toBe("foo");
-                        return "bar";
+                        return Promise.resolve("bar");
                     },
                 },
             },
@@ -354,7 +363,7 @@ describe("Secrets", function() {
             const storagePublicKey = decryption.generate_key();
             const storagePrivateKey = decryption.get_private_key();
 
-            const bob = await makeTestClient(
+            const bob: MatrixClient = await makeTestClient(
                 {
                     userId: "@bob:example.com",
                     deviceId: "bob1",
@@ -364,15 +373,15 @@ describe("Secrets", function() {
                         getSecretStorageKey: async request => {
                             const defaultKeyId = await bob.getDefaultSecretStorageKeyId();
                             expect(Object.keys(request.keys)).toEqual([defaultKeyId]);
-                            return [defaultKeyId, storagePrivateKey];
+                            return [defaultKeyId!, storagePrivateKey];
                         },
                     },
                 },
             );
 
-            bob.uploadDeviceSigningKeys = async () => {};
-            bob.uploadKeySignatures = async () => {};
-            bob.setAccountData = async function(eventType, contents, callback) {
+            bob.uploadDeviceSigningKeys = async () => ({});
+            bob.uploadKeySignatures = async () => ({ failures: {} });
+            bob.setAccountData = async function(eventType, contents) {
                 const event = new MatrixEvent({
                     type: eventType,
                     content: contents,
@@ -380,16 +389,19 @@ describe("Secrets", function() {
                 this.store.storeAccountDataEvents([
                     event,
                 ]);
-                this.emit("accountData", event);
+                this.emit(ClientEvent.AccountData, event);
+                return {};
             };
-            bob.crypto.backupManager.checkKeyBackup = async () => {};
+            bob.crypto!.backupManager.checkKeyBackup = async () => null;
 
-            const crossSigning = bob.crypto.crossSigningInfo;
-            const secretStorage = bob.crypto.secretStorage;
+            const crossSigning = bob.crypto!.crossSigningInfo;
+            const secretStorage = bob.crypto!.secretStorage;
 
             // Set up cross-signing keys from scratch with specific storage key
             await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async func => await func({}),
+                authUploadDeviceSigningKeys: async func => {
+                    await func({});
+                },
             });
             await bob.bootstrapSecretStorage({
                 createSecretStorageKey: async () => ({
@@ -400,13 +412,15 @@ describe("Secrets", function() {
             });
 
             // Clear local cross-signing keys and read from secret storage
-            bob.crypto.deviceList.storeCrossSigningForUser(
+            bob.crypto!.deviceList.storeCrossSigningForUser(
                 "@bob:example.com",
                 crossSigning.toStorage(),
             );
             crossSigning.keys = {};
             await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async func => await func({}),
+                authUploadDeviceSigningKeys: async func => {
+                    await func({});
+                },
             });
 
             expect(crossSigning.getId()).toBeTruthy();
@@ -422,7 +436,7 @@ describe("Secrets", function() {
                 user_signing: USK,
                 self_signing: SSK,
             };
-            const secretStorageKeys = {
+            const secretStorageKeys: Record<string, Uint8Array> = {
                 key_id: SSSSKey,
             };
             const alice = await makeTestClient(
@@ -498,14 +512,14 @@ describe("Secrets", function() {
                             [`ed25519:${XSPubKey}`]: XSPubKey,
                         },
                     },
-                    self_signing: sign({
+                    self_signing: sign<ICrossSigningKey>({
                         user_id: "@alice:example.com",
                         usage: ["self_signing"],
                         keys: {
                             [`ed25519:${SSPubKey}`]: SSPubKey,
                         },
                     }, XSK, "@alice:example.com"),
-                    user_signing: sign({
+                    user_signing: sign<ICrossSigningKey>({
                         user_id: "@alice:example.com",
                         usage: ["user_signing"],
                         keys: {
@@ -557,7 +571,7 @@ describe("Secrets", function() {
                 user_signing: USK,
                 self_signing: SSK,
             };
-            const secretStorageKeys = {
+            const secretStorageKeys: Record<string, Uint8Array> = {
                 key_id: SSSSKey,
             };
             const alice = await makeTestClient(
@@ -642,14 +656,14 @@ describe("Secrets", function() {
                             [`ed25519:${XSPubKey}`]: XSPubKey,
                         },
                     },
-                    self_signing: sign({
+                    self_signing: sign<ICrossSigningKey>({
                         user_id: "@alice:example.com",
                         usage: ["self_signing"],
                         keys: {
                             [`ed25519:${SSPubKey}`]: SSPubKey,
                         },
                     }, XSK, "@alice:example.com"),
-                    user_signing: sign({
+                    user_signing: sign<ICrossSigningKey>({
                         user_id: "@alice:example.com",
                         usage: ["user_signing"],
                         keys: {
diff --git a/spec/unit/crypto/verification/sas.spec.ts b/spec/unit/crypto/verification/sas.spec.ts
index ee058c7f0a0..2d05b31b2c3 100644
--- a/spec/unit/crypto/verification/sas.spec.ts
+++ b/spec/unit/crypto/verification/sas.spec.ts
@@ -18,12 +18,12 @@ import "../../../olm-loader";
 import { makeTestClients } from './util';
 import { MatrixEvent } from "../../../../src/models/event";
 import { ISasEvent, SAS, SasEvent } from "../../../../src/crypto/verification/SAS";
-import { DeviceInfo } from "../../../../src/crypto/deviceinfo";
+import { DeviceInfo, IDevice } from "../../../../src/crypto/deviceinfo";
 import { CryptoEvent, verificationMethods } from "../../../../src/crypto";
 import * as olmlib from "../../../../src/crypto/olmlib";
 import { logger } from "../../../../src/logger";
 import { resetCrossSigningKeys } from "../crypto-utils";
-import { VerificationBase as Verification, VerificationBase } from "../../../../src/crypto/verification/Base";
+import { VerificationBase } from "../../../../src/crypto/verification/Base";
 import { IVerificationChannel } from "../../../../src/crypto/verification/request/Channel";
 import { MatrixClient } from "../../../../src";
 import { VerificationRequest } from "../../../../src/crypto/verification/request/VerificationRequest";
@@ -31,8 +31,8 @@ import { TestClient } from "../../../TestClient";
 
 const Olm = global.Olm;
 
-let ALICE_DEVICES;
-let BOB_DEVICES;
+let ALICE_DEVICES: Record<string, IDevice>;
+let BOB_DEVICES: Record<string, IDevice>;
 
 describe("SAS verification", function() {
     if (!global.Olm) {
@@ -75,7 +75,7 @@ describe("SAS verification", function() {
         let bob: TestClient;
         let aliceSasEvent: ISasEvent | null;
         let bobSasEvent: ISasEvent | null;
-        let aliceVerifier: Verification<any, any>;
+        let aliceVerifier: SAS;
         let bobPromise: Promise<VerificationBase<any, any>>;
         let clearTestClientTimeouts: () => void;
 
@@ -95,25 +95,25 @@ describe("SAS verification", function() {
 
             ALICE_DEVICES = {
                 Osborne2: {
-                    user_id: "@alice:example.com",
-                    device_id: "Osborne2",
                     algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
                     keys: {
-                        "ed25519:Osborne2": aliceDevice.deviceEd25519Key,
-                        "curve25519:Osborne2": aliceDevice.deviceCurve25519Key,
+                        "ed25519:Osborne2": aliceDevice.deviceEd25519Key!,
+                        "curve25519:Osborne2": aliceDevice.deviceCurve25519Key!,
                     },
+                    verified: DeviceInfo.DeviceVerification.UNVERIFIED,
+                    known: false,
                 },
             };
 
             BOB_DEVICES = {
                 Dynabook: {
-                    user_id: "@bob:example.com",
-                    device_id: "Dynabook",
                     algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
                     keys: {
-                        "ed25519:Dynabook": bobDevice.deviceEd25519Key,
-                        "curve25519:Dynabook": bobDevice.deviceCurve25519Key,
+                        "ed25519:Dynabook": bobDevice.deviceEd25519Key!,
+                        "curve25519:Dynabook": bobDevice.deviceCurve25519Key!,
                     },
+                    verified: DeviceInfo.DeviceVerification.UNVERIFIED,
+                    known: false,
                 },
             };
 
@@ -136,7 +136,7 @@ describe("SAS verification", function() {
 
             bobPromise = new Promise<VerificationBase<any, any>>((resolve, reject) => {
                 bob.client.on(CryptoEvent.VerificationRequest, request => {
-                    request.verifier!.on("show_sas", (e) => {
+                    (<SAS>request.verifier!).on(SasEvent.ShowSas, (e) => {
                         if (!e.sas.emoji || !e.sas.decimal) {
                             e.cancel();
                         } else if (!aliceSasEvent) {
@@ -158,7 +158,7 @@ describe("SAS verification", function() {
 
             aliceVerifier = alice.client.beginKeyVerification(
                 verificationMethods.SAS, bob.client.getUserId()!, bob.deviceId!,
-            );
+            ) as SAS;
             aliceVerifier.on(SasEvent.ShowSas, (e) => {
                 if (!e.sas.emoji || !e.sas.decimal) {
                     e.cancel();
@@ -413,7 +413,7 @@ describe("SAS verification", function() {
 
         const bobPromise = new Promise<VerificationBase<any, any>>((resolve, reject) => {
             bob.client.on(CryptoEvent.VerificationRequest, request => {
-                request.verifier!.on("show_sas", (e) => {
+                (<SAS>request.verifier!).on(SasEvent.ShowSas, (e) => {
                     e.mismatch();
                 });
                 resolve(request.verifier!);
@@ -443,13 +443,13 @@ describe("SAS verification", function() {
     });
 
     describe("verification in DM", function() {
-        let alice;
-        let bob;
-        let aliceSasEvent;
-        let bobSasEvent;
-        let aliceVerifier;
-        let bobPromise;
-        let clearTestClientTimeouts;
+        let alice: TestClient;
+        let bob: TestClient;
+        let aliceSasEvent: ISasEvent | null;
+        let bobSasEvent: ISasEvent | null;
+        let aliceVerifier: SAS;
+        let bobPromise: Promise<void>;
+        let clearTestClientTimeouts: Function;
 
         beforeEach(async function() {
             [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
@@ -477,7 +477,7 @@ describe("SAS verification", function() {
                 );
             };
             alice.client.downloadKeys = () => {
-                return Promise.resolve();
+                return Promise.resolve({});
             };
 
             bob.client.crypto!.setDeviceVerification = jest.fn();
@@ -495,16 +495,16 @@ describe("SAS verification", function() {
                 return "bob+base64+ed25519+key";
             };
             bob.client.downloadKeys = () => {
-                return Promise.resolve();
+                return Promise.resolve({});
             };
 
             aliceSasEvent = null;
             bobSasEvent = null;
 
             bobPromise = new Promise<void>((resolve, reject) => {
-                bob.client.on("crypto.verification.request", async (request) => {
-                    const verifier = request.beginKeyVerification(SAS.NAME);
-                    verifier.on("show_sas", (e) => {
+                bob.client.on(CryptoEvent.VerificationRequest, async (request) => {
+                    const verifier = request.beginKeyVerification(SAS.NAME) as SAS;
+                    verifier.on(SasEvent.ShowSas, (e) => {
                         if (!e.sas.emoji || !e.sas.decimal) {
                             e.cancel();
                         } else if (!aliceSasEvent) {
@@ -525,12 +525,10 @@ describe("SAS verification", function() {
                 });
             });
 
-            const aliceRequest = await alice.client.requestVerificationDM(
-                bob.client.getUserId(), "!room_id",
-            );
+            const aliceRequest = await alice.client.requestVerificationDM(bob.client.getUserId()!, "!room_id");
             await aliceRequest.waitFor(r => r.started);
-            aliceVerifier = aliceRequest.verifier;
-            aliceVerifier.on("show_sas", (e) => {
+            aliceVerifier = aliceRequest.verifier! as SAS;
+            aliceVerifier.on(SasEvent.ShowSas, (e) => {
                 if (!e.sas.emoji || !e.sas.decimal) {
                     e.cancel();
                 } else if (!bobSasEvent) {
diff --git a/spec/unit/crypto/verification/secret_request.spec.ts b/spec/unit/crypto/verification/secret_request.spec.ts
index 2f9fafb5dfc..20ea64d4ac3 100644
--- a/spec/unit/crypto/verification/secret_request.spec.ts
+++ b/spec/unit/crypto/verification/secret_request.spec.ts
@@ -125,7 +125,7 @@ describe("self-verifications", () => {
         expect(restoreKeyBackupWithCache).toHaveBeenCalled();
 
         expect(result).toBeInstanceOf(Array);
-        expect(result[0][0]).toBe(testKeyPub);
-        expect(result[1][0]).toBe(testKeyPub);
+        expect(result![0][0]).toBe(testKeyPub);
+        expect(result![1][0]).toBe(testKeyPub);
     });
 });
diff --git a/spec/unit/crypto/verification/util.ts b/spec/unit/crypto/verification/util.ts
index 5efbe4ed5bd..f66d6464f5e 100644
--- a/spec/unit/crypto/verification/util.ts
+++ b/spec/unit/crypto/verification/util.ts
@@ -16,13 +16,21 @@ limitations under the License.
 */
 
 import { TestClient } from '../../../TestClient';
-import { MatrixEvent } from "../../../../src/models/event";
+import { IContent, MatrixEvent } from "../../../../src/models/event";
 import { IRoomTimelineData } from "../../../../src/models/event-timeline-set";
 import { Room, RoomEvent } from "../../../../src/models/room";
 import { logger } from '../../../../src/logger';
-import { MatrixClient, ClientEvent } from '../../../../src/client';
+import { MatrixClient, ClientEvent, ICreateClientOpts } from '../../../../src/client';
 
-export async function makeTestClients(userInfos, options): Promise<[TestClient[], () => void]> {
+interface UserInfo {
+    userId: string;
+    deviceId: string;
+}
+
+export async function makeTestClients(
+    userInfos: UserInfo[],
+    options: Partial<ICreateClientOpts>,
+): Promise<[TestClient[], () => void]> {
     const clients: TestClient[] = [];
     const timeouts: ReturnType<typeof setTimeout>[] = [];
     const clientMap: Record<string, Record<string, MatrixClient>> = {};
@@ -51,7 +59,7 @@ export async function makeTestClients(userInfos, options): Promise<[TestClient[]
         }
         return {};
     };
-    const makeSendEvent = (matrixClient: MatrixClient) => (room, type, content) => {
+    const makeSendEvent = (matrixClient: MatrixClient) => (room: string, type: string, content: IContent) => {
         // make up a unique ID as the event ID
         const eventId = "$" + matrixClient.makeTxnId();
         const rawEvent = {
@@ -88,11 +96,12 @@ export async function makeTestClients(userInfos, options): Promise<[TestClient[]
     };
 
     for (const userInfo of userInfos) {
-        let keys = {};
+        let keys: Record<string, Uint8Array> = {};
         if (!options) options = {};
         if (!options.cryptoCallbacks) options.cryptoCallbacks = {};
         if (!options.cryptoCallbacks.saveCrossSigningKeys) {
             options.cryptoCallbacks.saveCrossSigningKeys = k => { keys = k; };
+            // @ts-ignore tsc getting confused by overloads
             options.cryptoCallbacks.getCrossSigningKey = typ => keys[typ];
         }
         const testClient = new TestClient(
@@ -104,6 +113,7 @@ export async function makeTestClients(userInfos, options): Promise<[TestClient[]
         }
         clientMap[userInfo.userId][userInfo.deviceId] = testClient.client;
         testClient.client.sendToDevice = makeSendToDevice(testClient.client);
+        // @ts-ignore tsc getting confused by overloads
         testClient.client.sendEvent = makeSendEvent(testClient.client);
         clients.push(testClient);
     }
diff --git a/spec/unit/crypto/verification/verification_request.spec.ts b/spec/unit/crypto/verification/verification_request.spec.ts
index 6549c3af78a..2dce928e821 100644
--- a/spec/unit/crypto/verification/verification_request.spec.ts
+++ b/spec/unit/crypto/verification/verification_request.spec.ts
@@ -18,7 +18,7 @@ import { VerificationRequest, READY_TYPE, START_TYPE, DONE_TYPE } from
 import { InRoomChannel } from "../../../../src/crypto/verification/request/InRoomChannel";
 import { ToDeviceChannel } from
     "../../../../src/crypto/verification/request/ToDeviceChannel";
-import { MatrixEvent } from "../../../../src/models/event";
+import { IContent, MatrixEvent } from "../../../../src/models/event";
 import { MatrixClient } from "../../../../src/client";
 import { IVerificationChannel } from "../../../../src/crypto/verification/request/Channel";
 import { VerificationBase } from "../../../../src/crypto/verification/Base";
@@ -30,12 +30,12 @@ type MockClient = MatrixClient & {
 function makeMockClient(userId: string, deviceId: string): MockClient {
     let counter = 1;
     let events: MatrixEvent[] = [];
-    const deviceEvents = {};
+    const deviceEvents: Record<string, Record<string, MatrixEvent[]>> = {};
     return {
         getUserId() { return userId; },
         getDeviceId() { return deviceId; },
 
-        sendEvent(roomId, type, content) {
+        sendEvent(roomId: string, type: string, content: IContent) {
             counter = counter + 1;
             const eventId = `$${userId}-${deviceId}-${counter}`;
             events.push(new MatrixEvent({
@@ -49,7 +49,7 @@ function makeMockClient(userId: string, deviceId: string): MockClient {
             return Promise.resolve({ event_id: eventId });
         },
 
-        sendToDevice(type, msgMap) {
+        sendToDevice(type: string, msgMap: Record<string, Record<string, IContent>>) {
             for (const userId of Object.keys(msgMap)) {
                 const deviceMap = msgMap[userId];
                 for (const deviceId of Object.keys(deviceMap)) {
@@ -111,7 +111,7 @@ class MockVerifier extends VerificationBase<'', any> {
         }
     }
 
-    async handleEvent(event) {
+    async handleEvent(event: MatrixEvent) {
         if (event.getType() === DONE_TYPE && !this._startEvent) {
             await this._channel.send(DONE_TYPE, {});
         }
@@ -122,7 +122,7 @@ class MockVerifier extends VerificationBase<'', any> {
     }
 }
 
-function makeRemoteEcho(event) {
+function makeRemoteEcho(event: MatrixEvent) {
     return new MatrixEvent(Object.assign({}, event.event, {
         unsigned: {
             transaction_id: "abc",
diff --git a/spec/unit/matrix-client.spec.ts b/spec/unit/matrix-client.spec.ts
index ba4be9f9b20..419ef50206c 100644
--- a/spec/unit/matrix-client.spec.ts
+++ b/spec/unit/matrix-client.spec.ts
@@ -17,7 +17,7 @@ limitations under the License.
 import { mocked } from "jest-mock";
 
 import { logger } from "../../src/logger";
-import { MatrixClient, ClientEvent } from "../../src/client";
+import { ClientEvent, ITurnServerResponse, MatrixClient, Store } from "../../src/client";
 import { Filter } from "../../src/filter";
 import { DEFAULT_TREE_POWER_LEVELS_TEMPLATE } from "../../src/models/MSC3089TreeSpace";
 import {
@@ -36,7 +36,16 @@ import { ReceiptType } from "../../src/@types/read_receipts";
 import * as testUtils from "../test-utils/test-utils";
 import { makeBeaconInfoContent } from "../../src/content-helpers";
 import { M_BEACON_INFO } from "../../src/@types/beacon";
-import { ContentHelpers, EventTimeline, MatrixError, Room } from "../../src";
+import {
+    ContentHelpers,
+    EventTimeline, ICreateRoomOpts,
+    IRequestOpts,
+    MatrixError,
+    MatrixHttpApi,
+    MatrixScheduler,
+    Method,
+    Room,
+} from "../../src";
 import { supportsMatrixCall } from "../../src/webrtc/call";
 import { makeBeaconEvent } from "../test-utils/beacon";
 import {
@@ -44,6 +53,9 @@ import {
     POLICIES_ACCOUNT_EVENT_TYPE,
     PolicyScope,
 } from "../../src/models/invites-ignorer";
+import { IOlmDevice } from "../../src/crypto/algorithms/megolm";
+import { QueryDict } from "../../src/utils";
+import { SyncState } from "../../src/sync";
 
 jest.useFakeTimers();
 
@@ -52,17 +64,36 @@ jest.mock("../../src/webrtc/call", () => ({
     supportsMatrixCall: jest.fn(() => false),
 }));
 
+type HttpLookup = {
+    method: string;
+    path: string;
+    data?: Record<string, any>;
+    error?: object;
+    expectBody?: Record<string, any>;
+    expectQueryParams?: QueryDict;
+    thenCall?: Function;
+};
+
+interface Options extends ICreateRoomOpts {
+    _roomId?: string;
+}
+
+type WrappedRoom = Room & {
+    _options: Options;
+    _state: Map<string, any>;
+};
+
 describe("MatrixClient", function() {
     const userId = "@alice:bar";
     const identityServerUrl = "https://identity.server";
     const identityServerDomain = "identity.server";
-    let client;
-    let store;
-    let scheduler;
+    let client: MatrixClient;
+    let store: Store;
+    let scheduler: MatrixScheduler;
 
     const KEEP_ALIVE_PATH = "/_matrix/client/versions";
 
-    const PUSH_RULES_RESPONSE = {
+    const PUSH_RULES_RESPONSE: HttpLookup = {
         method: "GET",
         path: "/pushrules/",
         data: {},
@@ -70,7 +101,7 @@ describe("MatrixClient", function() {
 
     const FILTER_PATH = "/user/" + encodeURIComponent(userId) + "/filter";
 
-    const FILTER_RESPONSE = {
+    const FILTER_RESPONSE: HttpLookup = {
         method: "POST",
         path: FILTER_PATH,
         data: { filter_id: "f1lt3r" },
@@ -82,29 +113,21 @@ describe("MatrixClient", function() {
         rooms: {},
     };
 
-    const SYNC_RESPONSE = {
+    const SYNC_RESPONSE: HttpLookup = {
         method: "GET",
         path: "/sync",
         data: SYNC_DATA,
     };
 
     // items are popped off when processed and block if no items left.
-    let httpLookups: {
-        method: string;
-        path: string;
-        data?: object;
-        error?: object;
-        expectBody?: object;
-        expectQueryParams?: object;
-        thenCall?: Function;
-    }[] = [];
+    let httpLookups: HttpLookup[] = [];
     let acceptKeepalives: boolean;
     let pendingLookup: {
         promise: Promise<any>;
         method: string;
         path: string;
     } | null = null;
-    function httpReq(method, path, qp, data, prefix) {
+    function httpReq(method: Method, path: string, qp?: QueryDict, data?: BodyInit, opts?: IRequestOpts) {
         if (path === KEEP_ALIVE_PATH && acceptKeepalives) {
             return Promise.resolve({
                 unstable_features: {
@@ -145,7 +168,7 @@ describe("MatrixClient", function() {
             }
             if (next.expectQueryParams) {
                 Object.keys(next.expectQueryParams).forEach(function(k) {
-                    expect(qp[k]).toEqual(next.expectQueryParams![k]);
+                    expect(qp?.[k]).toEqual(next.expectQueryParams![k]);
                 });
             }
 
@@ -184,24 +207,38 @@ describe("MatrixClient", function() {
             userId: userId,
         });
         // FIXME: We shouldn't be yanking http like this.
-        client.http = [
-            "authedRequest", "getContentUri", "request", "uploadContent",
-        ].reduce((r, k) => { r[k] = jest.fn(); return r; }, {});
-        client.http.authedRequest.mockImplementation(httpReq);
-        client.http.request.mockImplementation(httpReq);
+        client.http = ([
+            "authedRequest",
+            "getContentUri",
+            "request",
+            "uploadContent",
+        ] as const).reduce((r, k) => {
+            r[k] = jest.fn();
+            return r;
+        }, {} as MatrixHttpApi<any>);
+        mocked(client.http.authedRequest).mockImplementation(httpReq);
+        mocked(client.http.request).mockImplementation(httpReq);
     }
 
     beforeEach(function() {
-        scheduler = [
-            "getQueueForEvent", "queueEvent", "removeEventFromQueue",
+        scheduler = ([
+            "getQueueForEvent",
+            "queueEvent",
+            "removeEventFromQueue",
             "setProcessFunction",
-        ].reduce((r, k) => { r[k] = jest.fn(); return r; }, {});
-        store = [
+        ] as const).reduce((r, k) => {
+            r[k] = jest.fn();
+            return r;
+        }, {} as MatrixScheduler);
+        store = ([
             "getRoom", "getRooms", "getUser", "getSyncToken", "scrollback",
             "save", "wantsSave", "setSyncToken", "storeEvents", "storeRoom", "storeUser",
             "getFilterIdByName", "setFilterIdByName", "getFilter", "storeFilter",
-            "getSyncAccumulator", "startup", "deleteAllData",
-        ].reduce((r, k) => { r[k] = jest.fn(); return r; }, {});
+            "startup", "deleteAllData",
+        ] as const).reduce((r, k) => {
+            r[k] = jest.fn();
+            return r;
+        }, {} as Store);
         store.getSavedSync = jest.fn().mockReturnValue(Promise.resolve(null));
         store.getSavedSyncToken = jest.fn().mockReturnValue(Promise.resolve(null));
         store.setSyncData = jest.fn().mockReturnValue(Promise.resolve(null));
@@ -225,7 +262,7 @@ describe("MatrixClient", function() {
         // means they may call /events and then fail an expect() which will fail
         // a DIFFERENT test (pollution between tests!) - we return unresolved
         // promises to stop the client from continuing to run.
-        client.http.authedRequest.mockImplementation(function() {
+        mocked(client.http.authedRequest).mockImplementation(function() {
             return new Promise(() => {});
         });
         client.stopClient();
@@ -289,7 +326,7 @@ describe("MatrixClient", function() {
             const txnId = client.makeTxnId();
 
             const room = new Room(roomId, client, userId);
-            store.getRoom.mockReturnValue(room);
+            mocked(store.getRoom).mockReturnValue(room);
 
             const rootEvent = new MatrixEvent({ event_id: threadId });
             room.createThread(threadId, rootEvent, [rootEvent], false);
@@ -329,7 +366,7 @@ describe("MatrixClient", function() {
             };
 
             const room = new Room(roomId, client, userId);
-            store.getRoom.mockReturnValue(room);
+            mocked(store.getRoom).mockReturnValue(room);
 
             const rootEvent = new MatrixEvent({ event_id: threadId });
             room.createThread(threadId, rootEvent, [rootEvent], false);
@@ -359,7 +396,7 @@ describe("MatrixClient", function() {
         const userId = "@test:example.org";
         const roomId = "!room:example.org";
         const roomName = "Test Tree";
-        const mockRoom = {};
+        const mockRoom = {} as unknown as Room;
         const fn = jest.fn().mockImplementation((opts) => {
             expect(opts).toMatchObject({
                 name: roomName,
@@ -431,23 +468,23 @@ describe("MatrixClient", function() {
                         throw new Error("Unexpected event type or state key");
                     }
                 },
-            },
-        };
+            } as Room["currentState"],
+        } as unknown as Room;
         client.getRoom = (getRoomId) => {
             expect(getRoomId).toEqual(roomId);
             return mockRoom;
         };
         const tree = client.unstableGetFileTreeSpace(roomId);
         expect(tree).toBeDefined();
-        expect(tree.roomId).toEqual(roomId);
-        expect(tree.room).toBe(mockRoom);
+        expect(tree!.roomId).toEqual(roomId);
+        expect(tree!.room).toBe(mockRoom);
     });
 
     it("should not get (unstable) file trees if not joined", async () => {
         const roomId = "!room:example.org";
         const mockRoom = {
             getMyMembership: () => "leave", // "not join"
-        };
+        } as unknown as Room;
         client.getRoom = (getRoomId) => {
             expect(getRoomId).toEqual(roomId);
             return mockRoom;
@@ -491,8 +528,8 @@ describe("MatrixClient", function() {
                         throw new Error("Unexpected event type or state key");
                     }
                 },
-            },
-        };
+            } as Room["currentState"],
+        } as unknown as Room;
         client.getRoom = (getRoomId) => {
             expect(getRoomId).toEqual(roomId);
             return mockRoom;
@@ -525,8 +562,8 @@ describe("MatrixClient", function() {
                         throw new Error("Unexpected event type or state key");
                     }
                 },
-            },
-        };
+            } as Room["currentState"],
+        } as unknown as Room;
         client.getRoom = (getRoomId) => {
             expect(getRoomId).toEqual(roomId);
             return mockRoom;
@@ -541,15 +578,15 @@ describe("MatrixClient", function() {
             SYNC_RESPONSE,
         ];
         const filterId = "ehfewf";
-        store.getFilterIdByName.mockReturnValue(filterId);
+        mocked(store.getFilterIdByName).mockReturnValue(filterId);
         const filter = new Filter("0", filterId);
         filter.setDefinition({ "room": { "timeline": { "limit": 8 } } });
-        store.getFilter.mockReturnValue(filter);
+        mocked(store.getFilter).mockReturnValue(filter);
         const syncPromise = new Promise<void>((resolve, reject) => {
-            client.on("sync", function syncListener(state) {
+            client.on(ClientEvent.Sync, function syncListener(state) {
                 if (state === "SYNCING") {
                     expect(httpLookups.length).toEqual(0);
-                    client.removeListener("sync", syncListener);
+                    client.removeListener(ClientEvent.Sync, syncListener);
                     resolve();
                 } else if (state === "ERROR") {
                     reject(new Error("sync error"));
@@ -567,10 +604,10 @@ describe("MatrixClient", function() {
 
         it("should return the same sync state as emitted sync events", async function() {
             const syncingPromise = new Promise<void>((resolve) => {
-                client.on("sync", function syncListener(state) {
+                client.on(ClientEvent.Sync, function syncListener(state) {
                     expect(state).toEqual(client.getSyncState());
                     if (state === "SYNCING") {
-                        client.removeListener("sync", syncListener);
+                        client.removeListener(ClientEvent.Sync, syncListener);
                         resolve();
                     }
                 });
@@ -586,7 +623,7 @@ describe("MatrixClient", function() {
         it("should use an existing filter if id is present in localStorage", function() {
         });
         it("should handle localStorage filterId missing from the server", function(done) {
-            function getFilterName(userId, suffix?: string) {
+            function getFilterName(userId: string, suffix?: string) {
                 // scope this on the user ID because people may login on many accounts
                 // and they all need to be stored!
                 return "FILTER_SYNC_" + userId + (suffix ? "_" + suffix : "");
@@ -605,14 +642,14 @@ describe("MatrixClient", function() {
                 },
             });
             httpLookups.push(FILTER_RESPONSE);
-            store.getFilterIdByName.mockReturnValue(invalidFilterId);
+            mocked(store.getFilterIdByName).mockReturnValue(invalidFilterId);
 
-            const filterName = getFilterName(client.credentials.userId);
+            const filterName = getFilterName(client.credentials.userId!);
             client.store.setFilterIdByName(filterName, invalidFilterId);
             const filter = new Filter(client.credentials.userId);
 
             client.getOrCreateFilter(filterName, filter).then(function(filterId) {
-                expect(filterId).toEqual(FILTER_RESPONSE.data.filter_id);
+                expect(filterId).toEqual(FILTER_RESPONSE.data?.filter_id);
                 done();
             });
         });
@@ -634,13 +671,13 @@ describe("MatrixClient", function() {
             httpLookups.push(FILTER_RESPONSE);
             httpLookups.push(SYNC_RESPONSE);
 
-            client.on("sync", function syncListener(state) {
+            client.on(ClientEvent.Sync, function syncListener(state) {
                 if (state === "ERROR" && httpLookups.length > 0) {
                     expect(httpLookups.length).toEqual(2);
                     expect(client.retryImmediately()).toBe(true);
                     jest.advanceTimersByTime(1);
                 } else if (state === "PREPARED" && httpLookups.length === 0) {
-                    client.removeListener("sync", syncListener);
+                    client.removeListener(ClientEvent.Sync, syncListener);
                     done();
                 } else {
                     // unexpected state transition!
@@ -658,7 +695,7 @@ describe("MatrixClient", function() {
                 method: "GET", path: "/sync", data: SYNC_DATA,
             });
 
-            client.on("sync", function syncListener(state) {
+            client.on(ClientEvent.Sync, function syncListener(state) {
                 if (state === "ERROR" && httpLookups.length > 0) {
                     expect(httpLookups.length).toEqual(1);
                     expect(client.retryImmediately()).toBe(
@@ -668,7 +705,7 @@ describe("MatrixClient", function() {
                 } else if (state === "RECONNECTING" && httpLookups.length > 0) {
                     jest.advanceTimersByTime(10000);
                 } else if (state === "SYNCING" && httpLookups.length === 0) {
-                    client.removeListener("sync", syncListener);
+                    client.removeListener(ClientEvent.Sync, syncListener);
                     done();
                 }
             });
@@ -684,13 +721,13 @@ describe("MatrixClient", function() {
             httpLookups.push(FILTER_RESPONSE);
             httpLookups.push(SYNC_RESPONSE);
 
-            client.on("sync", function syncListener(state) {
+            client.on(ClientEvent.Sync, function syncListener(state) {
                 if (state === "ERROR" && httpLookups.length > 0) {
                     expect(httpLookups.length).toEqual(3);
                     expect(client.retryImmediately()).toBe(true);
                     jest.advanceTimersByTime(1);
                 } else if (state === "PREPARED" && httpLookups.length === 0) {
-                    client.removeListener("sync", syncListener);
+                    client.removeListener(ClientEvent.Sync, syncListener);
                     done();
                 } else {
                     // unexpected state transition!
@@ -702,8 +739,8 @@ describe("MatrixClient", function() {
     });
 
     describe("emitted sync events", function() {
-        function syncChecker(expectedStates, done) {
-            return function syncListener(state, old) {
+        function syncChecker(expectedStates: [string, string | null][], done: Function) {
+            return function syncListener(state: SyncState, old: SyncState | null) {
                 const expected = expectedStates.shift();
                 logger.log(
                     "'sync' curr=%s old=%s EXPECT=%s", state, old, expected,
@@ -715,7 +752,7 @@ describe("MatrixClient", function() {
                 expect(state).toEqual(expected[0]);
                 expect(old).toEqual(expected[1]);
                 if (expectedStates.length === 0) {
-                    client.removeListener("sync", syncListener);
+                    client.removeListener(ClientEvent.Sync, syncListener);
                     done();
                 }
                 // standard retry time is 5 to 10 seconds
@@ -726,7 +763,7 @@ describe("MatrixClient", function() {
         it("should transition null -> PREPARED after the first /sync", function(done) {
             const expectedStates: [string, string | null][] = [];
             expectedStates.push(["PREPARED", null]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
@@ -738,7 +775,7 @@ describe("MatrixClient", function() {
                 method: "POST", path: FILTER_PATH, error: { errcode: "NOPE_NOPE_NOPE" },
             });
             expectedStates.push(["ERROR", null]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
@@ -768,7 +805,7 @@ describe("MatrixClient", function() {
             expectedStates.push(["RECONNECTING", null]);
             expectedStates.push(["ERROR", "RECONNECTING"]);
             expectedStates.push(["CATCHUP", "ERROR"]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
@@ -776,7 +813,7 @@ describe("MatrixClient", function() {
             const expectedStates: [string, string | null][] = [];
             expectedStates.push(["PREPARED", null]);
             expectedStates.push(["SYNCING", "PREPARED"]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
@@ -795,7 +832,7 @@ describe("MatrixClient", function() {
             expectedStates.push(["SYNCING", "PREPARED"]);
             expectedStates.push(["RECONNECTING", "SYNCING"]);
             expectedStates.push(["ERROR", "RECONNECTING"]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
@@ -809,7 +846,7 @@ describe("MatrixClient", function() {
             expectedStates.push(["PREPARED", null]);
             expectedStates.push(["SYNCING", "PREPARED"]);
             expectedStates.push(["ERROR", "SYNCING"]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
@@ -821,7 +858,7 @@ describe("MatrixClient", function() {
             expectedStates.push(["PREPARED", null]);
             expectedStates.push(["SYNCING", "PREPARED"]);
             expectedStates.push(["SYNCING", "SYNCING"]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
@@ -845,7 +882,7 @@ describe("MatrixClient", function() {
             expectedStates.push(["RECONNECTING", "SYNCING"]);
             expectedStates.push(["ERROR", "RECONNECTING"]);
             expectedStates.push(["ERROR", "ERROR"]);
-            client.on("sync", syncChecker(expectedStates, done));
+            client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
     });
@@ -914,14 +951,14 @@ describe("MatrixClient", function() {
                         throw new Error("Unexpected event type or state key");
                     }
                 },
-            },
+            } as Room["currentState"],
             getThread: jest.fn(),
             addPendingEvent: jest.fn(),
             updatePendingEvent: jest.fn(),
             reEmitter: {
                 reEmit: jest.fn(),
             },
-        };
+        } as unknown as Room;
 
         beforeEach(() => {
             client.getRoom = (getRoomId) => {
@@ -987,7 +1024,7 @@ describe("MatrixClient", function() {
 
         const mockRoom = {
             getMyMembership: () => "join",
-            updatePendingEvent: (event, status) => event.setStatus(status),
+            updatePendingEvent: (event: MatrixEvent, status: EventStatus) => event.setStatus(status),
             currentState: {
                 getStateEvents: (eventType, stateKey) => {
                     if (eventType === EventType.RoomCreate) {
@@ -1004,15 +1041,14 @@ describe("MatrixClient", function() {
                         throw new Error("Unexpected event type or state key");
                     }
                 },
-            },
-        };
+            } as Room["currentState"],
+        } as unknown as Room;
 
-        let event;
+        let event: MatrixEvent;
         beforeEach(async () => {
             event = new MatrixEvent({
                 event_id: "~" + roomId + ":" + txnId,
-                user_id: client.credentials.userId,
-                sender: client.credentials.userId,
+                sender: client.credentials.userId!,
                 room_id: roomId,
                 origin_server_ts: new Date().getTime(),
             });
@@ -1023,25 +1059,26 @@ describe("MatrixClient", function() {
                 return mockRoom;
             };
             client.crypto = { // mock crypto
-                encryptEvent: (event, room) => new Promise(() => {}),
+                encryptEvent: () => new Promise(() => {}),
                 stop: jest.fn(),
-            };
+            } as unknown as Crypto;
         });
 
         function assertCancelled() {
             expect(event.status).toBe(EventStatus.CANCELLED);
-            expect(client.scheduler.removeEventFromQueue(event)).toBeFalsy();
+            expect(client.scheduler?.removeEventFromQueue(event)).toBeFalsy();
             expect(httpLookups.filter(h => h.path.includes("/send/")).length).toBe(0);
         }
 
         it("should cancel an event which is queued", () => {
             event.setStatus(EventStatus.QUEUED);
-            client.scheduler.queueEvent(event);
+            client.scheduler?.queueEvent(event);
             client.cancelPendingEvent(event);
             assertCancelled();
         });
 
         it("should cancel an event which is encrypting", async () => {
+            // @ts-ignore protected method access
             client.encryptAndSendEvent(null, event);
             await testUtils.emitPromise(event, "Event.status");
             client.cancelPendingEvent(event);
@@ -1103,7 +1140,7 @@ describe("MatrixClient", function() {
             const room = {
                 hasPendingEvent: jest.fn().mockReturnValue(false),
                 addLocalEchoReceipt: jest.fn(),
-            };
+            } as unknown as Room;
             const rrEvent = new MatrixEvent({ event_id: "read_event_id" });
             const rpEvent = new MatrixEvent({ event_id: "read_private_event_id" });
             client.getRoom = () => room;
@@ -1142,7 +1179,7 @@ describe("MatrixClient", function() {
         const content = makeBeaconInfoContent(100, true);
 
         beforeEach(() => {
-            client.http.authedRequest.mockClear().mockResolvedValue({});
+            mocked(client.http.authedRequest).mockClear().mockResolvedValue({});
         });
 
         it("creates new beacon info", async () => {
@@ -1150,7 +1187,7 @@ describe("MatrixClient", function() {
 
             // event type combined
             const expectedEventType = M_BEACON_INFO.name;
-            const [method, path, queryParams, requestContent] = client.http.authedRequest.mock.calls[0];
+            const [method, path, queryParams, requestContent] = mocked(client.http.authedRequest).mock.calls[0];
             expect(method).toBe('PUT');
             expect(path).toEqual(
                 `/rooms/${encodeURIComponent(roomId)}/state/` +
@@ -1164,7 +1201,7 @@ describe("MatrixClient", function() {
             await client.unstable_setLiveBeacon(roomId, content);
 
             // event type combined
-            const [, path, , requestContent] = client.http.authedRequest.mock.calls[0];
+            const [, path, , requestContent] = mocked(client.http.authedRequest).mock.calls[0];
             expect(path).toEqual(
                 `/rooms/${encodeURIComponent(roomId)}/state/` +
                 `${encodeURIComponent(M_BEACON_INFO.name)}/${encodeURIComponent(userId)}`,
@@ -1242,7 +1279,7 @@ describe("MatrixClient", function() {
         const newPassword = 'newpassword';
 
         const passwordTest = (expectedRequestContent: any) => {
-            const [method, path, queryParams, requestContent] = client.http.authedRequest.mock.calls[0];
+            const [method, path, queryParams, requestContent] = mocked(client.http.authedRequest).mock.calls[0];
             expect(method).toBe('POST');
             expect(path).toEqual('/account/password');
             expect(queryParams).toBeFalsy();
@@ -1250,7 +1287,7 @@ describe("MatrixClient", function() {
         };
 
         beforeEach(() => {
-            client.http.authedRequest.mockClear().mockResolvedValue({});
+            mocked(client.http.authedRequest).mockClear().mockResolvedValue({});
         });
 
         it("no logout_devices specified", async () => {
@@ -1289,13 +1326,13 @@ describe("MatrixClient", function() {
             const response = {
                 aliases: ["#woop:example.org", "#another:example.org"],
             };
-            client.http.authedRequest.mockClear().mockResolvedValue(response);
+            mocked(client.http.authedRequest).mockClear().mockResolvedValue(response);
 
             const roomId = "!whatever:example.org";
             const result = await client.getLocalAliases(roomId);
 
             // Current version of the endpoint we support is v3
-            const [method, path, queryParams, data, opts] = client.http.authedRequest.mock.calls[0];
+            const [method, path, queryParams, data, opts] = mocked(client.http.authedRequest).mock.calls[0];
             expect(data).toBeFalsy();
             expect(method).toBe('GET');
             expect(path).toEqual(`/rooms/${encodeURIComponent(roomId)}/aliases`);
@@ -1352,11 +1389,11 @@ describe("MatrixClient", function() {
                 ],
                 username: "1443779631:@user:example.com",
                 password: "JlKfBy1QwLrO20385QyAtEyIv0=",
-            };
+            } as unknown as ITurnServerResponse;
             jest.spyOn(client, "turnServer").mockResolvedValue(turnServer);
 
             const events: any[][] = [];
-            const onTurnServers = (...args) => events.push(args);
+            const onTurnServers = (...args: any[]) => events.push(args);
             client.on(ClientEvent.TurnServers, onTurnServers);
             expect(await client.checkTurnServers()).toBe(true);
             client.off(ClientEvent.TurnServers, onTurnServers);
@@ -1372,7 +1409,7 @@ describe("MatrixClient", function() {
             jest.spyOn(client, "turnServer").mockRejectedValue(error);
 
             const events: any[][] = [];
-            const onTurnServersError = (...args) => events.push(args);
+            const onTurnServersError = (...args: any[]) => events.push(args);
             client.on(ClientEvent.TurnServersError, onTurnServersError);
             expect(await client.checkTurnServers()).toBe(false);
             client.off(ClientEvent.TurnServersError, onTurnServersError);
@@ -1384,7 +1421,7 @@ describe("MatrixClient", function() {
             jest.spyOn(client, "turnServer").mockRejectedValue(error);
 
             const events: any[][] = [];
-            const onTurnServersError = (...args) => events.push(args);
+            const onTurnServersError = (...args: any[]) => events.push(args);
             client.on(ClientEvent.TurnServersError, onTurnServersError);
             expect(await client.checkTurnServers()).toBe(false);
             client.off(ClientEvent.TurnServersError, onTurnServersError);
@@ -1400,7 +1437,7 @@ describe("MatrixClient", function() {
 
         it("is an alias for the crypto method", async () => {
             client.crypto = testUtils.mock(Crypto, "Crypto");
-            const deviceInfos = [];
+            const deviceInfos: IOlmDevice[] = [];
             const payload = {};
             await client.encryptAndSendToDevices(deviceInfos, payload);
             expect(client.crypto.encryptAndSendToDevices).toHaveBeenLastCalledWith(deviceInfos, payload);
@@ -1413,7 +1450,7 @@ describe("MatrixClient", function() {
             const dataStore = new Map();
             client.setAccountData = function(eventType, content) {
                 dataStore.set(eventType, content);
-                return Promise.resolve();
+                return Promise.resolve({});
             };
             client.getAccountData = function(eventType) {
                 const data = dataStore.get(eventType);
@@ -1424,9 +1461,9 @@ describe("MatrixClient", function() {
 
             // Mockup `createRoom`/`getRoom`/`joinRoom`, including state.
             const rooms = new Map();
-            client.createRoom = function(options = {}) {
+            client.createRoom = function(options: Options = {}) {
                 const roomId = options["_roomId"] || `!room-${rooms.size}:example.org`;
-                const state = new Map();
+                const state = new Map<string, any>();
                 const room = {
                     roomId,
                     _options: options,
@@ -1444,24 +1481,24 @@ describe("MatrixClient", function() {
                                             },
                                         };
                                     },
-                                };
+                                } as EventTimeline;
                             },
                         };
                     },
-                };
+                } as unknown as WrappedRoom;
                 rooms.set(roomId, room);
                 return Promise.resolve({ room_id: roomId });
             };
             client.getRoom = function(roomId) {
                 return rooms.get(roomId);
             };
-            client.joinRoom = function(roomId) {
-                return this.getRoom(roomId) || this.createRoom({ _roomId: roomId });
+            client.joinRoom = async function(roomId) {
+                return this.getRoom(roomId)! || this.createRoom({ _roomId: roomId } as ICreateRoomOpts);
             };
 
             // Mockup state events
             client.sendStateEvent = function(roomId, type, content) {
-                const room = this.getRoom(roomId);
+                const room = this.getRoom(roomId) as WrappedRoom;
                 const state: Map<string, any> = room._state;
                 let store = state.get(type);
                 if (!store) {
@@ -1480,14 +1517,15 @@ describe("MatrixClient", function() {
                         return content;
                     },
                 };
-                return { event_id: eventId };
+                return Promise.resolve({ event_id: eventId });
             };
             client.redactEvent = function(roomId, eventId) {
-                const room = this.getRoom(roomId);
+                const room = this.getRoom(roomId) as WrappedRoom;
                 const state: Map<string, any> = room._state;
                 for (const store of state.values()) {
-                    delete store[eventId];
+                    delete store[eventId!];
                 }
+                return Promise.resolve({ event_id: "$" + eventId + "-" + Math.random() });
             };
         });
 
@@ -1523,7 +1561,7 @@ describe("MatrixClient", function() {
                 roomId: "!snafu:somewhere.org",
             });
             expect(ruleMatch).toBeTruthy();
-            expect(ruleMatch.getContent()).toMatchObject({
+            expect(ruleMatch!.getContent()).toMatchObject({
                 recommendation: "m.ban",
                 reason: "just a test",
             });
@@ -1552,7 +1590,7 @@ describe("MatrixClient", function() {
                 roomId: "!snafu:somewhere.org",
             });
             expect(ruleSenderMatch).toBeTruthy();
-            expect(ruleSenderMatch.getContent()).toMatchObject({
+            expect(ruleSenderMatch!.getContent()).toMatchObject({
                 recommendation: "m.ban",
                 reason: REASON,
             });
@@ -1562,7 +1600,7 @@ describe("MatrixClient", function() {
                 roomId: "!snafu:example.org",
             });
             expect(ruleRoomMatch).toBeTruthy();
-            expect(ruleRoomMatch.getContent()).toMatchObject({
+            expect(ruleRoomMatch!.getContent()).toMatchObject({
                 recommendation: "m.ban",
                 reason: REASON,
             });
@@ -1587,7 +1625,7 @@ describe("MatrixClient", function() {
                 roomId: BAD_ROOM_ID,
             });
             expect(ruleSenderMatch).toBeTruthy();
-            expect(ruleSenderMatch.getContent()).toMatchObject({
+            expect(ruleSenderMatch!.getContent()).toMatchObject({
                 recommendation: "m.ban",
                 reason: REASON,
             });
@@ -1621,7 +1659,7 @@ describe("MatrixClient", function() {
                 roomId: "!snafu:somewhere.org",
             });
             expect(ruleMatch).toBeTruthy();
-            expect(ruleMatch.getContent()).toMatchObject({
+            expect(ruleMatch!.getContent()).toMatchObject({
                 recommendation: "m.ban",
                 reason: "just a test",
             });
@@ -1649,13 +1687,13 @@ describe("MatrixClient", function() {
                 roomId: "!snafu:somewhere.org",
             });
             expect(ruleMatch).toBeTruthy();
-            expect(ruleMatch.getContent()).toMatchObject({
+            expect(ruleMatch!.getContent()).toMatchObject({
                 recommendation: "m.ban",
                 reason: "just a test",
             });
 
             // After removing the invite, we shouldn't reject it anymore.
-            await client.ignoredInvites.removeRule(ruleMatch);
+            await client.ignoredInvites.removeRule(ruleMatch as MatrixEvent);
             const ruleMatch2 = await client.ignoredInvites.getRuleForInvite({
                 sender: "@foobar:example.org",
                 roomId: "!snafu:somewhere.org",
@@ -1669,10 +1707,10 @@ describe("MatrixClient", function() {
             // Make sure that everything is initialized.
             await client.ignoredInvites.getOrCreateSourceRooms();
             await client.joinRoom(NEW_SOURCE_ROOM_ID);
-            const newSourceRoom = client.getRoom(NEW_SOURCE_ROOM_ID);
+            const newSourceRoom = client.getRoom(NEW_SOURCE_ROOM_ID) as WrappedRoom;
 
             // Fetch the list of sources and check that we do not have the new room yet.
-            const policies = await client.getAccountData(POLICIES_ACCOUNT_EVENT_TYPE.name).getContent();
+            const policies = await client.getAccountData(POLICIES_ACCOUNT_EVENT_TYPE.name)!.getContent();
             expect(policies).toBeTruthy();
             const ignoreInvites = policies[IGNORE_INVITES_ACCOUNT_EVENT_KEY.name];
             expect(ignoreInvites).toBeTruthy();
@@ -1686,7 +1724,7 @@ describe("MatrixClient", function() {
             expect(added2).toBe(false);
 
             // Fetch the list of sources and check that we have added the new room.
-            const policies2 = await client.getAccountData(POLICIES_ACCOUNT_EVENT_TYPE.name).getContent();
+            const policies2 = await client.getAccountData(POLICIES_ACCOUNT_EVENT_TYPE.name)!.getContent();
             expect(policies2).toBeTruthy();
             const ignoreInvites2 = policies2[IGNORE_INVITES_ACCOUNT_EVENT_KEY.name];
             expect(ignoreInvites2).toBeTruthy();
@@ -1698,7 +1736,7 @@ describe("MatrixClient", function() {
 
             // Check where it shows up.
             const targetRoomId = ignoreInvites2.target;
-            const targetRoom = client.getRoom(targetRoomId);
+            const targetRoom = client.getRoom(targetRoomId) as WrappedRoom;
             expect(targetRoom._state.get(PolicyScope.User)[eventId]).toBeTruthy();
             expect(newSourceRoom._state.get(PolicyScope.User)?.[eventId]).toBeFalsy();
         });
diff --git a/spec/unit/models/MSC3089TreeSpace.spec.ts b/spec/unit/models/MSC3089TreeSpace.spec.ts
index 4158ea8b9fe..ab39b907535 100644
--- a/spec/unit/models/MSC3089TreeSpace.spec.ts
+++ b/spec/unit/models/MSC3089TreeSpace.spec.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MatrixClient } from "../../../src";
+import { IContent, MatrixClient } from "../../../src";
 import { Room } from "../../../src/models/room";
 import { MatrixEvent } from "../../../src/models/event";
 import { EventType, MsgType, UNSTABLE_MSC3089_BRANCH, UNSTABLE_MSC3089_LEAF } from "../../../src/@types/event";
@@ -33,7 +33,7 @@ describe("MSC3089TreeSpace", () => {
     const roomId = "!tree:localhost";
     const targetUser = "@target:example.org";
 
-    let powerLevels;
+    let powerLevels: MatrixEvent;
 
     beforeEach(() => {
         // TODO: Use utility functions to create test rooms and clients
@@ -480,7 +480,7 @@ describe("MSC3089TreeSpace", () => {
         const staticDomain = "static.example.org";
 
         function addSubspace(roomId: string, createTs?: number, order?: string) {
-            const content = {
+            const content: IContent = {
                 via: [staticDomain],
             };
             if (order) content['order'] = order;
diff --git a/spec/unit/models/event.spec.ts b/spec/unit/models/event.spec.ts
index 535e0f12db6..92d929fd4e7 100644
--- a/spec/unit/models/event.spec.ts
+++ b/spec/unit/models/event.spec.ts
@@ -121,7 +121,7 @@ describe('MatrixEvent', () => {
     });
 
     describe(".attemptDecryption", () => {
-        let encryptedEvent;
+        let encryptedEvent: MatrixEvent;
         const eventId = 'test_encrypted_event';
 
         beforeEach(() => {
@@ -155,7 +155,7 @@ describe('MatrixEvent', () => {
                             },
                         });
                     }),
-            };
+            } as unknown as Crypto;
 
             await encryptedEvent.attemptDecryption(crypto);
 
diff --git a/spec/unit/notifications.spec.ts b/spec/unit/notifications.spec.ts
index e7e637d4acc..02388f9f0dd 100644
--- a/spec/unit/notifications.spec.ts
+++ b/spec/unit/notifications.spec.ts
@@ -39,7 +39,7 @@ let threadEvent: MatrixEvent;
 const ROOM_ID = "!roomId:example.org";
 let THREAD_ID: string;
 
-function mkPushAction(notify, highlight): IActionsObject {
+function mkPushAction(notify: boolean, highlight: boolean): IActionsObject {
     return {
         notify,
         tweaks: {
diff --git a/spec/unit/read-receipt.spec.ts b/spec/unit/read-receipt.spec.ts
index 4443c25befc..df902d13b1c 100644
--- a/spec/unit/read-receipt.spec.ts
+++ b/spec/unit/read-receipt.spec.ts
@@ -70,7 +70,7 @@ const roomEvent = utils.mkEvent({
     },
 });
 
-function mockServerSideSupport(client, serverSideSupport: ServerSupport) {
+function mockServerSideSupport(client: MatrixClient, serverSideSupport: ServerSupport) {
     client.canSupport.set(Feature.ThreadUnreadNotifications, serverSideSupport);
 }
 
diff --git a/spec/unit/realtime-callbacks.spec.ts b/spec/unit/realtime-callbacks.spec.ts
index dd0d605a0cc..dfbbfc9f77a 100644
--- a/spec/unit/realtime-callbacks.spec.ts
+++ b/spec/unit/realtime-callbacks.spec.ts
@@ -20,7 +20,7 @@ let wallTime = 1234567890;
 jest.useFakeTimers().setSystemTime(wallTime);
 
 describe("realtime-callbacks", function() {
-    function tick(millis) {
+    function tick(millis: number): void {
         wallTime += millis;
         jest.advanceTimersByTime(millis);
     }
diff --git a/spec/unit/rendezvous/rendezvous.spec.ts b/spec/unit/rendezvous/rendezvous.spec.ts
index 2e0f492c046..bca7385982b 100644
--- a/spec/unit/rendezvous/rendezvous.spec.ts
+++ b/spec/unit/rendezvous/rendezvous.spec.ts
@@ -87,7 +87,7 @@ describe("Rendezvous", function() {
     });
 
     let httpBackend: MockHttpBackend;
-    let fetchFn: typeof global.fetchFn;
+    let fetchFn: typeof global.fetch;
     let transports: DummyTransport<any, MSC3903ECDHPayload>[];
 
     beforeEach(function() {
diff --git a/spec/unit/room-member.spec.ts b/spec/unit/room-member.spec.ts
index 8eb3096b60e..0ed96339bc2 100644
--- a/spec/unit/room-member.spec.ts
+++ b/spec/unit/room-member.spec.ts
@@ -373,37 +373,36 @@ describe("RoomMember", function() {
                 expect(member.events.member).toEqual(joinEvent);
             });
 
-        it("should set 'name' based on user_id, displayname and room state",
-            function() {
-                const roomState = {
-                    getStateEvents: function(type) {
-                        if (type !== "m.room.member") {
-                            return [];
-                        }
-                        return [
-                            utils.mkMembership({
-                                event: true, mship: "join", room: roomId,
-                                user: userB,
-                            }),
-                            utils.mkMembership({
-                                event: true, mship: "join", room: roomId,
-                                user: userC, name: "Alice",
-                            }),
-                            joinEvent,
-                        ];
-                    },
-                    getUserIdsWithDisplayName: function(displayName) {
-                        return [userA, userC];
-                    },
-                } as unknown as RoomState;
-                expect(member.name).toEqual(userA); // default = user_id
-                member.setMembershipEvent(joinEvent);
-                expect(member.name).toEqual("Alice"); // prefer displayname
-                member.setMembershipEvent(joinEvent, roomState);
-                expect(member.name).not.toEqual("Alice"); // it should disambig.
-                // user_id should be there somewhere
-                expect(member.name.indexOf(userA)).not.toEqual(-1);
-            });
+        it("should set 'name' based on user_id, displayname and room state", function() {
+            const roomState = {
+                getStateEvents: function(type: string) {
+                    if (type !== "m.room.member") {
+                        return [];
+                    }
+                    return [
+                        utils.mkMembership({
+                            event: true, mship: "join", room: roomId,
+                            user: userB,
+                        }),
+                        utils.mkMembership({
+                            event: true, mship: "join", room: roomId,
+                            user: userC, name: "Alice",
+                        }),
+                        joinEvent,
+                    ];
+                },
+                getUserIdsWithDisplayName: function(displayName: string) {
+                    return [userA, userC];
+                },
+            } as unknown as RoomState;
+            expect(member.name).toEqual(userA); // default = user_id
+            member.setMembershipEvent(joinEvent);
+            expect(member.name).toEqual("Alice"); // prefer displayname
+            member.setMembershipEvent(joinEvent, roomState);
+            expect(member.name).not.toEqual("Alice"); // it should disambig.
+            // user_id should be there somewhere
+            expect(member.name.indexOf(userA)).not.toEqual(-1);
+        });
 
         it("should emit 'RoomMember.membership' if the membership changes", function() {
             let emitCount = 0;
@@ -455,7 +454,7 @@ describe("RoomMember", function() {
             });
 
             const roomState = {
-                getStateEvents: function(type) {
+                getStateEvents: function(type: string) {
                     if (type !== "m.room.member") {
                         return [];
                     }
@@ -467,7 +466,7 @@ describe("RoomMember", function() {
                         joinEvent,
                     ];
                 },
-                getUserIdsWithDisplayName: function(displayName) {
+                getUserIdsWithDisplayName: function(displayName: string) {
                     return [userA, userC];
                 },
             } as unknown as RoomState;
diff --git a/spec/unit/room.spec.ts b/spec/unit/room.spec.ts
index f6199570325..c820f37a074 100644
--- a/spec/unit/room.spec.ts
+++ b/spec/unit/room.spec.ts
@@ -19,27 +19,32 @@ limitations under the License.
  * @module client
  */
 
+import { mocked } from "jest-mock";
+
 import * as utils from "../test-utils/test-utils";
+import { emitPromise } from "../test-utils/test-utils";
 import {
+    Direction,
     DuplicateStrategy,
     EventStatus,
     EventTimelineSet,
-    EventType, IStateEventWithRoomId,
+    EventType, IContent,
+    IStateEventWithRoomId,
     JoinRule,
     MatrixEvent,
     MatrixEventEvent,
     PendingEventOrdering,
     RelationType,
     RoomEvent,
+    RoomMember,
 } from "../../src";
 import { EventTimeline } from "../../src/models/event-timeline";
 import { NotificationCountType, Room } from "../../src/models/room";
 import { RoomState } from "../../src/models/room-state";
 import { UNSTABLE_ELEMENT_FUNCTIONAL_USERS } from "../../src/@types/event";
 import { TestClient } from "../TestClient";
-import { emitPromise } from "../test-utils/test-utils";
 import { ReceiptType, WrappedReceipt } from "../../src/@types/read_receipts";
-import { FeatureSupport, Thread, ThreadEvent, THREAD_RELATION_TYPE } from "../../src/models/thread";
+import { FeatureSupport, Thread, THREAD_RELATION_TYPE, ThreadEvent } from "../../src/models/thread";
 import { Crypto } from "../../src/crypto";
 
 describe("Room", function() {
@@ -48,7 +53,7 @@ describe("Room", function() {
     const userB = "@bertha:bar";
     const userC = "@clarissa:bar";
     const userD = "@dorothy:bar";
-    let room;
+    let room: Room;
 
     const mkMessage = () => utils.mkMessage({
         event: true,
@@ -131,13 +136,16 @@ describe("Room", function() {
     beforeEach(function() {
         room = new Room(roomId, new TestClient(userA, "device").client, userA);
         // mock RoomStates
+        // @ts-ignore
         room.oldState = room.getLiveTimeline().startState = utils.mock(RoomState, "oldState");
+        // @ts-ignore
         room.currentState = room.getLiveTimeline().endState = utils.mock(RoomState, "currentState");
     });
 
     describe('getCreator', () => {
         it("should return the creator from m.room.create", function() {
-            room.currentState.getStateEvents.mockImplementation(function(type, key) {
+            // @ts-ignore - mocked doesn't handle overloads sanely
+            mocked(room.currentState.getStateEvents).mockImplementation(function(type, key) {
                 if (type === EventType.RoomCreate && key === "") {
                     return utils.mkEvent({
                         event: true,
@@ -160,7 +168,8 @@ describe("Room", function() {
         const hsUrl = "https://my.home.server";
 
         it("should return the URL from m.room.avatar preferentially", function() {
-            room.currentState.getStateEvents.mockImplementation(function(type, key) {
+            // @ts-ignore - mocked doesn't handle overloads sanely
+            mocked(room.currentState.getStateEvents).mockImplementation(function(type, key) {
                 if (type === EventType.RoomAvatar && key === "") {
                     return utils.mkEvent({
                         event: true,
@@ -174,10 +183,10 @@ describe("Room", function() {
                     });
                 }
             });
-            const url = room.getAvatarUrl(hsUrl);
+            const url = room.getAvatarUrl(hsUrl, 100, 100, "scale");
             // we don't care about how the mxc->http conversion is done, other
             // than it contains the mxc body.
-            expect(url.indexOf("flibble/wibble")).not.toEqual(-1);
+            expect(url?.indexOf("flibble/wibble")).not.toEqual(-1);
         });
 
         it("should return nothing if there is no m.room.avatar and allowDefault=false",
@@ -189,12 +198,12 @@ describe("Room", function() {
 
     describe("getMember", function() {
         beforeEach(function() {
-            room.currentState.getMember.mockImplementation(function(userId) {
+            mocked(room.currentState.getMember).mockImplementation(function(userId) {
                 return {
                     "@alice:bar": {
                         userId: userA,
                         roomId: roomId,
-                    },
+                    } as unknown as RoomMember,
                 }[userId] || null;
             });
         });
@@ -222,11 +231,13 @@ describe("Room", function() {
         it("Make sure legacy overload passing options directly as parameters still works", () => {
             expect(() => room.addLiveEvents(events, DuplicateStrategy.Replace, false)).not.toThrow();
             expect(() => room.addLiveEvents(events, DuplicateStrategy.Ignore, true)).not.toThrow();
+            // @ts-ignore
             expect(() => room.addLiveEvents(events, "shouldfailbecauseinvalidduplicatestrategy", false)).toThrow();
         });
 
         it("should throw if duplicateStrategy isn't 'replace' or 'ignore'", function() {
             expect(function() {
+                // @ts-ignore
                 room.addLiveEvents(events, {
                     duplicateStrategy: "foo",
                 });
@@ -255,6 +266,7 @@ describe("Room", function() {
             dupe.event.event_id = events[0].getId();
             room.addLiveEvents(events);
             expect(room.timeline[0]).toEqual(events[0]);
+            // @ts-ignore
             room.addLiveEvents([dupe], {
                 duplicateStrategy: "ignore",
             });
@@ -263,7 +275,7 @@ describe("Room", function() {
 
         it("should emit 'Room.timeline' events", function() {
             let callCount = 0;
-            room.on("Room.timeline", function(event, emitRoom, toStart) {
+            room.on(RoomEvent.Timeline, function(event, emitRoom, toStart) {
                 callCount += 1;
                 expect(room.timeline.length).toEqual(callCount);
                 expect(event).toEqual(events[callCount - 1]);
@@ -306,8 +318,8 @@ describe("Room", function() {
                 userId: userA,
                 membership: "join",
                 name: "Alice",
-            };
-            room.currentState.getSentinelMember.mockImplementation(function(uid) {
+            } as unknown as RoomMember;
+            mocked(room.currentState.getSentinelMember).mockImplementation(function(uid) {
                 if (uid === userA) {
                     return sentinel;
                 }
@@ -331,27 +343,25 @@ describe("Room", function() {
             const remoteEventId = remoteEvent.getId();
 
             let callCount = 0;
-            room.on("Room.localEchoUpdated",
-                function(event, emitRoom, oldEventId, oldStatus) {
-                    switch (callCount) {
-                        case 0:
-                            expect(event.getId()).toEqual(localEventId);
-                            expect(event.status).toEqual(EventStatus.SENDING);
-                            expect(emitRoom).toEqual(room);
-                            expect(oldEventId).toBeUndefined();
-                            expect(oldStatus).toBeUndefined();
-                            break;
-                        case 1:
-                            expect(event.getId()).toEqual(remoteEventId);
-                            expect(event.status).toBeNull();
-                            expect(emitRoom).toEqual(room);
-                            expect(oldEventId).toEqual(localEventId);
-                            expect(oldStatus).toBe(EventStatus.SENDING);
-                            break;
-                    }
-                    callCount += 1;
-                },
-            );
+            room.on(RoomEvent.LocalEchoUpdated, (event, emitRoom, oldEventId, oldStatus) => {
+                switch (callCount) {
+                    case 0:
+                        expect(event.getId()).toEqual(localEventId);
+                        expect(event.status).toEqual(EventStatus.SENDING);
+                        expect(emitRoom).toEqual(room);
+                        expect(oldEventId).toBeUndefined();
+                        expect(oldStatus).toBeUndefined();
+                        break;
+                    case 1:
+                        expect(event.getId()).toEqual(remoteEventId);
+                        expect(event.status).toBeNull();
+                        expect(emitRoom).toEqual(room);
+                        expect(oldEventId).toEqual(localEventId);
+                        expect(oldStatus).toBe(EventStatus.SENDING);
+                        break;
+                }
+                callCount += 1;
+            });
 
             // first add the local echo
             room.addPendingEvent(localEvent, "TXN_ID");
@@ -367,7 +377,7 @@ describe("Room", function() {
         it("should be able to update local echo without a txn ID (/send then /sync)", function() {
             const eventJson = utils.mkMessage({
                 room: roomId, user: userA, event: false,
-            }) as object;
+            });
             delete eventJson["txn_id"];
             delete eventJson["event_id"];
             const localEvent = new MatrixEvent(Object.assign({ event_id: "$temp" }, eventJson));
@@ -398,7 +408,7 @@ describe("Room", function() {
         it("should be able to update local echo without a txn ID (/sync then /send)", function() {
             const eventJson = utils.mkMessage({
                 room: roomId, user: userA, event: false,
-            }) as object;
+            });
             delete eventJson["txn_id"];
             delete eventJson["event_id"];
             const txnId = "My_txn_id";
@@ -483,7 +493,7 @@ describe("Room", function() {
         it("should emit 'Room.timeline' events when added to the start",
             function() {
                 let callCount = 0;
-                room.on("Room.timeline", function(event, emitRoom, toStart) {
+                room.on(RoomEvent.Timeline, function(event, emitRoom, toStart) {
                     callCount += 1;
                     expect(room.timeline.length).toEqual(callCount);
                     expect(event).toEqual(events[callCount - 1]);
@@ -501,19 +511,19 @@ describe("Room", function() {
                 userId: userA,
                 membership: "join",
                 name: "Alice",
-            };
+            } as unknown as RoomMember;
             const oldSentinel = {
                 userId: userA,
                 membership: "join",
                 name: "Old Alice",
-            };
-            room.currentState.getSentinelMember.mockImplementation(function(uid) {
+            } as unknown as RoomMember;
+            mocked(room.currentState.getSentinelMember).mockImplementation(function(uid) {
                 if (uid === userA) {
                     return sentinel;
                 }
                 return null;
             });
-            room.oldState.getSentinelMember.mockImplementation(function(uid) {
+            mocked(room.oldState.getSentinelMember).mockImplementation(function(uid) {
                 if (uid === userA) {
                     return oldSentinel;
                 }
@@ -539,19 +549,19 @@ describe("Room", function() {
                 userId: userA,
                 membership: "join",
                 name: "Alice",
-            };
+            } as unknown as RoomMember;
             const oldSentinel = {
                 userId: userA,
                 membership: "join",
                 name: "Old Alice",
-            };
-            room.currentState.getSentinelMember.mockImplementation(function(uid) {
+            } as unknown as RoomMember;
+            mocked(room.currentState.getSentinelMember).mockImplementation(function(uid) {
                 if (uid === userA) {
                     return sentinel;
                 }
                 return null;
             });
-            room.oldState.getSentinelMember.mockImplementation(function(uid) {
+            mocked(room.oldState.getSentinelMember).mockImplementation(function(uid) {
                 if (uid === userA) {
                     return oldSentinel;
                 }
@@ -599,7 +609,7 @@ describe("Room", function() {
         });
     });
 
-    const resetTimelineTests = function(timelineSupport) {
+    const resetTimelineTests = function(timelineSupport: boolean) {
         let events: MatrixEvent[];
 
         beforeEach(function() {
@@ -630,8 +640,8 @@ describe("Room", function() {
             const oldState = room.getLiveTimeline().getState(EventTimeline.BACKWARDS);
             const newState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);
             expect(room.getLiveTimeline().getEvents().length).toEqual(1);
-            expect(oldState.getStateEvents(EventType.RoomName, "")).toEqual(events[1]);
-            expect(newState.getStateEvents(EventType.RoomName, "")).toEqual(events[2]);
+            expect(oldState?.getStateEvents(EventType.RoomName, "")).toEqual(events[1]);
+            expect(newState?.getStateEvents(EventType.RoomName, "")).toEqual(events[2]);
         });
 
         it("should reset the legacy timeline fields", function() {
@@ -669,17 +679,14 @@ describe("Room", function() {
             expect(currentStateUpdateEmitCount).toEqual(timelineSupport ? 1 : 0);
         });
 
-        it("should emit Room.timelineReset event and set the correct " +
-                 "pagination token", function() {
+        it("should emit Room.timelineReset event and set the correct pagination token", function() {
             let callCount = 0;
-            room.on("Room.timelineReset", function(emitRoom) {
+            room.on(RoomEvent.TimelineReset, function(emitRoom) {
                 callCount += 1;
                 expect(emitRoom).toEqual(room);
 
-                // make sure that the pagination token has been set before the
-                // event is emitted.
-                const tok = emitRoom.getLiveTimeline()
-                    .getPaginationToken(EventTimeline.BACKWARDS);
+                // make sure that the pagination token has been set before the event is emitted.
+                const tok = emitRoom?.getLiveTimeline().getPaginationToken(EventTimeline.BACKWARDS);
 
                 expect(tok).toEqual("pagToken");
             });
@@ -693,7 +700,7 @@ describe("Room", function() {
             const firstLiveTimeline = room.getLiveTimeline();
             room.resetLiveTimeline('sometoken', 'someothertoken');
 
-            const tl = room.getTimelineForEvent(events[0].getId());
+            const tl = room.getTimelineForEvent(events[0].getId()!);
             expect(tl).toBe(timelineSupport ? firstLiveTimeline : null);
         });
     };
@@ -721,30 +728,25 @@ describe("Room", function() {
         it("should handle events in the same timeline", function() {
             room.addLiveEvents(events);
 
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!,
-                events[1].getId()))
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!))
                 .toBeLessThan(0);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[2].getId()!,
-                events[1].getId()))
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[2].getId()!, events[1].getId()!))
                 .toBeGreaterThan(0);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!,
-                events[1].getId()))
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[1].getId()!))
                 .toEqual(0);
         });
 
         it("should handle events in adjacent timelines", function() {
             const oldTimeline = room.addTimeline();
-            oldTimeline.setNeighbouringTimeline(room.getLiveTimeline(), 'f');
-            room.getLiveTimeline().setNeighbouringTimeline(oldTimeline, 'b');
+            oldTimeline.setNeighbouringTimeline(room.getLiveTimeline(), Direction.Forward);
+            room.getLiveTimeline().setNeighbouringTimeline(oldTimeline, Direction.Backward);
 
             room.addEventsToTimeline([events[0]], false, oldTimeline);
             room.addLiveEvents([events[1]]);
 
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!,
-                events[1].getId()))
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!))
                 .toBeLessThan(0);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!,
-                events[0].getId()))
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[0].getId()!))
                 .toBeGreaterThan(0);
         });
 
@@ -754,11 +756,9 @@ describe("Room", function() {
             room.addEventsToTimeline([events[0]], false, oldTimeline);
             room.addLiveEvents([events[1]]);
 
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!,
-                events[1].getId()))
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!))
                 .toBe(null);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!,
-                events[0].getId()))
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[0].getId()!))
                 .toBe(null);
         });
 
@@ -769,21 +769,21 @@ describe("Room", function() {
                 .compareEventOrdering(events[0].getId()!, "xxx"))
                 .toBe(null);
             expect(room.getUnfilteredTimelineSet()
-                .compareEventOrdering("xxx", events[0].getId()))
+                .compareEventOrdering("xxx", events[0].getId()!))
                 .toBe(null);
             expect(room.getUnfilteredTimelineSet()
-                .compareEventOrdering(events[0].getId()!, events[0].getId()))
+                .compareEventOrdering(events[0].getId()!, events[0].getId()!))
                 .toBe(0);
         });
     });
 
     describe("getJoinedMembers", function() {
         it("should return members whose membership is 'join'", function() {
-            room.currentState.getMembers.mockImplementation(function() {
+            mocked(room.currentState.getMembers).mockImplementation(function() {
                 return [
-                    { userId: "@alice:bar", membership: "join" },
-                    { userId: "@bob:bar", membership: "invite" },
-                    { userId: "@cleo:bar", membership: "leave" },
+                    { userId: "@alice:bar", membership: "join" } as unknown as RoomMember,
+                    { userId: "@bob:bar", membership: "invite" } as unknown as RoomMember,
+                    { userId: "@cleo:bar", membership: "leave" } as unknown as RoomMember,
                 ];
             });
             const res = room.getJoinedMembers();
@@ -792,9 +792,9 @@ describe("Room", function() {
         });
 
         it("should return an empty list if no membership is 'join'", function() {
-            room.currentState.getMembers.mockImplementation(function() {
+            mocked(room.currentState.getMembers).mockImplementation(function() {
                 return [
-                    { userId: "@bob:bar", membership: "invite" },
+                    { userId: "@bob:bar", membership: "invite" } as unknown as RoomMember,
                 ];
             });
             const res = room.getJoinedMembers();
@@ -805,41 +805,41 @@ describe("Room", function() {
     describe("hasMembershipState", function() {
         it("should return true for a matching userId and membership",
             function() {
-                room.currentState.getMember.mockImplementation(function(userId) {
+                mocked(room.currentState.getMember).mockImplementation(function(userId) {
                     return {
                         "@alice:bar": { userId: "@alice:bar", membership: "join" },
                         "@bob:bar": { userId: "@bob:bar", membership: "invite" },
-                    }[userId];
+                    }[userId] as unknown as RoomMember;
                 });
                 expect(room.hasMembershipState("@bob:bar", "invite")).toBe(true);
             });
 
         it("should return false if match membership but no match userId",
             function() {
-                room.currentState.getMember.mockImplementation(function(userId) {
+                mocked(room.currentState.getMember).mockImplementation(function(userId) {
                     return {
                         "@alice:bar": { userId: "@alice:bar", membership: "join" },
-                    }[userId];
+                    }[userId] as unknown as RoomMember;
                 });
                 expect(room.hasMembershipState("@bob:bar", "join")).toBe(false);
             });
 
         it("should return false if match userId but no match membership",
             function() {
-                room.currentState.getMember.mockImplementation(function(userId) {
+                mocked(room.currentState.getMember).mockImplementation(function(userId) {
                     return {
                         "@alice:bar": { userId: "@alice:bar", membership: "join" },
-                    }[userId];
+                    }[userId] as unknown as RoomMember;
                 });
                 expect(room.hasMembershipState("@alice:bar", "ban")).toBe(false);
             });
 
         it("should return false if no match membership or userId",
             function() {
-                room.currentState.getMember.mockImplementation(function(userId) {
+                mocked(room.currentState.getMember).mockImplementation(function(userId) {
                     return {
                         "@alice:bar": { userId: "@alice:bar", membership: "join" },
-                    }[userId];
+                    }[userId] as unknown as RoomMember;
                 });
                 expect(room.hasMembershipState("@bob:bar", "invite")).toBe(false);
             });
@@ -1193,8 +1193,8 @@ describe("Room", function() {
             event: true,
         });
 
-        function mkReceipt(roomId: string, records) {
-            const content = {};
+        function mkReceipt(roomId: string, records: Array<ReturnType<typeof mkRecord>>) {
+            const content: IContent = {};
             records.forEach(function(r) {
                 if (!content[r.eventId]) {
                     content[r.eventId] = {};
@@ -1241,7 +1241,7 @@ describe("Room", function() {
             it("should emit an event when a receipt is added",
                 function() {
                     const listener = jest.fn();
-                    room.on("Room.receipt", listener);
+                    room.on(RoomEvent.Receipt, listener);
 
                     const ts = 13787898424;
 
@@ -1448,7 +1448,7 @@ describe("Room", function() {
     });
 
     describe("tags", function() {
-        function mkTags(roomId, tags) {
+        function mkTags(roomId: string, tags: object) {
             const content = { "tags": tags };
             return new MatrixEvent({
                 content: content,
@@ -1470,7 +1470,7 @@ describe("Room", function() {
                "received on the event stream",
             function() {
                 const listener = jest.fn();
-                room.on("Room.tags", listener);
+                room.on(RoomEvent.Tags, listener);
 
                 const tags = { "m.foo": { "order": 0.5 } };
                 const event = mkTags(roomId, tags);
@@ -1642,11 +1642,14 @@ describe("Room", function() {
     });
 
     describe("loadMembersIfNeeded", function() {
-        function createClientMock(serverResponse, storageResponse: MatrixEvent[] | Error | null = null) {
+        function createClientMock(
+            serverResponse: Error | MatrixEvent[],
+            storageResponse: MatrixEvent[] | Error | null = null,
+        ) {
             return {
                 getEventMapper: function() {
                     // events should already be MatrixEvents
-                    return function(event) {return event;};
+                    return function(event: MatrixEvent) {return event;};
                 },
                 isCryptoEnabled() {
                     return true;
@@ -1671,7 +1674,7 @@ describe("Room", function() {
                             return Promise.resolve(this.storageResponse);
                         }
                     },
-                    setOutOfBandMembers: function(roomId, memberEvents) {
+                    setOutOfBandMembers: function(roomId: string, memberEvents: IStateEventWithRoomId[]) {
                         this.storedMembers = memberEvents;
                         return Promise.resolve();
                     },
@@ -2170,7 +2173,7 @@ describe("Room", function() {
                 },
             });
 
-            room.createThread("$000", undefined, [eventWithoutARootEvent]);
+            room.createThread("$000", undefined, [eventWithoutARootEvent], false);
 
             const rootEvent = new MatrixEvent({
                 event_id: "$666",
@@ -2188,7 +2191,7 @@ describe("Room", function() {
                 },
             });
 
-            expect(() => room.createThread(rootEvent.getId()!, rootEvent, [])).not.toThrow();
+            expect(() => room.createThread(rootEvent.getId()!, rootEvent, [], false)).not.toThrow();
         });
 
         it("creating thread from edited event should not conflate old versions of the event", () => {
@@ -2406,8 +2409,6 @@ describe("Room", function() {
             Thread.setServerSideListSupport(FeatureSupport.Stable);
 
             room.client.createThreadListMessagesRequest = () => Promise.resolve({
-                start: null,
-                end: null,
                 chunk: [],
                 state: [],
             });
@@ -2761,7 +2762,7 @@ describe("Room", function() {
     });
 
     describe("thread notifications", () => {
-        let room;
+        let room: Room;
 
         beforeEach(() => {
             const client = new TestClient(userA).client;
diff --git a/spec/unit/scheduler.spec.ts b/spec/unit/scheduler.spec.ts
index 59c2d0a1d45..2e7dcf30898 100644
--- a/spec/unit/scheduler.spec.ts
+++ b/spec/unit/scheduler.spec.ts
@@ -1,18 +1,19 @@
 // This file had a function whose name is all caps, which displeases eslint
 /* eslint new-cap: "off" */
 
-import { defer } from '../../src/utils';
+import { defer, IDeferred } from '../../src/utils';
 import { MatrixError } from "../../src/http-api";
 import { MatrixScheduler } from "../../src/scheduler";
 import * as utils from "../test-utils/test-utils";
+import { MatrixEvent } from "../../src";
 
 jest.useFakeTimers();
 
 describe("MatrixScheduler", function() {
-    let scheduler;
-    let retryFn;
-    let queueFn;
-    let deferred;
+    let scheduler: MatrixScheduler<Record<string, boolean>>;
+    let retryFn: Function | null;
+    let queueFn: ((event: MatrixEvent) => string | null) | null;
+    let deferred: IDeferred<Record<string, boolean>>;
     const roomId = "!foo:bar";
     const eventA = utils.mkMessage({
         user: "@alice:bar", room: roomId, event: true,
@@ -65,8 +66,8 @@ describe("MatrixScheduler", function() {
         deferB.resolve({ b: true });
         deferA.resolve({ a: true });
         const [a, b] = await abPromise;
-        expect(a.a).toEqual(true);
-        expect(b.b).toEqual(true);
+        expect(a!.a).toEqual(true);
+        expect(b!.b).toEqual(true);
     });
 
     it("should invoke the retryFn on failure and wait the amount of time specified",
@@ -92,6 +93,7 @@ describe("MatrixScheduler", function() {
                     return new Promise(() => {});
                 }
                 expect(procCount).toBeLessThan(3);
+                return new Promise(() => {});
             });
 
             scheduler.queueEvent(eventA);
@@ -119,8 +121,8 @@ describe("MatrixScheduler", function() {
                 return "yep";
             };
 
-            const deferA = defer();
-            const deferB = defer();
+            const deferA = defer<Record<string, boolean>>();
+            const deferB = defer<Record<string, boolean>>();
             let procCount = 0;
             scheduler.setProcessFunction(function(ev) {
                 procCount += 1;
@@ -132,6 +134,7 @@ describe("MatrixScheduler", function() {
                     return deferB.promise;
                 }
                 expect(procCount).toBeLessThan(3);
+                return new Promise<Record<string, boolean>>(() => {});
             });
 
             const globalA = scheduler.queueEvent(eventA);
@@ -159,7 +162,7 @@ describe("MatrixScheduler", function() {
         const eventC = utils.mkMessage({ user: "@a:bar", room: roomId, event: true });
         const eventD = utils.mkMessage({ user: "@b:bar", room: roomId, event: true });
 
-        const buckets = {};
+        const buckets: Record<string, string> = {};
         buckets[eventA.getId()!] = "queue_A";
         buckets[eventD.getId()!] = "queue_A";
         buckets[eventB.getId()!] = "queue_B";
@@ -169,13 +172,13 @@ describe("MatrixScheduler", function() {
             return 0;
         };
         queueFn = function(event) {
-            return buckets[event.getId()];
+            return buckets[event.getId()!];
         };
 
         const expectOrder = [
             eventA.getId(), eventB.getId(), eventD.getId(),
         ];
-        const deferA = defer<void>();
+        const deferA = defer<Record<string, boolean>>();
         scheduler.setProcessFunction(function(event) {
             const id = expectOrder.shift();
             expect(id).toEqual(event.getId());
@@ -191,7 +194,7 @@ describe("MatrixScheduler", function() {
 
         // wait a bit then resolve A and we should get D (not C) next.
         setTimeout(function() {
-            deferA.resolve();
+            deferA.resolve({});
         }, 1000);
         jest.advanceTimersByTime(1000);
     });
@@ -210,7 +213,7 @@ describe("MatrixScheduler", function() {
             };
             const prom = scheduler.queueEvent(eventA);
             expect(prom).toBeTruthy();
-            expect(prom.then).toBeTruthy();
+            expect(prom!.then).toBeTruthy();
         });
     });
 
@@ -237,15 +240,15 @@ describe("MatrixScheduler", function() {
             scheduler.queueEvent(eventA);
             scheduler.queueEvent(eventB);
             const queue = scheduler.getQueueForEvent(eventA);
-            expect(queue.length).toEqual(2);
+            expect(queue).toHaveLength(2);
             expect(queue).toEqual([eventA, eventB]);
             // modify the queue
             const eventC = utils.mkMessage(
                 { user: "@a:bar", room: roomId, event: true },
             );
-            queue.push(eventC);
+            queue!.push(eventC);
             const queueAgain = scheduler.getQueueForEvent(eventA);
-            expect(queueAgain.length).toEqual(2);
+            expect(queueAgain).toHaveLength(2);
         });
 
         it("should return a list of events in the queue and modifications to" +
@@ -255,10 +258,10 @@ describe("MatrixScheduler", function() {
             };
             scheduler.queueEvent(eventA);
             scheduler.queueEvent(eventB);
-            const queue = scheduler.getQueueForEvent(eventA);
-            queue[1].event.content.body = "foo";
-            const queueAgain = scheduler.getQueueForEvent(eventA);
-            expect(queueAgain[1].event.content.body).toEqual("foo");
+            const queue = scheduler.getQueueForEvent(eventA)!;
+            queue[1].event.content!.body = "foo";
+            const queueAgain = scheduler.getQueueForEvent(eventA)!;
+            expect(queueAgain[1].event.content?.body).toEqual("foo");
         });
     });
 
diff --git a/spec/unit/sync-accumulator.spec.ts b/spec/unit/sync-accumulator.spec.ts
index 2e1ec58b60c..9a72a6b3397 100644
--- a/spec/unit/sync-accumulator.spec.ts
+++ b/spec/unit/sync-accumulator.spec.ts
@@ -16,7 +16,8 @@ limitations under the License.
 */
 
 import { ReceiptType } from "../../src/@types/read_receipts";
-import { SyncAccumulator } from "../../src/sync-accumulator";
+import { IJoinedRoom, ISyncResponse, SyncAccumulator } from "../../src/sync-accumulator";
+import { IRoomSummary } from "../../src";
 
 // The event body & unsigned object get frozen to assert that they don't get altered
 // by the impl
@@ -55,10 +56,10 @@ const RES_WITH_AGE = {
             },
         },
     },
-};
+} as unknown as ISyncResponse;
 
 describe("SyncAccumulator", function() {
-    let sa;
+    let sa: SyncAccumulator;
 
     beforeEach(function() {
         sa = new SyncAccumulator({
@@ -98,7 +99,7 @@ describe("SyncAccumulator", function() {
                     },
                 },
             },
-        };
+        } as unknown as ISyncResponse;
         sa.accumulate(res);
         const output = sa.getJSON();
         expect(output.nextBatch).toEqual(res.next_batch);
@@ -223,7 +224,6 @@ describe("SyncAccumulator", function() {
                     content: {
                         user_ids: ["@alice:localhost"],
                     },
-                    room_id: "!foo:bar",
                 }],
             },
         });
@@ -281,12 +281,12 @@ describe("SyncAccumulator", function() {
             account_data: {
                 events: [acc1],
             },
-        });
+        } as unknown as ISyncResponse);
         sa.accumulate({
             account_data: {
                 events: [acc2],
             },
-        });
+        } as unknown as ISyncResponse);
         expect(
             sa.getJSON().accountData.length,
         ).toEqual(1);
@@ -422,7 +422,7 @@ describe("SyncAccumulator", function() {
     });
 
     describe("summary field", function() {
-        function createSyncResponseWithSummary(summary) {
+        function createSyncResponseWithSummary(summary: IRoomSummary): ISyncResponse {
             return {
                 next_batch: "abc",
                 rooms: {
@@ -444,7 +444,7 @@ describe("SyncAccumulator", function() {
                         },
                     },
                 },
-            };
+            } as unknown as ISyncResponse;
         }
 
         afterEach(() => {
@@ -487,8 +487,8 @@ describe("SyncAccumulator", function() {
             jest.spyOn(global.Date, 'now').mockReturnValue(startingTs + delta);
 
             const output = sa.getJSON();
-            expect(output.roomsData.join["!foo:bar"].timeline.events[0].unsigned.age).toEqual(
-                RES_WITH_AGE.rooms.join["!foo:bar"].timeline.events[0].unsigned.age + delta,
+            expect(output.roomsData.join["!foo:bar"].timeline.events[0].unsigned?.age).toEqual(
+                RES_WITH_AGE.rooms.join["!foo:bar"].timeline.events[0].unsigned!.age! + delta,
             );
             expect(Object.keys(output.roomsData.join["!foo:bar"].timeline.events[0])).toEqual(
                 Object.keys(RES_WITH_AGE.rooms.join["!foo:bar"].timeline.events[0]),
@@ -507,12 +507,12 @@ describe("SyncAccumulator", function() {
             sa.accumulate(RES_WITH_AGE);
             const output = sa.getJSON();
             expect(output.roomsData.join["!foo:bar"]
-                .unread_thread_notifications["$143273582443PhrSn:example.org"]).not.toBeUndefined();
+                .unread_thread_notifications!["$143273582443PhrSn:example.org"]).not.toBeUndefined();
         });
     });
 });
 
-function syncSkeleton(joinObj) {
+function syncSkeleton(joinObj: Partial<IJoinedRoom>): ISyncResponse {
     joinObj = joinObj || {};
     return {
         next_batch: "abc",
@@ -521,11 +521,12 @@ function syncSkeleton(joinObj) {
                 "!foo:bar": joinObj,
             },
         },
-    };
+    } as unknown as ISyncResponse;
 }
 
-function msg(localpart, text) {
+function msg(localpart: string, text: string) {
     return {
+        event_id: "$" + Math.random(),
         content: {
             body: text,
         },
@@ -535,8 +536,9 @@ function msg(localpart, text) {
     };
 }
 
-function member(localpart, membership) {
+function member(localpart: string, membership: string) {
     return {
+        event_id: "$" + Math.random(),
         content: {
             membership: membership,
         },
diff --git a/spec/unit/utils.spec.ts b/spec/unit/utils.spec.ts
index 1b11f2a7cd3..c9fc75c3e85 100644
--- a/spec/unit/utils.spec.ts
+++ b/spec/unit/utils.spec.ts
@@ -455,7 +455,11 @@ describe("utils", function() {
 
     describe("recursivelyAssign", () => {
         it("doesn't override with null/undefined", () => {
-            const result = utils.recursivelyAssign(
+            const result = utils.recursivelyAssign<{
+                string: string;
+                object: object;
+                float: number;
+            }, {}>(
                 {
                     string: "Hello world",
                     object: {},
@@ -475,7 +479,11 @@ describe("utils", function() {
         });
 
         it("assigns recursively", () => {
-            const result = utils.recursivelyAssign(
+            const result = utils.recursivelyAssign<{
+                number: number;
+                object: object;
+                thing: string | object;
+            }, {}>(
                 {
                     number: 42,
                     object: {
diff --git a/spec/unit/webrtc/call.spec.ts b/spec/unit/webrtc/call.spec.ts
index d1cb5d29616..1d4f9f03401 100644
--- a/spec/unit/webrtc/call.spec.ts
+++ b/spec/unit/webrtc/call.spec.ts
@@ -933,7 +933,7 @@ describe('Call', function() {
             await fakeIncomingCall(client, call, "1");
         });
 
-        const untilEventSent = async (...args) => {
+        const untilEventSent = async (...args: any[]) => {
             const maxTries = 20;
 
             for (let tries = 0; tries < maxTries; ++tries) {
@@ -971,7 +971,7 @@ describe('Call', function() {
         });
 
         describe("ICE candidate sending", () => {
-            let mockPeerConn;
+            let mockPeerConn: MockRTCPeerConnection;
             const fakeCandidateString = "here is a fake candidate!";
             const fakeCandidateEvent = {
                 candidate: {
@@ -1086,7 +1086,7 @@ describe('Call', function() {
     });
 
     describe("Screen sharing", () => {
-        const waitNegotiateFunc = resolve => {
+        const waitNegotiateFunc = (resolve: Function): void => {
             mockSendEvent.mockImplementationOnce(() => {
                 // Note that the peer connection here is a dummy one and always returns
                 // dummy SDP, so there's not much point returning the content: the SDP will
diff --git a/src/@types/read_receipts.ts b/src/@types/read_receipts.ts
index 689313672a3..ea832926072 100644
--- a/src/@types/read_receipts.ts
+++ b/src/@types/read_receipts.ts
@@ -42,7 +42,7 @@ export type ReceiptCache = {[eventId: string]: CachedReceipt[]};
 
 export interface ReceiptContent {
     [eventId: string]: {
-        [key in ReceiptType]: {
+        [key in ReceiptType | string]: {
             [userId: string]: Receipt;
         };
     };
diff --git a/src/autodiscovery.ts b/src/autodiscovery.ts
index d26e4d5c683..fe2b6e383f3 100644
--- a/src/autodiscovery.ts
+++ b/src/autodiscovery.ts
@@ -49,7 +49,7 @@ interface WellKnownConfig extends Omit<IWellKnownConfig, "error"> {
     error?: IWellKnownConfig["error"] | null;
 }
 
-interface ClientConfig {
+interface ClientConfig extends Omit<IClientWellKnown, "m.homeserver" | "m.identity_server"> {
     "m.homeserver": WellKnownConfig;
     "m.identity_server": WellKnownConfig;
 }
@@ -131,7 +131,7 @@ export class AutoDiscovery {
      * configuration, which may include error states. Rejects on unexpected
      * failure, not when verification fails.
      */
-    public static async fromDiscoveryConfig(wellknown: any): Promise<ClientConfig> {
+    public static async fromDiscoveryConfig(wellknown: IClientWellKnown): Promise<ClientConfig> {
         // Step 1 is to get the config, which is provided to us here.
 
         // We default to an error state to make the first few checks easier to
@@ -185,7 +185,7 @@ export class AutoDiscovery {
         const hsVersions = await this.fetchWellKnownObject(
             `${hsUrl}/_matrix/client/versions`,
         );
-        if (!hsVersions || !hsVersions.raw["versions"]) {
+        if (!hsVersions || !hsVersions.raw?.["versions"]) {
             logger.error("Invalid /versions response");
             clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HOMESERVER;
 
@@ -219,9 +219,7 @@ export class AutoDiscovery {
 
             // Step 5a: Make sure the URL is valid *looking*. We'll make sure it
             // points to an identity server in Step 5b.
-            isUrl = this.sanitizeWellKnownUrl(
-                wellknown["m.identity_server"]["base_url"],
-            );
+            isUrl = this.sanitizeWellKnownUrl(wellknown["m.identity_server"]["base_url"]);
             if (!isUrl) {
                 logger.error("Invalid base_url for m.identity_server");
                 failingClientConfig["m.identity_server"].error =
@@ -234,7 +232,7 @@ export class AutoDiscovery {
             const isResponse = await this.fetchWellKnownObject(
                 `${isUrl}/_matrix/identity/api/v1`,
             );
-            if (!isResponse || !isResponse.raw || isResponse.action !== AutoDiscoveryAction.SUCCESS) {
+            if (!isResponse?.raw || isResponse.action !== AutoDiscoveryAction.SUCCESS) {
                 logger.error("Invalid /api/v1 response");
                 failingClientConfig["m.identity_server"].error =
                     AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;
@@ -259,14 +257,16 @@ export class AutoDiscovery {
 
         // Step 7: Copy any other keys directly into the clientConfig. This is for
         // things like custom configuration of services.
-        Object.keys(wellknown).forEach((k) => {
+        Object.keys(wellknown).forEach((k: keyof IClientWellKnown) => {
             if (k === "m.homeserver" || k === "m.identity_server") {
                 // Only copy selected parts of the config to avoid overwriting
                 // properties computed by the validation logic above.
                 const notProps = ["error", "state", "base_url"];
-                for (const prop of Object.keys(wellknown[k])) {
+                for (const prop of Object.keys(wellknown[k]!)) {
                     if (notProps.includes(prop)) continue;
-                    clientConfig[k][prop] = wellknown[k][prop];
+                    type Prop = Exclude<keyof IWellKnownConfig, "error" | "state" | "base_url">;
+                    // @ts-ignore - ts gets unhappy as we're mixing types here
+                    clientConfig[k][prop as Prop] = wellknown[k]![prop as Prop];
                 }
             } else {
                 // Just copy the whole thing over otherwise
@@ -347,7 +347,7 @@ export class AutoDiscovery {
         }
 
         // Step 2: Validate and parse the config
-        return AutoDiscovery.fromDiscoveryConfig(wellknown.raw);
+        return AutoDiscovery.fromDiscoveryConfig(wellknown.raw!);
     }
 
     /**
@@ -378,7 +378,7 @@ export class AutoDiscovery {
      * @return {string|boolean} The sanitized URL or a falsey value if the URL is invalid.
      * @private
      */
-    private static sanitizeWellKnownUrl(url: string): string | false {
+    private static sanitizeWellKnownUrl(url?: string | null): string | false {
         if (!url) return false;
 
         try {
diff --git a/src/browser-index.js b/src/browser-index.ts
similarity index 76%
rename from src/browser-index.js
rename to src/browser-index.ts
index 86e887bd49f..200b2a32d7c 100644
--- a/src/browser-index.js
+++ b/src/browser-index.ts
@@ -16,27 +16,28 @@ limitations under the License.
 
 import * as matrixcs from "./matrix";
 
+type BrowserMatrix = typeof matrixcs;
+declare global {
+    /* eslint-disable no-var, camelcase */
+    var __js_sdk_entrypoint: boolean;
+    var matrixcs: BrowserMatrix;
+    /* eslint-enable no-var */
+}
+
 if (global.__js_sdk_entrypoint) {
     throw new Error("Multiple matrix-js-sdk entrypoints detected!");
 }
 global.__js_sdk_entrypoint = true;
 
-// just *accessing* indexedDB throws an exception in firefox with
-// indexeddb disabled.
-let indexedDB;
+// just *accessing* indexedDB throws an exception in firefox with indexeddb disabled.
+let indexedDB: IDBFactory | undefined;
 try {
     indexedDB = global.indexedDB;
 } catch (e) {}
 
 // if our browser (appears to) support indexeddb, use an indexeddb crypto store.
 if (indexedDB) {
-    matrixcs.setCryptoStoreFactory(
-        function() {
-            return new matrixcs.IndexedDBCryptoStore(
-                indexedDB, "matrix-js-sdk:crypto",
-            );
-        },
-    );
+    matrixcs.setCryptoStoreFactory(() => new matrixcs.IndexedDBCryptoStore(indexedDB!, "matrix-js-sdk:crypto"));
 }
 
 // We export 3 things to make browserify happy as well as downstream projects.
diff --git a/src/client.ts b/src/client.ts
index 9abcd967f70..fae73b7a4e4 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -530,7 +530,7 @@ export interface IPreviewUrlResponse {
     "matrix:image:size"?: number;
 }
 
-interface ITurnServerResponse {
+export interface ITurnServerResponse {
     uris: string[];
     username: string;
     password: string;
@@ -561,7 +561,7 @@ export interface IClientWellKnown {
 }
 
 export interface IWellKnownConfig {
-    raw?: any; // todo typings
+    raw?: IClientWellKnown;
     action?: AutoDiscoveryAction;
     reason?: string;
     error?: Error | string;
@@ -605,10 +605,10 @@ interface ITagMetadata {
 }
 
 interface IMessagesResponse {
-    start: string;
-    end: string;
+    start?: string;
+    end?: string;
     chunk: IRoomEvent[];
-    state: IStateEvent[];
+    state?: IStateEvent[];
 }
 
 interface IThreadedMessagesResponse {
@@ -635,6 +635,17 @@ export interface IUploadKeysRequest {
     "org.matrix.msc2732.fallback_keys"?: Record<string, IOneTimeKey>;
 }
 
+export interface IQueryKeysRequest {
+    device_keys: { [userId: string]: string[] };
+    timeout?: number;
+    token?: string;
+}
+
+export interface IClaimKeysRequest {
+    one_time_keys: { [userId: string]: { [deviceId: string]: string } };
+    timeout?: number;
+}
+
 export interface IOpenIDToken {
     access_token: string;
     token_type: "Bearer" | string;
@@ -1744,13 +1755,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             }
         }
 
-        return this.http.authedRequest<{
+        type Response = {
             capabilities?: ICapabilities;
-        }>(Method.Get, "/capabilities").catch((e: Error): void => {
+        };
+        return this.http.authedRequest<Response>(Method.Get, "/capabilities").catch((e: Error): Response => {
             // We swallow errors because we need a default object anyhow
             logger.error(e);
+            return {};
         }).then((r = {}) => {
-            const capabilities: ICapabilities = r["capabilities"] || {};
+            const capabilities = r["capabilities"] || {};
 
             // If the capabilities missed the cache, cache it for a shorter amount
             // of time to try and refresh them later.
@@ -3229,28 +3242,28 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         targetRoomId: undefined,
         targetSessionId: undefined,
         backupInfo: IKeyBackupInfo,
-        opts: IKeyBackupRestoreOpts,
+        opts?: IKeyBackupRestoreOpts,
     ): Promise<IKeyBackupRestoreResult>;
     public restoreKeyBackupWithRecoveryKey(
         recoveryKey: string,
         targetRoomId: string,
         targetSessionId: undefined,
         backupInfo: IKeyBackupInfo,
-        opts: IKeyBackupRestoreOpts,
+        opts?: IKeyBackupRestoreOpts,
     ): Promise<IKeyBackupRestoreResult>;
     public restoreKeyBackupWithRecoveryKey(
         recoveryKey: string,
         targetRoomId: string,
         targetSessionId: string,
         backupInfo: IKeyBackupInfo,
-        opts: IKeyBackupRestoreOpts,
+        opts?: IKeyBackupRestoreOpts,
     ): Promise<IKeyBackupRestoreResult>;
     public restoreKeyBackupWithRecoveryKey(
         recoveryKey: string,
         targetRoomId: string | undefined,
         targetSessionId: string | undefined,
         backupInfo: IKeyBackupInfo,
-        opts: IKeyBackupRestoreOpts,
+        opts?: IKeyBackupRestoreOpts,
     ): Promise<IKeyBackupRestoreResult> {
         const privKey = decodeRecoveryKey(recoveryKey);
         return this.restoreKeyBackup(privKey, targetRoomId!, targetSessionId!, backupInfo, opts);
@@ -3442,7 +3455,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         const deviceInfos = await this.crypto.downloadKeys(userIds);
-        const devicesByUser = {};
+        const devicesByUser: Record<string, DeviceInfo[]> = {};
         for (const [userId, devices] of Object.entries(deviceInfos)) {
             devicesByUser[userId] = Object.values(devices);
         }
@@ -3616,7 +3629,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @return {module:http-api.MatrixError} Rejects: with an error response.
      */
     public setIgnoredUsers(userIds: string[]): Promise<{}> {
-        const content = { ignored_users: {} };
+        const content = { ignored_users: {} as Record<string, object> };
         userIds.forEach((u) => {
             content.ignored_users[u] = {};
         });
@@ -3910,16 +3923,25 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     ): Promise<ISendEventResponse>;
     public sendEvent(
         roomId: string,
-        threadId: string | null,
-        eventType: string | IContent,
-        content?: IContent | string,
-        txnId?: string,
+        threadIdOrEventType: string | null,
+        eventTypeOrContent: string | IContent,
+        contentOrTxnId?: IContent | string,
+        txnIdOrVoid?: string,
     ): Promise<ISendEventResponse> {
-        if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
-            txnId = content as string;
-            content = eventType as IContent;
-            eventType = threadId;
+        let threadId: string | null;
+        let eventType: string;
+        let content: IContent;
+        let txnId: string | undefined;
+        if (!threadIdOrEventType?.startsWith(EVENT_ID_PREFIX) && threadIdOrEventType !== null) {
+            txnId = contentOrTxnId as string;
+            content = eventTypeOrContent as IContent;
+            eventType = threadIdOrEventType;
             threadId = null;
+        } else {
+            txnId = txnIdOrVoid;
+            content = contentOrTxnId as IContent;
+            eventType = eventTypeOrContent as string;
+            threadId = threadIdOrEventType;
         }
 
         // If we expect that an event is part of a thread but is missing the relation
@@ -4280,7 +4302,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         let eventType: string = EventType.RoomMessage;
         let sendContent: IContent = content as IContent;
         const makeContentExtensible = (content: IContent = {}, recurse = true): IPartialEvent<object> | undefined => {
-            let newEvent: IPartialEvent<object> | undefined;
+            let newEvent: IPartialEvent<IContent> | undefined;
 
             if (content['msgtype'] === MsgType.Text) {
                 newEvent = MessageEvent.from(content['body'], content['formatted_body']).serialize();
@@ -5262,11 +5284,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 room.addEventsToTimeline(timelineEvents, true, room.getLiveTimeline());
                 this.processThreadEvents(room, threadedEvents, true);
 
-                room.oldState.paginationToken = res.end;
+                room.oldState.paginationToken = res.end ?? null;
                 if (res.chunk.length === 0) {
                     room.oldState.paginationToken = null;
                 }
-                this.store.storeEvents(room, matrixEvents, res.end, true);
+                this.store.storeEvents(room, matrixEvents, res.end ?? null, true);
                 delete this.ongoingScrollbacks[room.roomId];
                 resolve(room);
             }).catch((err) => {
@@ -6261,7 +6283,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param {string} roomId the id of the room.
      * @return {object} the rule or undefined.
      */
-    public getRoomPushRule(scope: string, roomId: string): IPushRule | undefined {
+    public getRoomPushRule(scope: "global" | "device", roomId: string): IPushRule | undefined {
         // There can be only room-kind push rule per room
         // and its id is the room id.
         if (this.pushRules) {
@@ -6282,7 +6304,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @return {Promise} Resolves: result object
      * @return {module:http-api.MatrixError} Rejects: with an error response.
      */
-    public setRoomMutePushRule(scope: string, roomId: string, mute: boolean): Promise<void> | undefined {
+    public setRoomMutePushRule(scope: "global" | "device", roomId: string, mute: boolean): Promise<void> | undefined {
         let promise: Promise<unknown> | undefined;
         let hasDontNotifyRule = false;
 
@@ -6818,7 +6840,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             .filter(([key, value]) => {
                 return primTypes.includes(typeof value);
             })
-            .reduce((obj, [key, value]) => {
+            .reduce<Record<string, any>>((obj, [key, value]) => {
                 obj[key] = value;
                 return obj;
             }, {});
@@ -7841,7 +7863,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             $roomId: roomId,
         });
 
-        const content = {
+        const content: IContent = {
             [ReceiptType.FullyRead]: rmEventId,
             [ReceiptType.Read]: rrEventId,
         };
@@ -8540,7 +8562,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *     an error response ({@link module:http-api.MatrixError}).
      */
     public downloadKeysForUsers(userIds: string[], opts: { token?: string } = {}): Promise<IDownloadKeyResult> {
-        const content: any = {
+        const content: IQueryKeysRequest = {
             device_keys: {},
         };
         if ('token' in opts) {
@@ -8582,7 +8604,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             queries[userId] = query;
             query[deviceId] = keyAlgorithm;
         }
-        const content: any = { one_time_keys: queries };
+        const content: IClaimKeysRequest = { one_time_keys: queries };
         if (timeout) {
             content.timeout = timeout;
         }
@@ -8874,7 +8896,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 const med = p[1].toLowerCase();
                 const unhashed = `${addr} ${med}`;
                 // Map the unhashed values to a known (case-sensitive) address. We use
-                // the case sensitive version because the caller might be expecting that.
+                // the case-sensitive version because the caller might be expecting that.
                 localMapping[unhashed] = p[0];
                 return unhashed;
             });
@@ -8883,12 +8905,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             throw new Error("Unsupported identity server: unknown hash algorithm");
         }
 
-        const response = await this.http.idServerRequest(
-            Method.Post, "/lookup",
-            params, IdentityPrefix.V2, identityAccessToken,
-        );
+        const response = await this.http.idServerRequest<{
+            mappings: { [address: string]: string };
+        }>(Method.Post, "/lookup", params, IdentityPrefix.V2, identityAccessToken);
 
-        if (!response || !response['mappings']) return []; // no results
+        if (!response?.['mappings']) return []; // no results
 
         const foundAddresses: { address: string, mxid: string }[] = [];
         for (const hashed of Object.keys(response['mappings'])) {
@@ -9028,7 +9049,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             messages: contentMap,
         };
 
-        const targets = Object.keys(contentMap).reduce((obj, key) => {
+        const targets = Object.keys(contentMap).reduce<Record<string, string[]>>((obj, key) => {
             obj[key] = Object.keys(contentMap[key]);
             return obj;
         }, {});
diff --git a/src/crypto/CrossSigning.ts b/src/crypto/CrossSigning.ts
index e776b93ad94..4035db04cf7 100644
--- a/src/crypto/CrossSigning.ts
+++ b/src/crypto/CrossSigning.ts
@@ -84,6 +84,7 @@ export class CrossSigningInfo {
         const res = new CrossSigningInfo(userId);
         for (const prop in obj) {
             if (obj.hasOwnProperty(prop)) {
+                // @ts-ignore - ts doesn't like this and nor should we
                 res[prop] = obj[prop];
             }
         }
diff --git a/src/crypto/EncryptionSetup.ts b/src/crypto/EncryptionSetup.ts
index 253c83c1d64..a46afdc4df6 100644
--- a/src/crypto/EncryptionSetup.ts
+++ b/src/crypto/EncryptionSetup.ts
@@ -35,7 +35,7 @@ import { IAccountDataClient } from "./SecretStorage";
 
 interface ICrossSigningKeys {
     authUpload: IBootstrapCrossSigningOpts["authUploadDeviceSigningKeys"];
-    keys: Record<string, ICrossSigningKey>;
+    keys: Record<"master" | "self_signing" | "user_signing", ICrossSigningKey>;
 }
 
 /**
@@ -209,7 +209,7 @@ export class EncryptionSetupOperation {
         if (this.crossSigningKeys) {
             const keys: Partial<CrossSigningKeys> = {};
             for (const [name, key] of Object.entries(this.crossSigningKeys.keys)) {
-                keys[name + "_key"] = key;
+                keys[((name as keyof ICrossSigningKeys["keys"]) + "_key" as keyof CrossSigningKeys)] = key;
             }
 
             // We must only call `uploadDeviceSigningKeys` from inside this auth
diff --git a/src/crypto/OlmDevice.ts b/src/crypto/OlmDevice.ts
index efa34ad4159..13463ef115c 100644
--- a/src/crypto/OlmDevice.ts
+++ b/src/crypto/OlmDevice.ts
@@ -23,11 +23,19 @@ import { CryptoStore, IProblem, ISessionInfo, IWithheld } from "./store/base";
 import { IOlmDevice, IOutboundGroupSessionKey } from "./algorithms/megolm";
 import { IMegolmSessionData } from "./index";
 import { OlmGroupSessionExtraData } from "../@types/crypto";
+import { IMessage } from "./algorithms/olm";
 
 // The maximum size of an event is 65K, and we base64 the content, so this is a
 // reasonable approximation to the biggest plaintext we can encrypt.
 const MAX_PLAINTEXT_LENGTH = 65536 * 3 / 4;
 
+export class PayloadTooLargeError extends Error {
+    public readonly data = {
+        errcode: "M_TOO_LARGE",
+        error: "Payload too large for encrypted message",
+    };
+}
+
 function checkPayloadLength(payloadString: string): void {
     if (payloadString === undefined) {
         throw new Error("payloadString undefined");
@@ -40,15 +48,8 @@ function checkPayloadLength(payloadString: string): void {
         // Note that even if we manage to do the encryption, the message send may fail,
         // because by the time we've wrapped the ciphertext in the event object, it may
         // exceed 65K. But at least we won't just fail with "abort()" in that case.
-        const err = new Error("Message too long (" + payloadString.length + " bytes). " +
-                        "The maximum for an encrypted message is " +
-                        MAX_PLAINTEXT_LENGTH + " bytes.");
-        // TODO: [TypeScript] We should have our own error types
-        err["data"] = {
-            errcode: "M_TOO_LARGE",
-            error: "Payload too large for encrypted message",
-        };
-        throw err;
+        throw new PayloadTooLargeError(`Message too long (${payloadString.length} bytes). ` +
+            `The maximum for an encrypted message is ${MAX_PLAINTEXT_LENGTH} bytes.`);
     }
 }
 
@@ -126,6 +127,8 @@ interface IInboundGroupSessionKey {
 }
 /* eslint-enable camelcase */
 
+type OneTimeKeys = { curve25519: { [keyId: string]: string } };
+
 /**
  * Manages the olm cryptography functions. Each OlmDevice has a single
  * OlmAccount and a number of OlmSessions.
@@ -452,7 +455,7 @@ export class OlmDevice {
      * @return {Promise<string>} base64-encoded signature
      */
     public async sign(message: string): Promise<string> {
-        let result;
+        let result: string;
         await this.cryptoStore.doTxn(
             'readonly', [IndexedDBCryptoStore.STORE_ACCOUNT],
             (txn) => {
@@ -460,7 +463,7 @@ export class OlmDevice {
                     result = account.sign(message);
                 });
             });
-        return result;
+        return result!;
     }
 
     /**
@@ -470,8 +473,8 @@ export class OlmDevice {
      * <tt>curve25519</tt>, which is itself an object mapping key id to Curve25519
      * key.
      */
-    public async getOneTimeKeys(): Promise<{ curve25519: { [keyId: string]: string } }> {
-        let result;
+    public async getOneTimeKeys(): Promise<OneTimeKeys> {
+        let result: OneTimeKeys;
         await this.cryptoStore.doTxn(
             'readonly', [IndexedDBCryptoStore.STORE_ACCOUNT],
             (txn) => {
@@ -481,7 +484,7 @@ export class OlmDevice {
             },
         );
 
-        return result;
+        return result!;
     }
 
     /**
@@ -821,10 +824,10 @@ export class OlmDevice {
         theirDeviceIdentityKey: string,
         sessionId: string,
         payloadString: string,
-    ): Promise<string> {
+    ): Promise<IMessage> {
         checkPayloadLength(payloadString);
 
-        let res;
+        let res: IMessage;
         await this.cryptoStore.doTxn(
             'readwrite', [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
@@ -840,7 +843,7 @@ export class OlmDevice {
             },
             logger.withPrefix("[encryptMessage]"),
         );
-        return res;
+        return res!;
     }
 
     /**
@@ -860,7 +863,7 @@ export class OlmDevice {
         messageType: number,
         ciphertext: string,
     ): Promise<string> {
-        let payloadString;
+        let payloadString: string;
         await this.cryptoStore.doTxn(
             'readwrite', [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
@@ -877,7 +880,7 @@ export class OlmDevice {
             },
             logger.withPrefix("[decryptMessage]"),
         );
-        return payloadString;
+        return payloadString!;
     }
 
     /**
@@ -902,7 +905,7 @@ export class OlmDevice {
             return false;
         }
 
-        let matches;
+        let matches: boolean;
         await this.cryptoStore.doTxn(
             'readonly', [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
@@ -912,7 +915,7 @@ export class OlmDevice {
             },
             logger.withPrefix("[matchesSession]"),
         );
-        return matches;
+        return matches!;
     }
 
     public async recordSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void> {
@@ -1293,7 +1296,7 @@ export class OlmDevice {
                             result = null;
                             return;
                         }
-                        let res;
+                        let res: ReturnType<InboundGroupSession["decrypt"]>;
                         try {
                             res = session.decrypt(body);
                         } catch (e) {
@@ -1313,8 +1316,8 @@ export class OlmDevice {
 
                         let plaintext: string = res.plaintext;
                         if (plaintext === undefined) {
-                            // Compatibility for older olm versions.
-                            plaintext = res;
+                            // @ts-ignore - Compatibility for older olm versions.
+                            plaintext = res as string;
                         } else {
                             // Check if we have seen this message index before to detect replay attacks.
                             // If the event ID and timestamp are specified, and the match the event ID
@@ -1555,7 +1558,7 @@ export class OlmDevice {
     }
 }
 
-export const WITHHELD_MESSAGES = {
+export const WITHHELD_MESSAGES: Record<string, string> = {
     "m.unverified": "The sender has disabled encrypting to unverified devices.",
     "m.blacklisted": "The sender has blocked you.",
     "m.unauthorised": "You are not authorised to read the message.",
diff --git a/src/crypto/SecretStorage.ts b/src/crypto/SecretStorage.ts
index a7e1e7d738f..54702034f46 100644
--- a/src/crypto/SecretStorage.ts
+++ b/src/crypto/SecretStorage.ts
@@ -18,10 +18,9 @@ import { v4 as uuidv4 } from 'uuid';
 
 import { logger } from '../logger';
 import * as olmlib from './olmlib';
-import { encodeBase64 } from './olmlib';
 import { randomString } from '../randomstring';
 import { calculateKeyCheck, decryptAES, encryptAES, IEncryptedPayload } from './aes';
-import { ICryptoCallbacks } from ".";
+import { ICryptoCallbacks, IEncryptedContent } from ".";
 import { IContent, MatrixEvent } from "../models/event";
 import { ClientEvent, ClientEventHandlerMap, MatrixClient } from "../client";
 import { IAddSecretStorageKeyOpts, ISecretStorageKeyInfo } from './api';
@@ -61,8 +60,7 @@ interface IDecryptors {
 
 interface ISecretInfo {
     encrypted: {
-        // eslint-disable-next-line camelcase
-        key_id: IEncryptedPayload;
+        [keyId: string]: IEncryptedPayload;
     };
 }
 
@@ -318,23 +316,11 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                 `the keys it is encrypted with are for a supported algorithm`);
         }
 
-        let keyId: string;
-        let decryption;
-        try {
-            // fetch private key from app
-            [keyId, decryption] = await this.getSecretStorageKey(keys, name);
+        // fetch private key from app
+        const [keyId, decryption] = await this.getSecretStorageKey(keys, name);
+        const encInfo = secretInfo.encrypted[keyId];
 
-            const encInfo = secretInfo.encrypted[keyId];
-
-            // We don't actually need the decryption object if it's a passthrough
-            // since we just want to return the key itself. It must be base64
-            // encoded, since this is how a key would normally be stored.
-            if (encInfo.passthrough) return encodeBase64(decryption.get_private_key());
-
-            return decryption.decrypt(encInfo);
-        } finally {
-            if (decryption && decryption.free) decryption.free();
-        }
+        return decryption.decrypt(encInfo);
     }
 
     /**
@@ -351,7 +337,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
         const secretInfo = await this.accountDataAdapter.getAccountDataFromServer<ISecretInfo>(name);
         if (!secretInfo?.encrypted) return null;
 
-        const ret = {};
+        const ret: Record<string, ISecretStorageKeyInfo> = {};
 
         // filter secret encryption keys with supported algorithm
         for (const keyId of Object.keys(secretInfo.encrypted)) {
@@ -391,7 +377,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                 requesting_device_id: this.baseApis.deviceId,
                 request_id: requestId,
             };
-            const toDevice = {};
+            const toDevice: Record<string, typeof cancelData> = {};
             for (const device of devices) {
                 toDevice[device] = cancelData;
             }
@@ -412,7 +398,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
             request_id: requestId,
             [ToDeviceMessageId]: uuidv4(),
         };
-        const toDevice = {};
+        const toDevice: Record<string, typeof requestData> = {};
         for (const device of devices) {
             toDevice[device] = requestData;
         }
@@ -490,9 +476,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                         secret: secret,
                     },
                 };
-                const encryptedContent = {
+                const encryptedContent: IEncryptedContent = {
                     algorithm: olmlib.OLM_ALGORITHM,
-                    sender_key: this.baseApis.crypto!.olmDevice.deviceCurve25519Key,
+                    sender_key: this.baseApis.crypto!.olmDevice.deviceCurve25519Key!,
                     ciphertext: {},
                     [ToDeviceMessageId]: uuidv4(),
                 };
diff --git a/src/crypto/algorithms/base.ts b/src/crypto/algorithms/base.ts
index d6c70bc1067..32b9ab73b7e 100644
--- a/src/crypto/algorithms/base.ts
+++ b/src/crypto/algorithms/base.ts
@@ -23,8 +23,14 @@ limitations under the License.
 import { MatrixClient } from "../../client";
 import { Room } from "../../models/room";
 import { OlmDevice } from "../OlmDevice";
-import { MatrixEvent, RoomMember } from "../../matrix";
-import { Crypto, IEventDecryptionResult, IMegolmSessionData, IncomingRoomKeyRequest } from "..";
+import { IContent, MatrixEvent, RoomMember } from "../../matrix";
+import {
+    Crypto,
+    IEncryptedContent,
+    IEventDecryptionResult,
+    IMegolmSessionData,
+    IncomingRoomKeyRequest,
+} from "..";
 import { DeviceInfo } from "../deviceinfo";
 import { IRoomEncryption } from "../RoomList";
 
@@ -108,7 +114,7 @@ export abstract class EncryptionAlgorithm {
      *
      * @return {Promise} Promise which resolves to the new event body
      */
-    public abstract encryptMessage(room: Room, eventType: string, content: object): Promise<object>;
+    public abstract encryptMessage(room: Room, eventType: string, content: IContent): Promise<IEncryptedContent>;
 
     /**
      * Called when the membership of a member of the room changes.
diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index 9ba33e32a78..b099ef40ae6 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -38,9 +38,15 @@ import { Room } from '../../models/room';
 import { DeviceInfo } from "../deviceinfo";
 import { IOlmSessionResult } from "../olmlib";
 import { DeviceInfoMap } from "../DeviceList";
-import { MatrixEvent } from "../../models/event";
+import { IContent, MatrixEvent } from "../../models/event";
 import { EventType, MsgType, ToDeviceMessageId } from '../../@types/event';
-import { IEncryptedContent, IEventDecryptionResult, IMegolmSessionData, IncomingRoomKeyRequest } from "../index";
+import {
+    IMegolmEncryptedContent,
+    IEventDecryptionResult,
+    IMegolmSessionData,
+    IncomingRoomKeyRequest,
+    IEncryptedContent,
+} from "../index";
 import { RoomKeyRequestState } from '../OutgoingRoomKeyRequestManager';
 import { OlmGroupSessionExtraData } from "../../@types/crypto";
 import { MatrixError } from "../../http-api";
@@ -228,7 +234,7 @@ class OutboundSessionInfo {
  * @param {object} params parameters, as per
  *     {@link module:crypto/algorithms/EncryptionAlgorithm}
  */
-class MegolmEncryption extends EncryptionAlgorithm {
+export class MegolmEncryption extends EncryptionAlgorithm {
     // the most recent attempt to set up a session. This is used to serialise
     // the session setups, so that we have a race-free view of which session we
     // are using, and which devices we have shared the keys with. It resolves
@@ -761,9 +767,9 @@ class MegolmEncryption extends EncryptionAlgorithm {
             },
         };
 
-        const encryptedContent = {
+        const encryptedContent: IEncryptedContent = {
             algorithm: olmlib.OLM_ALGORITHM,
-            sender_key: this.olmDevice.deviceCurve25519Key,
+            sender_key: this.olmDevice.deviceCurve25519Key!,
             ciphertext: {},
             [ToDeviceMessageId]: uuidv4(),
         };
@@ -1010,7 +1016,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
      *
      * @return {Promise} Promise which resolves to the new event body
      */
-    public async encryptMessage(room: Room, eventType: string, content: object): Promise<object> {
+    public async encryptMessage(room: Room, eventType: string, content: IContent): Promise<IMegolmEncryptedContent> {
         logger.log(`Starting to encrypt event for ${this.roomId}`);
 
         if (this.encryptionPreparation != null) {
@@ -1045,12 +1051,10 @@ class MegolmEncryption extends EncryptionAlgorithm {
             content: content,
         };
 
-        const ciphertext = this.olmDevice.encryptGroupMessage(
-            session.sessionId, JSON.stringify(payloadJson),
-        );
-        const encryptedContent = {
+        const ciphertext = this.olmDevice.encryptGroupMessage(session.sessionId, JSON.stringify(payloadJson));
+        const encryptedContent: IEncryptedContent = {
             algorithm: olmlib.MEGOLM_ALGORITHM,
-            sender_key: this.olmDevice.deviceCurve25519Key,
+            sender_key: this.olmDevice.deviceCurve25519Key!,
             ciphertext: ciphertext,
             session_id: session.sessionId,
             // Include our device ID so that recipients can send us a
@@ -1064,7 +1068,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
         return encryptedContent;
     }
 
-    private isVerificationEvent(eventType: string, content: object): boolean {
+    private isVerificationEvent(eventType: string, content: IContent): boolean {
         switch (eventType) {
             case EventType.KeyVerificationCancel:
             case EventType.KeyVerificationDone:
@@ -1227,7 +1231,7 @@ class MegolmEncryption extends EncryptionAlgorithm {
  * @param {object} params parameters, as per
  *     {@link module:crypto/algorithms/DecryptionAlgorithm}
  */
-class MegolmDecryption extends DecryptionAlgorithm {
+export class MegolmDecryption extends DecryptionAlgorithm {
     // events which we couldn't decrypt due to unknown sessions /
     // indexes, or which we could only decrypt with untrusted keys:
     // map from senderKey|sessionId to Set of MatrixEvents
@@ -1670,9 +1674,9 @@ class MegolmDecryption extends DecryptionAlgorithm {
             await olmlib.ensureOlmSessionsForDevices(
                 this.olmDevice, this.baseApis, { [sender]: [device] }, false,
             );
-            const encryptedContent = {
+            const encryptedContent: IEncryptedContent = {
                 algorithm: olmlib.OLM_ALGORITHM,
-                sender_key: this.olmDevice.deviceCurve25519Key,
+                sender_key: this.olmDevice.deviceCurve25519Key!,
                 ciphertext: {},
                 [ToDeviceMessageId]: uuidv4(),
             };
@@ -1752,9 +1756,9 @@ class MegolmDecryption extends DecryptionAlgorithm {
                 body.room_id, body.sender_key, body.session_id,
             );
         }).then((payload) => {
-            const encryptedContent = {
+            const encryptedContent: IEncryptedContent = {
                 algorithm: olmlib.OLM_ALGORITHM,
-                sender_key: this.olmDevice.deviceCurve25519Key,
+                sender_key: this.olmDevice.deviceCurve25519Key!,
                 ciphertext: {},
                 [ToDeviceMessageId]: uuidv4(),
             };
diff --git a/src/crypto/algorithms/olm.ts b/src/crypto/algorithms/olm.ts
index 682aa4c7c87..114368319b7 100644
--- a/src/crypto/algorithms/olm.ts
+++ b/src/crypto/algorithms/olm.ts
@@ -30,13 +30,13 @@ import {
     registerAlgorithm,
 } from "./base";
 import { Room } from '../../models/room';
-import { MatrixEvent } from "../../models/event";
-import { IEventDecryptionResult } from "../index";
+import { IContent, MatrixEvent } from "../../models/event";
+import { IEncryptedContent, IEventDecryptionResult, IOlmEncryptedContent } from "../index";
 import { IInboundSession } from "../OlmDevice";
 
 const DeviceVerification = DeviceInfo.DeviceVerification;
 
-interface IMessage {
+export interface IMessage {
     type: number;
     body: string;
 }
@@ -91,7 +91,7 @@ class OlmEncryption extends EncryptionAlgorithm {
      *
      * @return {Promise} Promise which resolves to the new event body
      */
-    public async encryptMessage(room: Room, eventType: string, content: object): Promise<object> {
+    public async encryptMessage(room: Room, eventType: string, content: IContent): Promise<IOlmEncryptedContent> {
         // pick the list of recipients based on the membership list.
         //
         // TODO: there is a race condition here! What if a new user turns up
@@ -111,9 +111,9 @@ class OlmEncryption extends EncryptionAlgorithm {
             content: content,
         };
 
-        const encryptedContent = {
+        const encryptedContent: IEncryptedContent = {
             algorithm: olmlib.OLM_ALGORITHM,
-            sender_key: this.olmDevice.deviceCurve25519Key,
+            sender_key: this.olmDevice.deviceCurve25519Key!,
             ciphertext: {},
         };
 
diff --git a/src/crypto/backup.ts b/src/crypto/backup.ts
index f2160165bd8..51912893605 100644
--- a/src/crypto/backup.ts
+++ b/src/crypto/backup.ts
@@ -93,7 +93,7 @@ interface BackupAlgorithmClass {
 
 interface BackupAlgorithm {
     untrusted: boolean;
-    encryptSession(data: Record<string, any>): Promise<any>;
+    encryptSession(data: Record<string, any>): Promise<Curve25519SessionData | IEncryptedPayload>;
     decryptSessions(ciphertexts: Record<string, IKeyBackupSession>): Promise<IMegolmSessionData[]>;
     authData: AuthData;
     keyMatches(key: ArrayLike<number>): Promise<boolean>;
@@ -663,7 +663,7 @@ export class Curve25519 implements BackupAlgorithm {
 
     public get untrusted(): boolean { return true; }
 
-    public async encryptSession(data: Record<string, any>): Promise<any> {
+    public async encryptSession(data: Record<string, any>): Promise<Curve25519SessionData> {
         const plainText: Record<string, any> = Object.assign({}, data);
         delete plainText.session_id;
         delete plainText.room_id;
@@ -788,7 +788,7 @@ export class Aes256 implements BackupAlgorithm {
 
     public get untrusted(): boolean { return false; }
 
-    public encryptSession(data: Record<string, any>): Promise<any> {
+    public encryptSession(data: Record<string, any>): Promise<IEncryptedPayload> {
         const plainText: Record<string, any> = Object.assign({}, data);
         delete plainText.session_id;
         delete plainText.room_id;
diff --git a/src/crypto/dehydration.ts b/src/crypto/dehydration.ts
index cc6b252da59..1ed16b74cbd 100644
--- a/src/crypto/dehydration.ts
+++ b/src/crypto/dehydration.ts
@@ -258,7 +258,7 @@ export class DehydrationManager {
             }
 
             logger.log("Preparing fallback keys");
-            const fallbackKeys = {};
+            const fallbackKeys: Record<string, IOneTimeKey> = {};
             for (const [keyId, key] of Object.entries(fallbacks.curve25519)) {
                 const k: IOneTimeKey = { key, fallback: true };
                 const signature = account.sign(anotherjson.stringify(k));
diff --git a/src/crypto/deviceinfo.ts b/src/crypto/deviceinfo.ts
index 3b4d53f6813..a8fd9f0086b 100644
--- a/src/crypto/deviceinfo.ts
+++ b/src/crypto/deviceinfo.ts
@@ -72,7 +72,8 @@ export class DeviceInfo {
         const res = new DeviceInfo(deviceId);
         for (const prop in obj) {
             if (obj.hasOwnProperty(prop)) {
-                res[prop] = obj[prop];
+                // @ts-ignore - this is messy and typescript doesn't like it
+                res[prop as keyof IDevice] = obj[prop as keyof IDevice];
             }
         }
         return res;
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index d71fadf9073..9163ace4f71 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -88,6 +88,9 @@ import { CryptoStore } from "./store/base";
 import { IVerificationChannel } from "./verification/request/Channel";
 import { TypedEventEmitter } from "../models/typed-event-emitter";
 import { IContent } from "../models/event";
+import { ISyncResponse } from "../sync-accumulator";
+import { ISignatures } from "../@types/signed";
+import { IMessage } from "./algorithms/olm";
 
 const DeviceVerification = DeviceInfo.DeviceVerification;
 
@@ -100,7 +103,7 @@ const defaultVerificationMethods = {
     // to start.
     [SHOW_QR_CODE_METHOD]: IllegalMethod,
     [SCAN_QR_CODE_METHOD]: IllegalMethod,
-};
+} as const;
 
 /**
  * verification method names
@@ -109,7 +112,7 @@ const defaultVerificationMethods = {
 export const verificationMethods = {
     RECIPROCATE_QR_CODE: ReciprocateQRCode.NAME,
     SAS: SASVerification.NAME,
-};
+} as const;
 
 export type VerificationMethod = keyof typeof verificationMethods | string;
 
@@ -200,18 +203,13 @@ interface IUserOlmSession {
     }[];
 }
 
-interface ISyncDeviceLists {
-    changed: string[];
-    left: string[];
-}
-
 export interface IRoomKeyRequestRecipient {
     userId: string;
     deviceId: string;
 }
 
 interface ISignableObject {
-    signatures?: object;
+    signatures?: ISignatures;
     unsigned?: object;
 }
 
@@ -231,14 +229,25 @@ export interface IRequestsMap {
 }
 
 /* eslint-disable camelcase */
-export interface IEncryptedContent {
-    algorithm: string;
+export interface IOlmEncryptedContent {
+    algorithm: typeof olmlib.OLM_ALGORITHM;
     sender_key: string;
-    ciphertext: Record<string, string>;
-    [ToDeviceMessageId]: string;
+    ciphertext: Record<string, IMessage>;
+    [ToDeviceMessageId]?: string;
+}
+
+export interface IMegolmEncryptedContent {
+    algorithm: typeof olmlib.MEGOLM_ALGORITHM;
+    sender_key: string;
+    session_id: string;
+    device_id: string;
+    ciphertext: string;
+    [ToDeviceMessageId]?: string;
 }
 /* eslint-enable camelcase */
 
+export type IEncryptedContent = IOlmEncryptedContent | IMegolmEncryptedContent;
+
 export enum CryptoEvent {
     DeviceVerificationChanged = "deviceVerificationChanged",
     UserTrustStatusChanged = "userTrustStatusChanged",
@@ -382,7 +391,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         private readonly clientStore: IStore,
         public readonly cryptoStore: CryptoStore,
         private readonly roomList: RoomList,
-        verificationMethods: Array<keyof typeof defaultVerificationMethods | typeof VerificationBase>,
+        verificationMethods: Array<VerificationMethod | (typeof VerificationBase & { NAME: string })>,
     ) {
         super();
         this.reEmitter = new TypedReEmitter(this);
@@ -2947,7 +2956,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @param {Object} syncDeviceLists device_lists field from /sync, or response from
      * /keys/changes
      */
-    public async handleDeviceListChanges(syncData: ISyncStateData, syncDeviceLists: ISyncDeviceLists): Promise<void> {
+    public async handleDeviceListChanges(
+        syncData: ISyncStateData,
+        syncDeviceLists: Required<ISyncResponse>["device_lists"],
+    ): Promise<void> {
         // Initial syncs don't have device change lists. We'll either get the complete list
         // of changes for the interval or will have invalidated everything in willProcessSync
         if (!syncData.oldSyncToken) return;
@@ -3087,15 +3099,14 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @param {Object} deviceLists device_lists field from /sync, or response from
      * /keys/changes
      */
-    private async evalDeviceListChanges(deviceLists: ISyncDeviceLists): Promise<void> {
-        if (deviceLists.changed && Array.isArray(deviceLists.changed)) {
+    private async evalDeviceListChanges(deviceLists: Required<ISyncResponse>["device_lists"]): Promise<void> {
+        if (Array.isArray(deviceLists?.changed)) {
             deviceLists.changed.forEach((u) => {
                 this.deviceList.invalidateUserDeviceList(u);
             });
         }
 
-        if (deviceLists.left && Array.isArray(deviceLists.left) &&
-            deviceLists.left.length) {
+        if (Array.isArray(deviceLists?.left) && deviceLists.left.length) {
             // Check we really don't share any rooms with these users
             // any more: the server isn't required to give us the
             // exact correct set.
@@ -3515,9 +3526,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         // same order we sent them, the other end will get this first, set up the new session,
         // then get the keyshare request and send the key over this new session (because it
         // is the session it has most recently received a message on).
-        const encryptedContent = {
+        const encryptedContent: IEncryptedContent = {
             algorithm: olmlib.OLM_ALGORITHM,
-            sender_key: this.olmDevice.deviceCurve25519Key,
+            sender_key: this.olmDevice.deviceCurve25519Key!,
             ciphertext: {},
             [ToDeviceMessageId]: uuidv4(),
         };
@@ -3842,7 +3853,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * @param {Object} obj  Object to which we will add a 'signatures' property
      */
-    public async signObject(obj: object & ISignableObject): Promise<void> {
+    public async signObject<T extends ISignableObject & object>(obj: T): Promise<void> {
         const sigs = obj.signatures || {};
         const unsigned = obj.unsigned;
 
diff --git a/src/crypto/olmlib.ts b/src/crypto/olmlib.ts
index 111e4c16de3..862691353c9 100644
--- a/src/crypto/olmlib.ts
+++ b/src/crypto/olmlib.ts
@@ -31,6 +31,7 @@ import { IClaimOTKsResult, MatrixClient } from "../client";
 import { ISignatures } from "../@types/signed";
 import { MatrixEvent } from "../models/event";
 import { EventType } from "../@types/event";
+import { IMessage } from "./algorithms/olm";
 
 enum Algorithm {
     Olm = "m.olm.v1.curve25519-aes-sha2",
@@ -75,7 +76,7 @@ export interface IOlmSessionResult {
  *    has been encrypted into `resultsObject`
  */
 export async function encryptMessageForDevice(
-    resultsObject: Record<string, string>,
+    resultsObject: Record<string, IMessage>,
     ourUserId: string,
     ourDeviceId: string | undefined,
     olmDevice: OlmDevice,
@@ -124,6 +125,7 @@ export async function encryptMessageForDevice(
         recipient_keys: {
             "ed25519": recipientDevice.getFingerprint(),
         },
+        ...payloadFields,
     };
 
     // TODO: technically, a bunch of that stuff only needs to be included for
@@ -131,11 +133,7 @@ export async function encryptMessageForDevice(
     // involved in the session. If we're looking to reduce data transfer in the
     // future, we could elide them for subsequent messages.
 
-    Object.assign(payload, payloadFields);
-
-    resultsObject[deviceKey] = await olmDevice.encryptMessage(
-        deviceKey, sessionId, JSON.stringify(payload),
-    );
+    resultsObject[deviceKey] = await olmDevice.encryptMessage(deviceKey, sessionId, JSON.stringify(payload));
 }
 
 interface IExistingOlmSession {
@@ -495,7 +493,7 @@ export async function verifySignature(
  * @param {string} pubKey The public key (ignored if key is a seed)
  * @returns {string} the signature for the object
  */
-export function pkSign(obj: IObject, key: PkSigning, userId: string, pubKey: string): string {
+export function pkSign(obj: object & IObject, key: Uint8Array | PkSigning, userId: string, pubKey: string): string {
     let createdKey = false;
     if (key instanceof Uint8Array) {
         const keyObj = new global.Olm.PkSigning();
diff --git a/src/crypto/store/base.ts b/src/crypto/store/base.ts
index 0615822271d..72b02e0a1cb 100644
--- a/src/crypto/store/base.ts
+++ b/src/crypto/store/base.ts
@@ -69,7 +69,7 @@ export interface CryptoStore {
     deleteOutgoingRoomKeyRequest(requestId: string, expectedState: number): Promise<OutgoingRoomKeyRequest | null>;
 
     // Olm Account
-    getAccount(txn: unknown, func: (accountPickle: string | null) => void);
+    getAccount(txn: unknown, func: (accountPickle: string | null) => void): void;
     storeAccount(txn: unknown, accountPickle: string): void;
     getCrossSigningKeys(txn: unknown, func: (keys: Record<string, ICrossSigningKey> | null) => void): void;
     getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(
diff --git a/src/crypto/store/localStorage-crypto-store.ts b/src/crypto/store/localStorage-crypto-store.ts
index 977236ef93f..c6f9a02d6ae 100644
--- a/src/crypto/store/localStorage-crypto-store.ts
+++ b/src/crypto/store/localStorage-crypto-store.ts
@@ -338,20 +338,20 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
     }
 
     public unmarkSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
-        const sessionsNeedingBackup
-              = getJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
+        const sessionsNeedingBackup = getJsonItem<{
+            [senderKeySessionId: string]: string;
+        }>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
         for (const session of sessions) {
             delete sessionsNeedingBackup[session.senderKey + '/' + session.sessionId];
         }
-        setJsonItem(
-            this.store, KEY_SESSIONS_NEEDING_BACKUP, sessionsNeedingBackup,
-        );
+        setJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP, sessionsNeedingBackup);
         return Promise.resolve();
     }
 
     public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
-        const sessionsNeedingBackup
-              = getJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
+        const sessionsNeedingBackup = getJsonItem<{
+            [senderKeySessionId: string]: boolean;
+        }>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
         for (const session of sessions) {
             sessionsNeedingBackup[session.senderKey + '/' + session.sessionId] = true;
         }
diff --git a/src/crypto/verification/QRCode.ts b/src/crypto/verification/QRCode.ts
index f6bdda17e1a..13053280d8b 100644
--- a/src/crypto/verification/QRCode.ts
+++ b/src/crypto/verification/QRCode.ts
@@ -283,21 +283,21 @@ export class QRCodeData {
     private static generateBuffer(qrData: IQrData): Buffer {
         let buf = Buffer.alloc(0); // we'll concat our way through life
 
-        const appendByte = (b): void => {
+        const appendByte = (b: number): void => {
             const tmpBuf = Buffer.from([b]);
             buf = Buffer.concat([buf, tmpBuf]);
         };
-        const appendInt = (i): void => {
+        const appendInt = (i: number): void => {
             const tmpBuf = Buffer.alloc(2);
             tmpBuf.writeInt16BE(i, 0);
             buf = Buffer.concat([buf, tmpBuf]);
         };
-        const appendStr = (s, enc, withLengthPrefix = true): void => {
+        const appendStr = (s: string, enc: BufferEncoding, withLengthPrefix = true): void => {
             const tmpBuf = Buffer.from(s, enc);
             if (withLengthPrefix) appendInt(tmpBuf.byteLength);
             buf = Buffer.concat([buf, tmpBuf]);
         };
-        const appendEncBase64 = (b64): void => {
+        const appendEncBase64 = (b64: string): void => {
             const b = decodeBase64(b64);
             const tmpBuf = Buffer.from(b);
             buf = Buffer.concat([buf, tmpBuf]);
@@ -307,7 +307,7 @@ export class QRCodeData {
         appendStr(qrData.prefix, "ascii", false);
         appendByte(qrData.version);
         appendByte(qrData.mode);
-        appendStr(qrData.transactionId, "utf-8");
+        appendStr(qrData.transactionId!, "utf-8");
         appendEncBase64(qrData.firstKeyB64);
         appendEncBase64(qrData.secondKeyB64);
         appendEncBase64(qrData.secretB64);
diff --git a/src/crypto/verification/SAS.ts b/src/crypto/verification/SAS.ts
index 5df6d48f6c8..168a85d28fc 100644
--- a/src/crypto/verification/SAS.ts
+++ b/src/crypto/verification/SAS.ts
@@ -140,7 +140,7 @@ function generateEmojiSas(sasBytes: number[]): EmojiMapping[] {
 const sasGenerators = {
     decimal: generateDecimalSas,
     emoji: generateEmojiSas,
-};
+} as const;
 
 export interface IGeneratedSas {
     decimal?: [number, number, number];
@@ -154,11 +154,12 @@ export interface ISasEvent {
     mismatch(): void;
 }
 
-function generateSas(sasBytes: number[], methods: string[]): IGeneratedSas {
+function generateSas(sasBytes: Uint8Array, methods: string[]): IGeneratedSas {
     const sas: IGeneratedSas = {};
     for (const method of methods) {
         if (method in sasGenerators) {
-            sas[method] = sasGenerators[method](sasBytes);
+            // @ts-ignore - ts doesn't like us mixing types like this
+            sas[method] = sasGenerators[method](Array.from(sasBytes));
         }
     }
     return sas;
@@ -168,15 +169,14 @@ const macMethods = {
     "hkdf-hmac-sha256": "calculate_mac",
     "org.matrix.msc3783.hkdf-hmac-sha256": "calculate_mac_fixed_base64",
     "hmac-sha256": "calculate_mac_long_kdf",
-};
+} as const;
 
-type Method = keyof typeof macMethods;
+type MacMethod = keyof typeof macMethods;
 
-function calculateMAC(olmSAS: OlmSAS, method: Method) {
-    return function(...args): string {
-        const macFunction = olmSAS[macMethods[method]];
-        const mac: string = macFunction.apply(olmSAS, args);
-        logger.log("SAS calculateMAC:", method, args, mac);
+function calculateMAC(olmSAS: OlmSAS, method: MacMethod) {
+    return function(input: string, info: string): string {
+        const mac = olmSAS[macMethods[method]](input, info);
+        logger.log("SAS calculateMAC:", method, [input, info], mac);
         return mac;
     };
 }
@@ -202,15 +202,17 @@ const calculateKeyAgreement = {
               + sas.channel.transactionId;
         return olmSAS.generate_bytes(sasInfo, bytes);
     },
-};
+} as const;
+
+type KeyAgreement = keyof typeof calculateKeyAgreement;
 
 /* lists of algorithms/methods that are supported.  The key agreement, hashes,
  * and MAC lists should be sorted in order of preference (most preferred
  * first).
  */
-const KEY_AGREEMENT_LIST = ["curve25519-hkdf-sha256", "curve25519"];
+const KEY_AGREEMENT_LIST: KeyAgreement[] = ["curve25519-hkdf-sha256", "curve25519"];
 const HASHES_LIST = ["sha256"];
-const MAC_LIST: Method[] = ["org.matrix.msc3783.hkdf-hmac-sha256", "hkdf-hmac-sha256", "hmac-sha256"];
+const MAC_LIST: MacMethod[] = ["org.matrix.msc3783.hkdf-hmac-sha256", "hkdf-hmac-sha256", "hmac-sha256"];
 const SAS_LIST = Object.keys(sasGenerators);
 
 const KEY_AGREEMENT_SET = new Set(KEY_AGREEMENT_LIST);
@@ -299,10 +301,10 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
     }
 
     private async verifyAndCheckMAC(
-        keyAgreement: string,
+        keyAgreement: KeyAgreement,
         sasMethods: string[],
         olmSAS: OlmSAS,
-        macMethod: Method,
+        macMethod: MacMethod,
     ): Promise<void> {
         const sasBytes = calculateKeyAgreement[keyAgreement](this, olmSAS, 6);
         const verifySAS = new Promise<void>((resolve, reject) => {
@@ -354,7 +356,7 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
             throw new SwitchStartEventError(this.startEvent);
         }
 
-        let e;
+        let e: MatrixEvent;
         try {
             e = await this.waitForEvent(EventType.KeyVerificationAccept);
         } finally {
@@ -445,8 +447,8 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
         }
     }
 
-    private sendMAC(olmSAS: OlmSAS, method: Method): Promise<void> {
-        const mac = {};
+    private sendMAC(olmSAS: OlmSAS, method: MacMethod): Promise<void> {
+        const mac: Record<string, string> = {};
         const keyList: string[] = [];
         const baseInfo = "MATRIX_KEY_VERIFICATION_MAC"
               + this.baseApis.getUserId() + this.baseApis.deviceId
@@ -455,7 +457,7 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
 
         const deviceKeyId = `ed25519:${this.baseApis.deviceId}`;
         mac[deviceKeyId] = calculateMAC(olmSAS, method)(
-            this.baseApis.getDeviceEd25519Key(),
+            this.baseApis.getDeviceEd25519Key()!,
             baseInfo + deviceKeyId,
         );
         keyList.push(deviceKeyId);
@@ -477,7 +479,7 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
         return this.send(EventType.KeyVerificationMac, { mac, keys });
     }
 
-    private async checkMAC(olmSAS: OlmSAS, content: IContent, method: Method): Promise<void> {
+    private async checkMAC(olmSAS: OlmSAS, content: IContent, method: MacMethod): Promise<void> {
         const baseInfo = "MATRIX_KEY_VERIFICATION_MAC"
               + this.userId + this.deviceId
               + this.baseApis.getUserId() + this.baseApis.deviceId
diff --git a/src/filter-component.ts b/src/filter-component.ts
index 85afb0ea707..0bda7d3792d 100644
--- a/src/filter-component.ts
+++ b/src/filter-component.ts
@@ -148,17 +148,17 @@ export class FilterComponent {
             "types": function(v: string): boolean {
                 return matchesWildcard(eventType, v);
             },
-        };
+        } as const;
 
         for (const name in literalKeys) {
-            const matchFunc = literalKeys[name];
+            const matchFunc = literalKeys[<keyof typeof literalKeys>name];
             const notName = "not_" + name;
-            const disallowedValues: string[] = this.filterJson[notName];
+            const disallowedValues = this.filterJson[<`not_${keyof typeof literalKeys}`>notName];
             if (disallowedValues?.some(matchFunc)) {
                 return false;
             }
 
-            const allowedValues: string[] = this.filterJson[name];
+            const allowedValues = this.filterJson[name as keyof typeof literalKeys];
             if (allowedValues && !allowedValues.some(matchFunc)) {
                 return false;
             }
diff --git a/src/filter.ts b/src/filter.ts
index 57bd0540d87..66522701730 100644
--- a/src/filter.ts
+++ b/src/filter.ts
@@ -31,8 +31,8 @@ import { MatrixEvent } from "./models/event";
  * @param {string} keyNesting
  * @param {*} val
  */
-function setProp(obj: object, keyNesting: string, val: any): void {
-    const nestedKeys = keyNesting.split(".");
+function setProp(obj: Record<string, any>, keyNesting: string, val: any): void {
+    const nestedKeys = keyNesting.split(".") as [keyof typeof obj];
     let currentObj = obj;
     for (let i = 0; i < (nestedKeys.length - 1); i++) {
         if (!currentObj[nestedKeys[i]]) {
@@ -70,8 +70,7 @@ interface IStateFilter extends IRoomEventFilter {}
 
 interface IRoomFilter {
     not_rooms?: string[];
-    rooms?: string[];
-    ephemeral?: IRoomEventFilter;
+    rooms?: string[];ephemeral?: IRoomEventFilter;
     include_leave?: boolean;
     state?: IStateFilter;
     timeline?: IRoomEventFilter;
diff --git a/src/models/event.ts b/src/models/event.ts
index c233307d4eb..2864aa6b520 100644
--- a/src/models/event.ts
+++ b/src/models/event.ts
@@ -318,19 +318,19 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         // 'membership' at the event level (rather than the content level) is a legacy
         // field that Element never otherwise looks at, but it will still take up a lot
         // of space if we don't intern it.
-        ["state_key", "type", "sender", "room_id", "membership"].forEach((prop) => {
+        (["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"].forEach((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"].forEach((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;
@@ -1120,7 +1120,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
         for (const key in this.event) {
             if (this.event.hasOwnProperty(key) && !REDACT_KEEP_KEYS.has(key)) {
-                delete this.event[key];
+                delete this.event[key as keyof IEvent];
             }
         }
 
@@ -1129,7 +1129,9 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
             this.clearEvent = undefined;
         }
 
-        const keeps = REDACT_KEEP_CONTENT_MAP[this.getType()] || {};
+        const keeps = this.getType() in REDACT_KEEP_CONTENT_MAP
+            ? REDACT_KEEP_CONTENT_MAP[this.getType() as keyof typeof REDACT_KEEP_CONTENT_MAP]
+            : {};
         const content = this.getContent();
         for (const key in content) {
             if (content.hasOwnProperty(key) && !keeps[key]) {
@@ -1212,7 +1214,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * @returns {object} The redaction event JSON, or an empty object
      */
-    public getRedactionEvent(): object | null {
+    public getRedactionEvent(): IEvent | {} | null {
         if (!this.isRedacted()) return null;
 
         if (this.clearEvent?.unsigned) {
@@ -1512,7 +1514,8 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         const ev = new MatrixEvent(JSON.parse(JSON.stringify(this.event)));
         for (const [p, v] of Object.entries(this)) {
             if (p !== "event") { // exclude the thing we just cloned
-                ev[p] = v;
+                // @ts-ignore - XXX: this is just nasty
+                ev[p as keyof MatrixEvent] = v;
             }
         }
         return ev;
@@ -1612,7 +1615,7 @@ const REDACT_KEEP_KEYS = new Set([
 ]);
 
 // a map from state event type to the .content keys we keep when an event is redacted
-const REDACT_KEEP_CONTENT_MAP = {
+const REDACT_KEEP_CONTENT_MAP: Record<string, Record<string, 1>> = {
     [EventType.RoomMember]: { 'membership': 1 },
     [EventType.RoomCreate]: { 'creator': 1 },
     [EventType.RoomJoinRules]: { 'join_rule': 1 },
@@ -1621,7 +1624,7 @@ const REDACT_KEEP_CONTENT_MAP = {
         'kick': 1, 'redact': 1, 'state_default': 1,
         'users': 1, 'users_default': 1,
     },
-};
+} as const;
 
 /**
  * Fires when an event is decrypted
diff --git a/src/models/invites-ignorer.ts b/src/models/invites-ignorer.ts
index ad48fe5633f..907d1ca176c 100644
--- a/src/models/invites-ignorer.ts
+++ b/src/models/invites-ignorer.ts
@@ -17,7 +17,7 @@ limitations under the License.
 import { UnstableValue } from "matrix-events-sdk";
 
 import { MatrixClient } from "../client";
-import { MatrixEvent } from "./event";
+import { IContent, MatrixEvent } from "./event";
 import { EventTimeline } from "./event-timeline";
 import { Preset } from "../@types/partials";
 import { globToRegexp } from "../utils";
@@ -262,7 +262,7 @@ export class IgnoredInvites {
      */
     public async getOrCreateSourceRooms(): Promise<Room[]> {
         const ignoreInvitesPolicies = this.getIgnoreInvitesPolicies();
-        let sources = ignoreInvitesPolicies.sources;
+        let sources: string[] = ignoreInvitesPolicies.sources;
 
         // Validate `sources`. If it is invalid, trash out the current `sources`
         // and create a new list of sources from `target`.
@@ -272,11 +272,11 @@ export class IgnoredInvites {
             hasChanges = true;
             sources = [];
         }
-        let sourceRooms: Room[] = sources
+        let sourceRooms = sources
             // `sources` could contain non-string / invalid room ids
             .filter(roomId => typeof roomId === "string")
             .map(roomId => this.client.getRoom(roomId))
-            .filter(room => !!room);
+            .filter(room => !!room) as Room[];
         if (sourceRooms.length != sources.length) {
             hasChanges = true;
         }
@@ -327,7 +327,7 @@ export class IgnoredInvites {
      */
     private getPoliciesAndIgnoreInvitesPolicies():
         {policies: {[key: string]: any}, ignoreInvitesPolicies: {[key: string]: any}} {
-        let policies = {};
+        let policies: IContent = {};
         for (const key of [POLICIES_ACCOUNT_EVENT_TYPE.name, POLICIES_ACCOUNT_EVENT_TYPE.altName]) {
             if (!key) {
                 continue;
diff --git a/src/models/room-state.ts b/src/models/room-state.ts
index 523201d8323..e69d9515268 100644
--- a/src/models/room-state.ts
+++ b/src/models/room-state.ts
@@ -22,7 +22,7 @@ import { RoomMember } from "./room-member";
 import { logger } from '../logger';
 import * as utils from "../utils";
 import { EventType, UNSTABLE_MSC2716_MARKER } from "../@types/event";
-import { MatrixEvent, MatrixEventEvent } from "./event";
+import { IEvent, MatrixEvent, MatrixEventEvent } from "./event";
 import { MatrixClient } from "../client";
 import { GuestAccess, HistoryVisibility, IJoinRuleEventContent, JoinRule } from "../@types/partials";
 import { TypedEventEmitter } from "./typed-event-emitter";
@@ -53,6 +53,20 @@ enum OobStatus {
     Finished,
 }
 
+export interface IPowerLevelsContent {
+    users?: Record<string, number>;
+    events?: Record<string, number>;
+    // eslint-disable-next-line camelcase
+    users_default?: number;
+    // eslint-disable-next-line camelcase
+    events_default?: number;
+    // eslint-disable-next-line camelcase
+    state_default?: number;
+    ban?: number;
+    kick?: number;
+    redact?: number;
+}
+
 export enum RoomStateEvent {
     Events = "RoomState.events",
     Members = "RoomState.members",
@@ -499,7 +513,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
             const beacon = this.beacons.get(beaconIdentifier)!;
 
             if (event.isRedacted()) {
-                if (beacon.beaconInfoId === event.getRedactionEvent()?.['redacts']) {
+                if (beacon.beaconInfoId === (<IEvent>event.getRedactionEvent())?.redacts) {
                     beacon.destroy();
                     this.beacons.delete(beaconIdentifier);
                 }
@@ -724,17 +738,17 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * @param {number} powerLevel The power level of the member
      * @return {boolean} true if the given power level is sufficient
      */
-    public hasSufficientPowerLevelFor(action: string, powerLevel: number): boolean {
+    public hasSufficientPowerLevelFor(action: "ban" | "kick" | "redact", powerLevel: number): boolean {
         const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, "");
 
-        let powerLevels = {};
+        let powerLevels: IPowerLevelsContent = {};
         if (powerLevelsEvent) {
             powerLevels = powerLevelsEvent.getContent();
         }
 
         let requiredLevel = 50;
         if (utils.isNumber(powerLevels[action])) {
-            requiredLevel = powerLevels[action];
+            requiredLevel = powerLevels[action]!;
         }
 
         return powerLevel >= requiredLevel;
@@ -807,8 +821,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     private maySendEventOfType(eventType: EventType | string, userId: string, state: boolean): boolean {
         const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, '');
 
-        let powerLevels;
-        let eventsLevels = {};
+        let powerLevels: IPowerLevelsContent;
+        let eventsLevels: Record<EventType | string, number> = {};
 
         let stateDefault = 0;
         let eventsDefault = 0;
@@ -818,20 +832,20 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
             eventsLevels = powerLevels.events || {};
 
             if (Number.isSafeInteger(powerLevels.state_default)) {
-                stateDefault = powerLevels.state_default;
+                stateDefault = powerLevels.state_default!;
             } else {
                 stateDefault = 50;
             }
 
             const userPowerLevel = powerLevels.users && powerLevels.users[userId];
             if (Number.isSafeInteger(userPowerLevel)) {
-                powerLevel = userPowerLevel;
+                powerLevel = userPowerLevel!;
             } else if (Number.isSafeInteger(powerLevels.users_default)) {
-                powerLevel = powerLevels.users_default;
+                powerLevel = powerLevels.users_default!;
             }
 
             if (Number.isSafeInteger(powerLevels.events_default)) {
-                eventsDefault = powerLevels.events_default;
+                eventsDefault = powerLevels.events_default!;
             }
         }
 
@@ -877,7 +891,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      */
     public getJoinRule(): JoinRule {
         const joinRuleEvent = this.getStateEvents(EventType.RoomJoinRules, "");
-        const joinRuleContent = joinRuleEvent?.getContent<IJoinRuleEventContent>() ?? {};
+        const joinRuleContent: Partial<IJoinRuleEventContent> = joinRuleEvent?.getContent() ?? {};
         return joinRuleContent["join_rule"] || JoinRule.Invite;
     }
 
diff --git a/src/models/room-summary.ts b/src/models/room-summary.ts
index ba279d2d4fc..218a4afcc8d 100644
--- a/src/models/room-summary.ts
+++ b/src/models/room-summary.ts
@@ -20,8 +20,8 @@ limitations under the License.
 
 export interface IRoomSummary {
     "m.heroes": string[];
-    "m.joined_member_count": number;
-    "m.invited_member_count": number;
+    "m.joined_member_count"?: number;
+    "m.invited_member_count"?: number;
 }
 
 interface IInfo {
diff --git a/src/models/room.ts b/src/models/room.ts
index 3952ed7d9cb..4c3ebafbe82 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -1312,10 +1312,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         const joinedCount = summary["m.joined_member_count"];
         const invitedCount = summary["m.invited_member_count"];
         if (Number.isInteger(joinedCount)) {
-            this.currentState.setJoinedMemberCount(joinedCount);
+            this.currentState.setJoinedMemberCount(joinedCount!);
         }
         if (Number.isInteger(invitedCount)) {
-            this.currentState.setInvitedMemberCount(invitedCount);
+            this.currentState.setInvitedMemberCount(invitedCount!);
         }
         if (Array.isArray(heroes)) {
             // be cautious about trusting server values,
@@ -1826,7 +1826,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             timelineSet.getFilter(),
         );
 
-        timelineSet.getLiveTimeline().setPaginationToken(end, Direction.Backward);
+        timelineSet.getLiveTimeline().setPaginationToken(end ?? null, Direction.Backward);
 
         if (!events.length) return;
 
diff --git a/src/pushprocessor.ts b/src/pushprocessor.ts
index 4538b97214e..cc124682591 100644
--- a/src/pushprocessor.ts
+++ b/src/pushprocessor.ts
@@ -518,13 +518,13 @@ export class PushProcessor {
      * @return {object} The push rule, or null if no such rule was found
      */
     public getPushRuleById(ruleId: string): IPushRule | null {
-        for (const scope of ['global']) {
+        for (const scope of ['global'] as const) {
             if (this.client.pushRules?.[scope] === undefined) continue;
 
             for (const kind of RULEKINDS_IN_ORDER) {
                 if (this.client.pushRules[scope][kind] === undefined) continue;
 
-                for (const rule of this.client.pushRules[scope][kind]) {
+                for (const rule of this.client.pushRules[scope][kind]!) {
                     if (rule.rule_id === ruleId) return rule;
                 }
             }
diff --git a/src/scheduler.ts b/src/scheduler.ts
index 0c15032bcac..74bf7dd2580 100644
--- a/src/scheduler.ts
+++ b/src/scheduler.ts
@@ -97,7 +97,7 @@ export class MatrixScheduler<T = ISendEventResponse> {
      * @see module:scheduler~queueAlgorithm
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    public static QUEUE_MESSAGES(event: MatrixEvent): "message" | null {
+    public static QUEUE_MESSAGES(event: MatrixEvent): string | null {
         // enqueue messages or events that associate with another event (redactions and relations)
         if (event.getType() === EventType.RoomMessage || event.hasAssociation()) {
             // put these events in the 'message' queue.
diff --git a/src/sliding-sync-sdk.ts b/src/sliding-sync-sdk.ts
index c99f61f13b9..d103eb39bea 100644
--- a/src/sliding-sync-sdk.ts
+++ b/src/sliding-sync-sdk.ts
@@ -22,7 +22,7 @@ import { ClientEvent, IStoredClientOpts, MatrixClient, PendingEventOrdering } fr
 import { ISyncStateData, SyncState, _createAndReEmitRoom } from "./sync";
 import { MatrixEvent } from "./models/event";
 import { Crypto } from "./crypto";
-import { IMinimalEvent, IRoomEvent, IStateEvent, IStrippedState } from "./sync-accumulator";
+import { IMinimalEvent, IRoomEvent, IStateEvent, IStrippedState, ISyncResponse } from "./sync-accumulator";
 import { MatrixError } from "./http-api";
 import {
     Extension,
@@ -44,7 +44,18 @@ import { RoomMemberEvent } from "./models/room-member";
 // keepAlive is successful but the server /sync fails.
 const FAILED_SYNC_ERROR_THRESHOLD = 3;
 
-class ExtensionE2EE implements Extension {
+type ExtensionE2EERequest = {
+    enabled: boolean;
+};
+
+type ExtensionE2EEResponse = Pick<ISyncResponse,
+    "device_lists" |
+    "device_one_time_keys_count" |
+    "device_unused_fallback_key_types" |
+    "org.matrix.msc2732.device_unused_fallback_key_types"
+>;
+
+class ExtensionE2EE implements Extension<ExtensionE2EERequest, ExtensionE2EEResponse> {
     public constructor(private readonly crypto: Crypto) {}
 
     public name(): string {
@@ -55,7 +66,7 @@ class ExtensionE2EE implements Extension {
         return ExtensionState.PreProcess;
     }
 
-    public onRequest(isInitial: boolean): object | undefined {
+    public onRequest(isInitial: boolean): ExtensionE2EERequest | undefined {
         if (!isInitial) {
             return undefined;
         }
@@ -64,7 +75,7 @@ class ExtensionE2EE implements Extension {
         };
     }
 
-    public async onResponse(data: object): Promise<void> {
+    public async onResponse(data: ExtensionE2EEResponse): Promise<void> {
         // Handle device list updates
         if (data["device_lists"]) {
             await this.crypto.handleDeviceListChanges({
@@ -92,7 +103,18 @@ class ExtensionE2EE implements Extension {
     }
 }
 
-class ExtensionToDevice implements Extension {
+type ExtensionToDeviceRequest = {
+    since?: string;
+    limit?: number;
+    enabled?: boolean;
+};
+
+type ExtensionToDeviceResponse = {
+    events: Required<ISyncResponse>["to_device"]["events"];
+    next_batch: string | null;
+};
+
+class ExtensionToDevice implements Extension<ExtensionToDeviceRequest, ExtensionToDeviceResponse> {
     private nextBatch: string | null = null;
 
     public constructor(private readonly client: MatrixClient) {}
@@ -105,8 +127,8 @@ class ExtensionToDevice implements Extension {
         return ExtensionState.PreProcess;
     }
 
-    public onRequest(isInitial: boolean): object {
-        const extReq = {
+    public onRequest(isInitial: boolean): ExtensionToDeviceRequest {
+        const extReq: ExtensionToDeviceRequest = {
             since: this.nextBatch !== null ? this.nextBatch : undefined,
         };
         if (isInitial) {
@@ -116,11 +138,10 @@ class ExtensionToDevice implements Extension {
         return extReq;
     }
 
-    public async onResponse(data: object): Promise<void> {
+    public async onResponse(data: ExtensionToDeviceResponse): Promise<void> {
         const cancelledKeyVerificationTxns: string[] = [];
-        data["events"] = data["events"] || [];
-        data["events"]
-            .map(this.client.getEventMapper())
+        data.events
+            ?.map(this.client.getEventMapper())
             .map((toDeviceEvent) => { // map is a cheap inline forEach
                 // We want to flag m.key.verification.start events as cancelled
                 // if there's an accompanying m.key.verification.cancel event, so
@@ -165,11 +186,20 @@ class ExtensionToDevice implements Extension {
                 },
             );
 
-        this.nextBatch = data["next_batch"];
+        this.nextBatch = data.next_batch;
     }
 }
 
-class ExtensionAccountData implements Extension {
+type ExtensionAccountDataRequest = {
+    enabled: boolean;
+};
+
+type ExtensionAccountDataResponse = {
+    global: IMinimalEvent[];
+    rooms: Record<string, IMinimalEvent[]>;
+};
+
+class ExtensionAccountData implements Extension<ExtensionAccountDataRequest, ExtensionAccountDataResponse> {
     public constructor(private readonly client: MatrixClient) {}
 
     public name(): string {
@@ -180,7 +210,7 @@ class ExtensionAccountData implements Extension {
         return ExtensionState.PostProcess;
     }
 
-    public onRequest(isInitial: boolean): object | undefined {
+    public onRequest(isInitial: boolean): ExtensionAccountDataRequest | undefined {
         if (!isInitial) {
             return undefined;
         }
@@ -189,7 +219,7 @@ class ExtensionAccountData implements Extension {
         };
     }
 
-    public onResponse(data: {global: object[], rooms: Record<string, object[]>}): void {
+    public onResponse(data: ExtensionAccountDataResponse): void {
         if (data.global && data.global.length > 0) {
             this.processGlobalAccountData(data.global);
         }
@@ -208,9 +238,9 @@ class ExtensionAccountData implements Extension {
         }
     }
 
-    private processGlobalAccountData(globalAccountData: object[]): void {
+    private processGlobalAccountData(globalAccountData: IMinimalEvent[]): void {
         const events = mapEvents(this.client, undefined, globalAccountData);
-        const prevEventsMap = events.reduce((m, c) => {
+        const prevEventsMap = events.reduce<Record<string, MatrixEvent | undefined>>((m, c) => {
             m[c.getType()] = this.client.store.getAccountData(c.getType());
             return m;
         }, {});
@@ -233,7 +263,15 @@ class ExtensionAccountData implements Extension {
     }
 }
 
-class ExtensionTyping implements Extension {
+type ExtensionTypingRequest = {
+    enabled: boolean;
+};
+
+type ExtensionTypingResponse = {
+    rooms: Record<string, IMinimalEvent>;
+};
+
+class ExtensionTyping implements Extension<ExtensionTypingRequest, ExtensionTypingResponse> {
     public constructor(private readonly client: MatrixClient) {}
 
     public name(): string {
@@ -244,7 +282,7 @@ class ExtensionTyping implements Extension {
         return ExtensionState.PostProcess;
     }
 
-    public onRequest(isInitial: boolean): object | undefined {
+    public onRequest(isInitial: boolean): ExtensionTypingRequest | undefined {
         if (!isInitial) {
             return undefined; // don't send a JSON object for subsequent requests, we don't need to.
         }
@@ -253,20 +291,26 @@ class ExtensionTyping implements Extension {
         };
     }
 
-    public onResponse(data: {rooms: Record<string, IMinimalEvent>}): void {
-        if (!data || !data.rooms) {
+    public onResponse(data: ExtensionTypingResponse): void {
+        if (!data?.rooms) {
             return;
         }
 
         for (const roomId in data.rooms) {
-            processEphemeralEvents(
-                this.client, roomId, [data.rooms[roomId]],
-            );
+            processEphemeralEvents(this.client, roomId, [data.rooms[roomId]]);
         }
     }
 }
 
-class ExtensionReceipts implements Extension {
+type ExtensionReceiptsRequest = {
+    enabled: boolean;
+};
+
+type ExtensionReceiptsResponse = {
+    rooms: Record<string, IMinimalEvent>;
+};
+
+class ExtensionReceipts implements Extension<ExtensionReceiptsRequest, ExtensionReceiptsResponse> {
     public constructor(private readonly client: MatrixClient) {}
 
     public name(): string {
@@ -277,7 +321,7 @@ class ExtensionReceipts implements Extension {
         return ExtensionState.PostProcess;
     }
 
-    public onRequest(isInitial: boolean): object | undefined {
+    public onRequest(isInitial: boolean): ExtensionReceiptsRequest | undefined {
         if (isInitial) {
             return {
                 enabled: true,
@@ -286,8 +330,8 @@ class ExtensionReceipts implements Extension {
         return undefined; // don't send a JSON object for subsequent requests, we don't need to.
     }
 
-    public onResponse(data: {rooms: Record<string, IMinimalEvent>}): void {
-        if (!data || !data.rooms) {
+    public onResponse(data: ExtensionReceiptsResponse): void {
+        if (!data?.rooms) {
             return;
         }
 
@@ -336,7 +380,7 @@ export class SlidingSyncSdk {
 
         this.slidingSync.on(SlidingSyncEvent.Lifecycle, this.onLifecycle.bind(this));
         this.slidingSync.on(SlidingSyncEvent.RoomData, this.onRoomData.bind(this));
-        const extensions: Extension[] = [
+        const extensions: Extension<any, any>[] = [
             new ExtensionToDevice(this.client),
             new ExtensionAccountData(this.client),
             new ExtensionTyping(this.client),
@@ -533,7 +577,7 @@ export class SlidingSyncSdk {
         // room::decryptCriticalEvent is in charge of decrypting all the events
         // required for a client to function properly
         let timelineEvents = mapEvents(this.client, room.roomId, roomData.timeline, false);
-        const ephemeralEvents = []; // TODO this.mapSyncEventsFormat(joinObj.ephemeral);
+        const ephemeralEvents: MatrixEvent[] = []; // TODO this.mapSyncEventsFormat(joinObj.ephemeral);
 
         // TODO: handle threaded / beacon events
 
@@ -967,12 +1011,14 @@ function ensureNameEvent(client: MatrixClient, roomId: string, roomData: MSC3575
     return roomData;
 }
 
+type TaggedEvent = (IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent) & { room_id?: string };
+
 // Helper functions which set up JS SDK structs are below and are identical to the sync v2 counterparts,
 // just outside the class.
 function mapEvents(client: MatrixClient, roomId: string | undefined, events: object[], decrypt = true): MatrixEvent[] {
     const mapper = client.getEventMapper({ decrypt });
-    return (events as Array<IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent>).map(function(e) {
-        e["room_id"] = roomId;
+    return (events as TaggedEvent[]).map(function(e) {
+        e.room_id = roomId;
         return mapper(e);
     });
 }
diff --git a/src/sliding-sync.ts b/src/sliding-sync.ts
index cda2737d984..a3daf3af6bf 100644
--- a/src/sliding-sync.ts
+++ b/src/sliding-sync.ts
@@ -139,7 +139,7 @@ export interface MSC3575SlidingSyncResponse {
     txn_id?: string;
     lists: ListResponse[];
     rooms: Record<string, MSC3575RoomData>;
-    extensions: object;
+    extensions: Record<string, object>;
 }
 
 export enum SlidingSyncState {
@@ -265,7 +265,7 @@ export enum ExtensionState {
 /**
  * An interface that must be satisfied to register extensions
  */
-export interface Extension {
+export interface Extension<Req extends {}, Res extends {}> {
     /**
      * The extension name to go under 'extensions' in the request body.
      * @returns The JSON key.
@@ -277,12 +277,12 @@ export interface Extension {
      * @param isInitial True when this is part of the initial request (send sticky params)
      * @returns The request JSON to send.
      */
-    onRequest(isInitial: boolean): object | undefined;
+    onRequest(isInitial: boolean): Req | undefined;
     /**
      * A function which is called when there is response JSON under this extension.
      * @param data The response JSON under the extension name.
      */
-    onResponse(data: object);
+    onResponse(data: Res): void;
     /**
      * Controls when onResponse should be called.
      * @returns The state when it should be called.
@@ -353,7 +353,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     // a defer to resolve/reject depending on whether they were successfully sent or not.
     private txnIdDefers: (IDeferred<string> & { txnId: string})[] = [];
     // map of extension name to req/resp handler
-    private extensions: Record<string, Extension> = {};
+    private extensions: Record<string, Extension<any, any>> = {};
 
     private desiredRoomSubscriptions = new Set<string>(); // the *desired* room subscriptions
     private confirmedRoomSubscriptions = new Set<string>();
@@ -519,22 +519,22 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
      * Register an extension to send with the /sync request.
      * @param ext The extension to register.
      */
-    public registerExtension(ext: Extension): void {
+    public registerExtension(ext: Extension<any, any>): void {
         if (this.extensions[ext.name()]) {
             throw new Error(`registerExtension: ${ext.name()} already exists as an extension`);
         }
         this.extensions[ext.name()] = ext;
     }
 
-    private getExtensionRequest(isInitial: boolean): object {
-        const ext = {};
+    private getExtensionRequest(isInitial: boolean): Record<string, object | undefined> {
+        const ext: Record<string, object | undefined> = {};
         Object.keys(this.extensions).forEach((extName) => {
             ext[extName] = this.extensions[extName].onRequest(isInitial);
         });
         return ext;
     }
 
-    private onPreExtensionsResponse(ext: object): void {
+    private onPreExtensionsResponse(ext: Record<string, object>): void {
         Object.keys(ext).forEach((extName) => {
             if (this.extensions[extName].when() == ExtensionState.PreProcess) {
                 this.extensions[extName].onResponse(ext[extName]);
@@ -542,7 +542,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
         });
     }
 
-    private onPostExtensionsResponse(ext: object): void {
+    private onPostExtensionsResponse(ext: Record<string, object>): void {
         Object.keys(ext).forEach((extName) => {
             if (this.extensions[extName].when() == ExtensionState.PostProcess) {
                 this.extensions[extName].onResponse(ext[extName]);
diff --git a/src/store/index.ts b/src/store/index.ts
index bed7aa7a69c..3edba926977 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -123,7 +123,7 @@ export interface IStore {
      * @param {string} token The token associated with these events.
      * @param {boolean} toStart True if these are paginated results.
      */
-    storeEvents(room: Room, events: MatrixEvent[], token: string, toStart: boolean): void;
+    storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void;
 
     /**
      * Store a filter.
diff --git a/src/store/indexeddb-local-backend.ts b/src/store/indexeddb-local-backend.ts
index af4b5fc6519..2b94af25600 100644
--- a/src/store/indexeddb-local-backend.ts
+++ b/src/store/indexeddb-local-backend.ts
@@ -315,10 +315,10 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
 
         const minStateKeyProm = reqAsCursorPromise(
             roomIndex.openKeyCursor(roomRange, "next"),
-        ).then((cursor) => cursor && cursor.primaryKey[1]);
+        ).then((cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1]);
         const maxStateKeyProm = reqAsCursorPromise(
             roomIndex.openKeyCursor(roomRange, "prev"),
-        ).then((cursor) => cursor && cursor.primaryKey[1]);
+        ).then((cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1]);
         const [minStateKey, maxStateKey] = await Promise.all(
             [minStateKeyProm, maxStateKeyProm]);
 
diff --git a/src/store/memory.ts b/src/store/memory.ts
index f24ab2d976d..1fcb6b0c865 100644
--- a/src/store/memory.ts
+++ b/src/store/memory.ts
@@ -217,7 +217,7 @@ export class MemoryStore implements IStore {
      * @param {string} token The token associated with these events.
      * @param {boolean} toStart True if these are paginated results.
      */
-    public storeEvents(room: Room, events: MatrixEvent[], token: string, toStart: boolean): void {
+    public storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void {
         // no-op because they've already been added to the room instance.
     }
 
diff --git a/src/store/stub.ts b/src/store/stub.ts
index 746bc521ffb..74234393879 100644
--- a/src/store/stub.ts
+++ b/src/store/stub.ts
@@ -139,7 +139,7 @@ export class StubStore implements IStore {
      * @param {string} token The token associated with these events.
      * @param {boolean} toStart True if these are paginated results.
      */
-    public storeEvents(room: Room, events: MatrixEvent[], token: string, toStart: boolean): void {}
+    public storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void {}
 
     /**
      * Store a filter.
diff --git a/src/sync-accumulator.ts b/src/sync-accumulator.ts
index 19d5cf1312e..f383cb98a4a 100644
--- a/src/sync-accumulator.ts
+++ b/src/sync-accumulator.ts
@@ -116,7 +116,7 @@ interface IAccountData {
     events: IMinimalEvent[];
 }
 
-interface IToDeviceEvent {
+export interface IToDeviceEvent {
     content: IContent;
     sender: string;
     type: string;
@@ -127,8 +127,8 @@ interface IToDevice {
 }
 
 interface IDeviceLists {
-    changed: string[];
-    left: string[];
+    changed?: string[];
+    left?: string[];
 }
 
 export interface ISyncResponse {
@@ -139,6 +139,9 @@ export interface ISyncResponse {
     to_device?: IToDevice;
     device_lists?: IDeviceLists;
     device_one_time_keys_count?: Record<string, number>;
+
+    device_unused_fallback_key_types?: string[];
+    "org.matrix.msc2732.device_unused_fallback_key_types"?: string[];
 }
 /* eslint-enable camelcase */
 
@@ -182,6 +185,12 @@ export interface ISyncData {
     roomsData: IRooms;
 }
 
+type TaggedEvent = IRoomEvent & { _localTs?: number };
+
+function isTaggedEvent(event: IRoomEvent): event is TaggedEvent {
+    return "_localTs" in event && event["_localTs"] !== undefined;
+}
+
 /**
  * The purpose of this class is to accumulate /sync responses such that a
  * complete "initial" JSON response can be returned which accurately represents
@@ -473,35 +482,31 @@ export class SyncAccumulator {
         // - existing state which didn't come down /sync.
         // - State events under the 'state' key.
         // - State events in the 'timeline'.
-        if (data.state && data.state.events) {
-            data.state.events.forEach((e) => {
-                setState(currentData._currentState, e);
-            });
-        }
-        if (data.timeline && data.timeline.events) {
-            data.timeline.events.forEach((e, index) => {
-                // this nops if 'e' isn't a state event
-                setState(currentData._currentState, e);
-                // append the event to the timeline. The back-pagination token
-                // corresponds to the first event in the timeline
-                let transformedEvent: IRoomEvent & { _localTs?: number };
-                if (!fromDatabase) {
-                    transformedEvent = Object.assign({}, e);
-                    if (transformedEvent.unsigned !== undefined) {
-                        transformedEvent.unsigned = Object.assign({}, transformedEvent.unsigned);
-                    }
-                    const age = e.unsigned ? e.unsigned.age : e.age;
-                    if (age !== undefined) transformedEvent._localTs = Date.now() - age;
-                } else {
-                    transformedEvent = e;
+        data.state?.events?.forEach((e) => {
+            setState(currentData._currentState, e);
+        });
+        data.timeline?.events?.forEach((e, index) => {
+            // this nops if 'e' isn't a state event
+            setState(currentData._currentState, e);
+            // append the event to the timeline. The back-pagination token
+            // corresponds to the first event in the timeline
+            let transformedEvent: TaggedEvent;
+            if (!fromDatabase) {
+                transformedEvent = Object.assign({}, e);
+                if (transformedEvent.unsigned !== undefined) {
+                    transformedEvent.unsigned = Object.assign({}, transformedEvent.unsigned);
                 }
+                const age = e.unsigned ? e.unsigned.age : e.age;
+                if (age !== undefined) transformedEvent._localTs = Date.now() - age;
+            } else {
+                transformedEvent = e;
+            }
 
-                currentData._timeline.push({
-                    event: transformedEvent,
-                    token: index === 0 ? (data.timeline.prev_batch ?? null) : null,
-                });
+            currentData._timeline.push({
+                event: transformedEvent,
+                token: index === 0 ? (data.timeline.prev_batch ?? null) : null,
             });
-        }
+        });
 
         // attempt to prune the timeline by jumping between events which have
         // pagination tokens.
@@ -581,7 +586,7 @@ export class SyncAccumulator {
                 room_id: roomId,
                 content: {
                     // $event_id: { "m.read": { $user_id: $json } }
-                },
+                } as IContent,
             };
 
             for (const [userId, receiptData] of Object.entries(roomData._readReceipts)) {
@@ -626,8 +631,8 @@ export class SyncAccumulator {
                 }
 
                 let transformedEvent: (IRoomEvent | IStateEvent) & { _localTs?: number };
-                if (!forDatabase && msgData.event["_localTs"]) {
-                    // This means we have to copy each event so we can fix it up to
+                if (!forDatabase && isTaggedEvent(msgData.event)) {
+                    // This means we have to copy each event, so we can fix it up to
                     // set a correct 'age' parameter whilst keeping the local timestamp
                     // on our stored event. If this turns out to be a bottleneck, it could
                     // be optimised either by doing this in the main process after the data
@@ -641,7 +646,7 @@ export class SyncAccumulator {
                     }
                     delete transformedEvent._localTs;
                     transformedEvent.unsigned = transformedEvent.unsigned || {};
-                    transformedEvent.unsigned.age = Date.now() - msgData.event["_localTs"];
+                    transformedEvent.unsigned.age = Date.now() - msgData.event._localTs!;
                 } else {
                     transformedEvent = msgData.event;
                 }
diff --git a/src/sync.ts b/src/sync.ts
index 20cab67b6eb..c97ba35401d 100644
--- a/src/sync.ts
+++ b/src/sync.ts
@@ -106,7 +106,7 @@ function getFilterName(userId: string, suffix?: string): string {
     return `FILTER_SYNC_${userId}` + (suffix ? "_" + suffix : "");
 }
 
-function debuglog(...params): void {
+function debuglog(...params: any[]): void {
     if (!DEBUG) return;
     logger.log(...params);
 }
@@ -1093,7 +1093,7 @@ export class SyncApi {
         // handle non-room account_data
         if (Array.isArray(data.account_data?.events)) {
             const events = data.account_data.events.map(client.getEventMapper());
-            const prevEventsMap = events.reduce((m, c) => {
+            const prevEventsMap = events.reduce<Record<string, MatrixEvent | undefined>>((m, c) => {
                 m[c.getType()!] = client.store.getAccountData(c.getType());
                 return m;
             }, {});
@@ -1473,12 +1473,13 @@ export class SyncApi {
             this.opts.crypto.updateOneTimeKeyCount(currentCount);
         }
         if (this.opts.crypto &&
-            (data["device_unused_fallback_key_types"] ||
-                data["org.matrix.msc2732.device_unused_fallback_key_types"])) {
+            (data.device_unused_fallback_key_types ||
+                data["org.matrix.msc2732.device_unused_fallback_key_types"])
+        ) {
             // The presence of device_unused_fallback_key_types indicates that the
             // server supports fallback keys. If there's no unused
             // signed_curve25519 fallback key we need a new one.
-            const unusedFallbackKeys = data["device_unused_fallback_key_types"] ||
+            const unusedFallbackKeys = data.device_unused_fallback_key_types ||
                 data["org.matrix.msc2732.device_unused_fallback_key_types"];
             this.opts.crypto.setNeedsNewFallback(
                 Array.isArray(unusedFallbackKeys) &&
@@ -1607,9 +1608,10 @@ export class SyncApi {
             return [];
         }
         const mapper = this.client.getEventMapper({ decrypt });
-        return (obj.events as Array<IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent>).map(function(e) {
+        type TaggedEvent = (IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent) & { room_id?: string };
+        return (obj.events as TaggedEvent[]).map(function(e) {
             if (room) {
-                e["room_id"] = room.roomId;
+                e.room_id = room.roomId;
             }
             return mapper(e);
         });
diff --git a/src/utils.ts b/src/utils.ts
index 71871d3b737..ef6af6b0668 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -316,7 +316,7 @@ export function deepSortedObjectEntries(obj: any): [string, any][] {
  * @param {*} value the value to test
  * @return {boolean} whether or not value is a finite number without type-coercion
  */
-export function isNumber(value: any): boolean {
+export function isNumber(value: any): value is number {
     return typeof value === 'number' && isFinite(value);
 }
 
@@ -428,8 +428,8 @@ export interface IDeferred<T> {
 
 // Returns a Deferred
 export function defer<T = void>(): IDeferred<T> {
-    let resolve;
-    let reject;
+    let resolve!: IDeferred<T>["resolve"];
+    let reject!: IDeferred<T>["reject"];
 
     const promise = new Promise<T>((_resolve, _reject) => {
         resolve = _resolve;
@@ -665,18 +665,22 @@ export function compare(a: string, b: string): number {
  * @param {Object} source
  * @returns the target object
  */
-export function recursivelyAssign(target: Object, source: Object, ignoreNullish = false): any {
+export function recursivelyAssign<T1 extends T2, T2 extends Record<string, any>>(
+    target: T1,
+    source: T2,
+    ignoreNullish = false,
+): T1 & T2 {
     for (const [sourceKey, sourceValue] of Object.entries(source)) {
         if (target[sourceKey] instanceof Object && sourceValue) {
             recursivelyAssign(target[sourceKey], sourceValue);
             continue;
         }
         if ((sourceValue !== null && sourceValue !== undefined) || !ignoreNullish) {
-            target[sourceKey] = sourceValue;
+            target[sourceKey as keyof T1] = sourceValue;
             continue;
         }
     }
-    return target;
+    return target as T1 & T2;
 }
 
 function getContentTimestampWithFallback(event: MatrixEvent): number {
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index 178f75608d7..7d303af4a5c 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -27,7 +27,7 @@ import { parse as parseSdp, write as writeSdp } from "sdp-transform";
 
 import { logger } from '../logger';
 import * as utils from '../utils';
-import { MatrixEvent } from '../models/event';
+import { IContent, MatrixEvent } from '../models/event';
 import { EventType, ToDeviceMessageId } from '../@types/event';
 import { RoomMember } from '../models/room-member';
 import { randomString } from '../randomstring';
@@ -1101,7 +1101,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         this.terminate(CallParty.Local, reason, !suppressEvent);
         // We don't want to send hangup here if we didn't even get to sending an invite
         if ([CallState.Fledgling, CallState.WaitLocalMedia].includes(this.state)) return;
-        const content = {};
+        const content: IContent = {};
         // Don't send UserHangup reason to older clients
         if ((this.opponentVersion && this.opponentVersion !== 0) || reason !== CallErrorCode.UserHangup) {
             content["reason"] = reason;
diff --git a/tsconfig.json b/tsconfig.json
index 9644f5c5f77..f34858ce9e4 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,7 +5,6 @@
     "esModuleInterop": true,
     "module": "commonjs",
     "moduleResolution": "node",
-    "noImplicitAny": false,
     "noUnusedLocals": true,
     "noEmit": true,
     "declaration": true,
diff --git a/yarn.lock b/yarn.lock
index 413b7bfc9f1..b96adf0ef9a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1423,9 +1423,9 @@
   dependencies:
     lodash "^4.17.21"
 
-"@matrix-org/olm@https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.13.tgz":
-  version "3.2.13"
-  resolved "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.13.tgz#0109fde93bcc61def851f79826c9384c073b5175"
+"@matrix-org/olm@https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz":
+  version "3.2.14"
+  resolved "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz#acd96c00a881d0f462e1f97a56c73742c8dbc984"
 
 "@nicolo-ribaudo/chokidar-2@2.1.8-no-fsevents.3":
   version "2.1.8-no-fsevents.3"

From a071a82a030250caa1ee526c08d4f3ec34b8dd9d Mon Sep 17 00:00:00 2001
From: Germain <germains@element.io>
Date: Wed, 7 Dec 2022 11:18:32 +0000
Subject: [PATCH 27/60] Update test runner instructions (#2948)

---
 README.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 19592b0ea8f..bb86a6f9431 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
 [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=bugs)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
 
-Matrix Javascript SDK
+Matrix JavaScript SDK
 =====================
 
 This is the [Matrix](https://matrix.org) Client-Server SDK for JavaScript and TypeScript. This SDK can be run in a
@@ -370,11 +370,14 @@ To build a browser version from scratch when developing::
  $ yarn build
 ```
 
-To run tests (Jasmine)::
+To run tests (Jest):
 ```
  $ yarn test
 ```
 
+> **Note**
+> The `sync-browserify.spec.ts` requires a browser build (`yarn build`) in order to pass
+
 To run linting:
 ```
  $ yarn lint

From 4a7365f32fe057b29e90e98598797e40e5aac312 Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 7 Dec 2022 13:06:41 +0000
Subject: [PATCH 28/60] Fix release documentation (#2949)

---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 2655ed6e7e2..721f45b6253 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -36,7 +36,7 @@ jobs:
           tag="${{ github.ref_name }}"
           VERSION="${tag#v}"
           [ ! -e "$VERSION" ] || rm -r $VERSION
-          cp -r $RUNNER_TEMP/docs/ $VERSION
+          cp -r $RUNNER_TEMP/_docs/ $VERSION
 
           # Add the new directory to the index if it isn't there already
           if ! grep -q ">Version $VERSION</a>" index.html; then

From a9e7a46c566ac81523a04e2cc081d13054f713a9 Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Wed, 7 Dec 2022 13:48:41 +0000
Subject: [PATCH 29/60] Upload device keys during initCrypto (#2872)

Rather than waiting for the application to call `.startClient`, upload the
device keys during `initCrypto()`. Element-R is going to approach this slightly
differently (it wants to manage the decision on key uploads itself), so this
lays some groundwork by collecting the libolm-specific bits together.
---
 spec/integ/matrix-client-crypto.spec.ts  | 13 +++++++++----
 spec/integ/matrix-client-methods.spec.ts | 14 +++++++++++++-
 spec/unit/crypto.spec.ts                 |  8 +++++++-
 spec/unit/crypto/backup.spec.ts          | 11 ++++++++++-
 src/client.ts                            | 19 ++++++++-----------
 5 files changed, 47 insertions(+), 18 deletions(-)

diff --git a/spec/integ/matrix-client-crypto.spec.ts b/spec/integ/matrix-client-crypto.spec.ts
index adb7dd25b9a..ae58be1c91c 100644
--- a/spec/integ/matrix-client-crypto.spec.ts
+++ b/spec/integ/matrix-client-crypto.spec.ts
@@ -53,10 +53,7 @@ type OlmPayload = ReturnType<Session["encrypt"]>;
 
 async function bobUploadsDeviceKeys(): Promise<void> {
     bobTestClient.expectDeviceKeyUpload();
-    await Promise.all([
-        bobTestClient.client.uploadKeys(),
-        bobTestClient.httpBackend.flushAllExpected(),
-    ]);
+    await bobTestClient.httpBackend.flushAllExpected();
     expect(Object.keys(bobTestClient.deviceKeys!).length).not.toEqual(0);
 }
 
@@ -383,6 +380,14 @@ describe("MatrixClient crypto", () => {
 
     it("Bob uploads device keys", bobUploadsDeviceKeys);
 
+    it("handles failures to upload device keys", async () => {
+        // since device keys are uploaded asynchronously, there's not really much to do here other than fail the
+        // upload.
+        bobTestClient.httpBackend.when("POST", "/keys/upload")
+            .fail(0, new Error("bleh"));
+        await bobTestClient.httpBackend.flushAllExpected();
+    });
+
     it("Ali downloads Bobs device keys", async () => {
         await bobUploadsDeviceKeys();
         await aliDownloadsKeys();
diff --git a/spec/integ/matrix-client-methods.spec.ts b/spec/integ/matrix-client-methods.spec.ts
index 93c3d353727..c585fb3c5fa 100644
--- a/spec/integ/matrix-client-methods.spec.ts
+++ b/spec/integ/matrix-client-methods.spec.ts
@@ -511,7 +511,12 @@ describe("MatrixClient", function() {
         }
 
         beforeEach(function() {
-            return client!.initCrypto();
+            // running initCrypto should trigger a key upload
+            httpBackend!.when("POST", "/keys/upload").respond(200, {});
+            return Promise.all([
+                client!.initCrypto(),
+                httpBackend!.flush("/keys/upload", 1),
+            ]);
         });
 
         afterEach(() => {
@@ -1371,6 +1376,13 @@ describe("MatrixClient", function() {
             await prom;
         });
     });
+
+    describe("uploadKeys", () => {
+        // uploadKeys() is a no-op nowadays, so there's not much to test here.
+        it("should complete successfully", async () => {
+            await client!.uploadKeys();
+        });
+    });
 });
 
 function withThreadId(event: MatrixEvent, newThreadId: string): MatrixEvent {
diff --git a/spec/unit/crypto.spec.ts b/spec/unit/crypto.spec.ts
index a4e1ec374e0..51d57159d52 100644
--- a/spec/unit/crypto.spec.ts
+++ b/spec/unit/crypto.spec.ts
@@ -995,7 +995,13 @@ describe("Crypto", function() {
             });
 
             client = new TestClient("@alice:example.org", "aliceweb");
-            await client.client.initCrypto();
+
+            // running initCrypto should trigger a key upload
+            client.httpBackend.when("POST", "/keys/upload").respond(200, {});
+            await Promise.all([
+                client.client.initCrypto(),
+                client.httpBackend.flush("/keys/upload", 1),
+            ]);
 
             encryptedPayload = {
                 algorithm: "m.olm.v1.curve25519-aes-sha2",
diff --git a/spec/unit/crypto/backup.spec.ts b/spec/unit/crypto/backup.spec.ts
index 60fddedc733..bd1c71f02a3 100644
--- a/spec/unit/crypto/backup.spec.ts
+++ b/spec/unit/crypto/backup.spec.ts
@@ -135,7 +135,7 @@ function makeTestClient(cryptoStore: CryptoStore) {
     const scheduler = makeTestScheduler();
     const store = new StubStore();
 
-    return new MatrixClient({
+    const client = new MatrixClient({
         baseUrl: "https://my.home.server",
         idBaseUrl: "https://identity.server",
         accessToken: "my.access.token",
@@ -147,6 +147,10 @@ function makeTestClient(cryptoStore: CryptoStore) {
         cryptoStore: cryptoStore,
         cryptoCallbacks: { getCrossSigningKey, saveCrossSigningKeys },
     });
+
+    // initialising the crypto library will trigger a key upload request, which we can stub out
+    client.uploadKeysRequest = jest.fn();
+    return client;
 }
 
 describe("MegolmBackup", function() {
@@ -509,6 +513,8 @@ describe("MegolmBackup", function() {
                 deviceId: "device",
                 cryptoStore: cryptoStore,
             });
+            // initialising the crypto library will trigger a key upload request, which we can stub out
+            client.uploadKeysRequest = jest.fn();
 
             megolmDecryption = new MegolmDecryption({
                 userId: '@user:id',
@@ -724,6 +730,9 @@ describe("MegolmBackup", function() {
                 deviceId: "device",
                 cryptoStore,
             });
+            // initialising the crypto library will trigger a key upload request, which we can stub out
+            client.uploadKeysRequest = jest.fn();
+
             await client.initCrypto();
 
             cryptoStore.countSessionsNeedingBackup = jest.fn().mockReturnValue(6);
diff --git a/src/client.ts b/src/client.ts
index fae73b7a4e4..6fb74ca173c 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -1210,10 +1210,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             this.store.storeUser(new User(userId));
         }
 
-        if (this.crypto) {
-            this.crypto.uploadDeviceKeys();
-        }
-
         // periodically poll for turn servers if we support voip
         if (this.canSupportVoip) {
             this.checkTurnServersIntervalID = setInterval(() => {
@@ -1864,6 +1860,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // if crypto initialisation was successful, tell it to attach its event handlers.
         crypto.registerEventHandlers(this as Parameters<Crypto["registerEventHandlers"]>[0]);
         this.crypto = crypto;
+
+        // upload our keys in the background
+        this.crypto.uploadDeviceKeys().catch((e) => {
+            // TODO: throwing away this error is a really bad idea.
+            logger.error("Error uploading device keys", e);
+        });
     }
 
     /**
@@ -1895,15 +1897,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * Upload the device keys to the homeserver.
-     * @return {Promise<void>} A promise that will resolve when the keys are uploaded.
+     * @deprecated Does nothing.
      */
     public async uploadKeys(): Promise<void> {
-        if (!this.crypto) {
-            throw new Error("End-to-end encryption disabled");
-        }
-
-        await this.crypto.uploadDeviceKeys();
+        logger.warn("MatrixClient.uploadKeys is deprecated");
     }
 
     /**

From c4006d752a098608ba4f8ea35f5abcd0d78fcddc Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Wed, 7 Dec 2022 18:01:54 +0000
Subject: [PATCH 30/60] Improve tsdoc types (#2940)

* Install eslint-plugin-jsdoc

* Enable lint rule jsdoc/no-types

* Make tsdoc more valid, add required hyphens and s/return/returns/g

* Stash tsdoc work

* Fix mistypes

* Stash

* Stash

* More tsdoc work

* Remove useless doc params

* Fixup docs

* Apply suggestions from code review

Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>

* Update src/crypto/verification/request/ToDeviceChannel.ts

Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>

* Update src/client.ts

Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>

* Update src/client.ts

Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>

* Update src/client.ts

Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>

* Apply suggestions from code review

Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>

* Iterate

Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
---
 .eslintrc.js                                  |   23 +-
 package.json                                  |    6 +-
 spec/TestClient.ts                            |   10 +-
 spec/integ/devicelist-integ.spec.ts           |    4 +-
 spec/integ/matrix-client-crypto.spec.ts       |   17 +-
 spec/integ/matrix-client-syncing.spec.ts      |    4 +-
 spec/integ/megolm-integ.spec.ts               |    8 +-
 spec/integ/sliding-sync.spec.ts               |   10 +-
 spec/test-utils/test-utils.ts                 |   87 +-
 spec/unit/room.spec.ts                        |    1 -
 src/@types/IIdentityServerProvider.ts         |    2 +-
 src/@types/beacon.ts                          |   65 +-
 src/@types/event.ts                           |    6 +-
 src/@types/requests.ts                        |   24 +
 src/@types/topic.ts                           |    8 +-
 src/autodiscovery.ts                          |   34 +-
 src/client.ts                                 | 2369 +++++++----------
 src/content-helpers.ts                        |   42 +-
 src/content-repo.ts                           |   17 +-
 src/crypto/CrossSigning.ts                    |   79 +-
 src/crypto/DeviceList.ts                      |   79 +-
 src/crypto/EncryptionSetup.ts                 |   43 +-
 src/crypto/OlmDevice.ts                       |  292 +-
 src/crypto/OutgoingRoomKeyRequestManager.ts   |   27 +-
 src/crypto/RoomList.ts                        |    5 -
 src/crypto/SecretStorage.ts                   |   45 +-
 src/crypto/aes.ts                             |   26 +-
 src/crypto/algorithms/base.ts                 |  112 +-
 src/crypto/algorithms/index.ts                |    4 -
 src/crypto/algorithms/megolm.ts               |  198 +-
 src/crypto/algorithms/olm.ts                  |   39 +-
 src/crypto/api.ts                             |    4 +-
 src/crypto/backup.ts                          |   26 +-
 src/crypto/deviceinfo.ts                      |   61 +-
 src/crypto/index.ts                           |  528 ++--
 src/crypto/keybackup.ts                       |    4 +
 src/crypto/olmlib.ts                          |   80 +-
 src/crypto/store/base.ts                      |   39 +-
 .../store/indexeddb-crypto-store-backend.ts   |   51 +-
 src/crypto/store/indexeddb-crypto-store.ts    |  214 +-
 src/crypto/store/localStorage-crypto-store.ts |    7 +-
 src/crypto/store/memory-crypto-store.ts       |   51 +-
 src/crypto/verification/Base.ts               |   17 +-
 src/crypto/verification/Error.ts              |    2 -
 src/crypto/verification/IllegalMethod.ts      |    5 -
 src/crypto/verification/QRCode.ts             |    5 -
 src/crypto/verification/SAS.ts                |    5 -
 src/crypto/verification/SASDecimal.ts         |    4 +-
 .../verification/request/InRoomChannel.ts     |   57 +-
 .../verification/request/ToDeviceChannel.ts   |   51 +-
 .../request/VerificationRequest.ts            |   58 +-
 src/embedded.ts                               |    2 +-
 src/event-mapper.ts                           |    3 +
 src/filter-component.ts                       |   37 +-
 src/filter.ts                                 |   42 +-
 src/http-api/errors.ts                        |   25 +-
 src/http-api/fetch.ts                         |  102 +-
 src/http-api/index.ts                         |   22 +-
 src/http-api/interface.ts                     |   55 +-
 src/http-api/utils.ts                         |   18 +-
 src/indexeddb-helpers.ts                      |    6 +-
 src/indexeddb-worker.ts                       |    2 +-
 src/interactive-auth.ts                       |  166 +-
 src/logger.ts                                 |    6 +-
 src/matrix.ts                                 |   25 +-
 src/models/MSC3089Branch.ts                   |   30 +-
 src/models/MSC3089TreeSpace.ts                |   58 +-
 src/models/event-context.ts                   |   25 +-
 src/models/event-status.ts                    |    1 -
 src/models/event-timeline-set.ts              |  185 +-
 src/models/event-timeline.ts                  |   67 +-
 src/models/event.ts                           |  250 +-
 src/models/invites-ignorer.ts                 |   16 +-
 src/models/read-receipt.ts                    |   32 +-
 src/models/relations-container.ts             |   19 +-
 src/models/relations.ts                       |   30 +-
 src/models/room-member.ts                     |  201 +-
 src/models/room-state.ts                      |  246 +-
 src/models/room-summary.ts                    |   20 +-
 src/models/room.ts                            |  540 ++--
 src/models/search-result.ts                   |   14 +-
 src/models/thread.ts                          |    6 +-
 src/models/typed-event-emitter.ts             |    4 +-
 src/models/user.ts                            |  203 +-
 src/pushprocessor.ts                          |   42 +-
 src/realtime-callbacks.ts                     |    9 +-
 src/rendezvous/MSC3906Rendezvous.ts           |    8 +-
 src/rendezvous/RendezvousChannel.ts           |    2 +-
 src/rendezvous/RendezvousTransport.ts         |    4 +-
 src/room-hierarchy.ts                         |   13 +-
 src/scheduler.ts                              |  120 +-
 src/sliding-sync-sdk.ts                       |   23 +-
 src/sliding-sync.ts                           |   72 +-
 src/store/index.ts                            |   76 +-
 src/store/indexeddb-local-backend.ts          |   57 +-
 src/store/indexeddb-remote-backend.ts         |   27 +-
 src/store/indexeddb-store-worker.ts           |    8 +-
 src/store/indexeddb.ts                        |   69 +-
 src/store/memory.ts                           |   98 +-
 src/store/stub.ts                             |   58 +-
 src/sync-accumulator.ts                       |   25 +-
 src/sync.ts                                   |  112 +-
 src/timeline-window.ts                        |   94 +-
 src/utils.ts                                  |  123 +-
 src/webrtc/audioContext.ts                    |    2 +-
 src/webrtc/call.ts                            |  126 +-
 src/webrtc/callEventHandler.ts                |   10 +
 src/webrtc/callFeed.ts                        |   14 +-
 src/webrtc/groupCall.ts                       |   33 +-
 src/webrtc/mediaHandler.ts                    |   24 +-
 yarn.lock                                     |   80 +-
 111 files changed, 3970 insertions(+), 4772 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index 3059df17f4d..c1cc4dc4caa 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -2,6 +2,7 @@ module.exports = {
     plugins: [
         "matrix-org",
         "import",
+        "jsdoc",
     ],
     extends: [
         "plugin:matrix-org/babel",
@@ -45,7 +46,7 @@ module.exports = {
         // restrict EventEmitters to force callers to use TypedEventEmitter
         "no-restricted-imports": ["error", {
             name: "events",
-            message: "Please use TypedEventEmitter instead"
+            message: "Please use TypedEventEmitter instead",
         }],
 
         "import/no-restricted-paths": ["error", {
@@ -61,6 +62,9 @@ module.exports = {
         files: [
             "**/*.ts",
         ],
+        plugins: [
+            "eslint-plugin-tsdoc",
+        ],
         extends: [
             "plugin:matrix-org/typescript",
         ],
@@ -84,6 +88,23 @@ module.exports = {
             "quotes": "off",
             // We use a `logger` intermediary module
             "no-console": "error",
+
+        },
+    }, {
+        // We don't need amazing docs in our spec files
+        files: [
+            "src/**/*.ts",
+        ],
+        rules: {
+            "tsdoc/syntax": "error",
+            // We use some select jsdoc rules as the tsdoc linter has only one rule
+            "jsdoc/no-types": "error",
+            "jsdoc/empty-tags": "error",
+            "jsdoc/check-property-names": "error",
+            "jsdoc/check-values": "error",
+            // These need a bit more work before we can enable
+            // "jsdoc/check-param-names": "error",
+            // "jsdoc/check-indentation": "error",
         },
     }, {
         files: [
diff --git a/package.json b/package.json
index 76529468dc1..2685e5d2830 100644
--- a/package.json
+++ b/package.json
@@ -88,8 +88,8 @@
     "@types/node": "18",
     "@types/sdp-transform": "^2.4.5",
     "@types/uuid": "7",
-    "@typescript-eslint/eslint-plugin": "^5.6.0",
-    "@typescript-eslint/parser": "^5.6.0",
+    "@typescript-eslint/eslint-plugin": "^5.45.0",
+    "@typescript-eslint/parser": "^5.45.0",
     "allchange": "^1.0.6",
     "babel-jest": "^29.0.0",
     "babelify": "^10.0.0",
@@ -101,7 +101,9 @@
     "eslint-config-google": "^0.14.0",
     "eslint-import-resolver-typescript": "^3.5.1",
     "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jsdoc": "^39.6.4",
     "eslint-plugin-matrix-org": "^0.8.0",
+    "eslint-plugin-tsdoc": "^0.2.17",
     "eslint-plugin-unicorn": "^45.0.0",
     "exorcist": "^2.0.0",
     "fake-indexeddb": "^4.0.0",
diff --git a/spec/TestClient.ts b/spec/TestClient.ts
index 02d26b6a76f..8b54fd92ab9 100644
--- a/spec/TestClient.ts
+++ b/spec/TestClient.ts
@@ -105,7 +105,7 @@ export class TestClient {
 
     /**
      * stop the client
-     * @return {Promise} Resolves once the mock http backend has finished all pending flushes
+     * @returns Promise which resolves once the mock http backend has finished all pending flushes
      */
     public async stop(): Promise<void> {
         this.client.stopClient();
@@ -135,7 +135,7 @@ export class TestClient {
      * set up an expectation that the keys will be uploaded, and wait for
      * that to happen.
      *
-     * @returns {Promise} for the one-time keys
+     * @returns Promise for the one-time keys
      */
     public awaitOneTimeKeyUpload(): Promise<Record<string, IOneTimeKey>> {
         if (Object.keys(this.oneTimeKeys!).length != 0) {
@@ -177,7 +177,7 @@ export class TestClient {
      *
      * We check that the query contains each of the users in `response`.
      *
-     * @param {Object} response   response to the query.
+     * @param response -   response to the query.
      */
     public expectKeyQuery(response: IDownloadKeyResult) {
         this.httpBackend.when('POST', '/keys/query').respond<IDownloadKeyResult>(
@@ -202,7 +202,7 @@ export class TestClient {
     /**
      * get the uploaded curve25519 device key
      *
-     * @return {string} base64 device key
+     * @returns base64 device key
      */
     public getDeviceKey(): string {
         const keyId = 'curve25519:' + this.deviceId;
@@ -212,7 +212,7 @@ export class TestClient {
     /**
      * get the uploaded ed25519 device key
      *
-     * @return {string} base64 device key
+     * @returns base64 device key
      */
     public getSigningKey(): string {
         const keyId = 'ed25519:' + this.deviceId;
diff --git a/spec/integ/devicelist-integ.spec.ts b/spec/integ/devicelist-integ.spec.ts
index 5b980149b02..35af27e51dc 100644
--- a/spec/integ/devicelist-integ.spec.ts
+++ b/spec/integ/devicelist-integ.spec.ts
@@ -26,9 +26,7 @@ const ROOM_ID = "!room:id";
  * get a /sync response which contains a single e2e room (ROOM_ID), with the
  * members given
  *
- * @param {string[]} roomMembers
- *
- * @return {object} sync response
+ * @returns sync response
  */
 function getSyncResponse(roomMembers: string[]) {
     const stateEvents = [
diff --git a/spec/integ/matrix-client-crypto.spec.ts b/spec/integ/matrix-client-crypto.spec.ts
index ae58be1c91c..74366a21b6b 100644
--- a/spec/integ/matrix-client-crypto.spec.ts
+++ b/spec/integ/matrix-client-crypto.spec.ts
@@ -60,7 +60,7 @@ async function bobUploadsDeviceKeys(): Promise<void> {
 /**
  * Set an expectation that querier will query uploader's keys; then flush the http request.
  *
- * @return {promise} resolves once the http request has completed.
+ * @returns resolves once the http request has completed.
  */
 function expectQueryKeys(querier: TestClient, uploader: TestClient): Promise<number> {
     // can't query keys before bob has uploaded them
@@ -83,7 +83,7 @@ const expectBobQueryKeys = () => expectQueryKeys(bobTestClient, aliTestClient);
 /**
  * Set an expectation that ali will claim one of bob's keys; then flush the http request.
  *
- * @return {promise} resolves once the http request has completed.
+ * @returns resolves once the http request has completed.
  */
 async function expectAliClaimKeys(): Promise<void> {
     const keys = await bobTestClient.awaitOneTimeKeyUpload();
@@ -151,7 +151,7 @@ const bobEnablesEncryption = () => clientEnablesEncryption(bobTestClient.client)
  * Ali sends a message, first claiming e2e keys. Set the expectations and
  * check the results.
  *
- * @return {promise} which resolves to the ciphertext for Bob's device.
+ * @returns which resolves to the ciphertext for Bob's device.
  */
 async function aliSendsFirstMessage(): Promise<OlmPayload> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -168,7 +168,7 @@ async function aliSendsFirstMessage(): Promise<OlmPayload> {
  * Ali sends a message without first claiming e2e keys. Set the expectations
  * and check the results.
  *
- * @return {promise} which resolves to the ciphertext for Bob's device.
+ * @returns which resolves to the ciphertext for Bob's device.
  */
 async function aliSendsMessage(): Promise<OlmPayload> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -183,7 +183,7 @@ async function aliSendsMessage(): Promise<OlmPayload> {
  * Bob sends a message, first querying (but not claiming) e2e keys. Set the
  * expectations and check the results.
  *
- * @return {promise} which resolves to the ciphertext for Ali's device.
+ * @returns which resolves to the ciphertext for Ali's device.
  */
 async function bobSendsReplyMessage(): Promise<OlmPayload> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -198,7 +198,7 @@ async function bobSendsReplyMessage(): Promise<OlmPayload> {
 /**
  * Set an expectation that Ali will send a message, and flush the request
  *
- * @return {promise} which resolves to the ciphertext for Bob's device.
+ * @returns which resolves to the ciphertext for Bob's device.
  */
 async function expectAliSendMessageRequest(): Promise<OlmPayload> {
     const content = await expectSendMessageRequest(aliTestClient.httpBackend);
@@ -212,7 +212,7 @@ async function expectAliSendMessageRequest(): Promise<OlmPayload> {
 /**
  * Set an expectation that Bob will send a message, and flush the request
  *
- * @return {promise} which resolves to the ciphertext for Bob's device.
+ * @returns which resolves to the ciphertext for Bob's device.
  */
 async function expectBobSendMessageRequest(): Promise<OlmPayload> {
     const content = await expectSendMessageRequest(bobTestClient.httpBackend);
@@ -321,8 +321,7 @@ async function recvMessage(
  * Send an initial sync response to the client (which just includes the member
  * list for our test room).
  *
- * @param {TestClient} testClient
- * @returns {Promise} which resolves when the sync has been flushed.
+ * @returns which resolves when the sync has been flushed.
  */
 function firstSync(testClient: TestClient): Promise<void> {
     // send a sync response including our test room.
diff --git a/spec/integ/matrix-client-syncing.spec.ts b/spec/integ/matrix-client-syncing.spec.ts
index dbb891449cc..5ddcb0aa01c 100644
--- a/spec/integ/matrix-client-syncing.spec.ts
+++ b/spec/integ/matrix-client-syncing.spec.ts
@@ -1658,8 +1658,8 @@ describe("MatrixClient syncing", () => {
     /**
      * waits for the MatrixClient to emit one or more 'sync' events.
      *
-     * @param {Number?} numSyncs number of syncs to wait for
-     * @returns {Promise} promise which resolves after the sync events have happened
+     * @param numSyncs - number of syncs to wait for
+     * @returns promise which resolves after the sync events have happened
      */
     function awaitSyncEvent(numSyncs?: number) {
         return utils.syncPromise(client!, numSyncs);
diff --git a/spec/integ/megolm-integ.spec.ts b/spec/integ/megolm-integ.spec.ts
index 89c06426617..73a1999363b 100644
--- a/spec/integ/megolm-integ.spec.ts
+++ b/spec/integ/megolm-integ.spec.ts
@@ -220,8 +220,8 @@ describe("megolm", () => {
      * Get the device keys for testOlmAccount in a format suitable for a
      * response to /keys/query
      *
-     * @param {string} userId The user ID to query for
-     * @returns {IDownloadKeyResult} The fake query response
+     * @param userId - The user ID to query for
+     * @returns The fake query response
      */
     function getTestKeysQueryResponse(userId: string): IDownloadKeyResult {
         const testE2eKeys = JSON.parse(testOlmAccount.identity_keys());
@@ -248,8 +248,8 @@ describe("megolm", () => {
      * Get a one-time key for testOlmAccount in a format suitable for a
      * response to /keys/claim
 
-     * @param {string} userId The user ID to query for
-     * @returns {IClaimOTKsResult} The fake key claim response
+     * @param userId - The user ID to query for
+     * @returns The fake key claim response
      */
     function getTestKeysClaimResponse(userId: string): IClaimOTKsResult {
         testOlmAccount.generate_one_time_keys(1);
diff --git a/spec/integ/sliding-sync.spec.ts b/spec/integ/sliding-sync.spec.ts
index c2a4b8e98fc..d90c0236a56 100644
--- a/spec/integ/sliding-sync.spec.ts
+++ b/spec/integ/sliding-sync.spec.ts
@@ -1446,11 +1446,11 @@ function timeout(delayMs: number, reason: string): { promise: Promise<never>, ca
 
 /**
  * Listen until a callback returns data.
- * @param {EventEmitter} emitter The event emitter
- * @param {string} eventName The event to listen for
- * @param {function} callback The callback which will be invoked when events fire. Return something truthy from this to resolve the promise.
- * @param {number} timeoutMs The number of milliseconds to wait for the callback to return data. Default: 500ms.
- * @returns {Promise} A promise which will be resolved when the callback returns data. If the callback throws or the timeout is reached,
+ * @param emitter - The event emitter
+ * @param eventName - The event to listen for
+ * @param callback - The callback which will be invoked when events fire. Return something truthy from this to resolve the promise.
+ * @param timeoutMs - The number of milliseconds to wait for the callback to return data. Default: 500ms.
+ * @returns A promise which will be resolved when the callback returns data. If the callback throws or the timeout is reached,
  * the promise is rejected.
  */
 function listenUntil<T>(
diff --git a/spec/test-utils/test-utils.ts b/spec/test-utils/test-utils.ts
index 3dd9c037844..814f9b15e40 100644
--- a/spec/test-utils/test-utils.ts
+++ b/spec/test-utils/test-utils.ts
@@ -13,9 +13,9 @@ import { eventMapperFor } from "../../src/event-mapper";
 /**
  * Return a promise that is resolved when the client next emits a
  * SYNCING event.
- * @param {Object} client The client
- * @param {Number=} count Number of syncs to wait for (default 1)
- * @return {Promise} Resolves once the client has emitted a SYNCING event
+ * @param client - The client
+ * @param count - Number of syncs to wait for (default 1)
+ * @returns Promise which resolves once the client has emitted a SYNCING event
  */
 export function syncPromise(client: MatrixClient, count = 1): Promise<void> {
     if (count <= 0) {
@@ -41,9 +41,9 @@ export function syncPromise(client: MatrixClient, count = 1): Promise<void> {
 
 /**
  * Create a spy for an object and automatically spy its methods.
- * @param {*} constr The class constructor (used with 'new')
- * @param {string} name The name of the class
- * @return {Object} An instantiated object with spied methods/properties.
+ * @param constr - The class constructor (used with 'new')
+ * @param name - The name of the class
+ * @returns An instantiated object with spied methods/properties.
  */
 export function mock<T>(constr: { new(...args: any[]): T }, name: string): T {
     // Based on http://eclipsesource.com/blogs/2014/03/27/mocks-in-jasmine-tests/
@@ -84,15 +84,15 @@ interface IEventOpts {
 let testEventIndex = 1; // counter for events, easier for comparison of randomly generated events
 /**
  * Create an Event.
- * @param {Object} opts Values for the event.
- * @param {string} opts.type The event.type
- * @param {string} opts.room The event.room_id
- * @param {string} opts.sender The event.sender
- * @param {string} opts.skey Optional. The state key (auto inserts empty string)
- * @param {Object} opts.content The event.content
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object} a JSON object representing this event.
+ * @param opts - Values for the event.
+ * @param opts.type - The event.type
+ * @param opts.room - The event.room_id
+ * @param opts.sender - The event.sender
+ * @param opts.skey - Optional. The state key (auto inserts empty string)
+ * @param opts.content - The event.content
+ * @param opts.event - True to make a MatrixEvent.
+ * @param client - If passed along with opts.event=true will be used to set up re-emitters.
+ * @returns a JSON object representing this event.
  */
 export function mkEvent(opts: IEventOpts & { event: true }, client?: MatrixClient): MatrixEvent;
 export function mkEvent(opts: IEventOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
@@ -160,8 +160,8 @@ interface IPresenceOpts {
 
 /**
  * Create an m.presence event.
- * @param {Object} opts Values for the presence.
- * @return {Object|MatrixEvent} The event
+ * @param opts - Values for the presence.
+ * @returns The event
  */
 export function mkPresence(opts: IPresenceOpts & { event: true }): MatrixEvent;
 export function mkPresence(opts: IPresenceOpts & { event?: false }): Partial<IEvent>;
@@ -193,16 +193,16 @@ interface IMembershipOpts {
 
 /**
  * Create an m.room.member event.
- * @param {Object} opts Values for the membership.
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.mship The content.membership for the event.
- * @param {string} opts.sender The sender user ID for the event.
- * @param {string} opts.skey The target user ID for the event if applicable
+ * @param opts - Values for the membership.
+ * @param opts.room - The room ID for the event.
+ * @param opts.mship - The content.membership for the event.
+ * @param opts.sender - The sender user ID for the event.
+ * @param opts.skey - The target user ID for the event if applicable
  * e.g. for invites/bans.
- * @param {string} opts.name The content.displayname for the event.
- * @param {string} opts.url The content.avatar_url for the event.
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @return {Object|MatrixEvent} The event
+ * @param opts.name - The content.displayname for the event.
+ * @param opts.url - The content.avatar_url for the event.
+ * @param opts.event - True to make a MatrixEvent.
+ * @returns The event
  */
 export function mkMembership(opts: IMembershipOpts & { event: true }): MatrixEvent;
 export function mkMembership(opts: IMembershipOpts & { event?: false }): Partial<IEvent>;
@@ -250,13 +250,13 @@ export interface IMessageOpts {
 
 /**
  * Create an m.room.message event.
- * @param {Object} opts Values for the message
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.user The user ID for the event.
- * @param {string} opts.msg Optional. The content.body for the event.
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object|MatrixEvent} The event
+ * @param opts - Values for the message
+ * @param opts.room - The room ID for the event.
+ * @param opts.user - The user ID for the event.
+ * @param opts.msg - Optional. The content.body for the event.
+ * @param opts.event - True to make a MatrixEvent.
+ * @param client - If passed along with opts.event=true will be used to set up re-emitters.
+ * @returns The event
  */
 export function mkMessage(opts: IMessageOpts & { event: true }, client?: MatrixClient): MatrixEvent;
 export function mkMessage(opts: IMessageOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
@@ -290,14 +290,14 @@ interface IReplyMessageOpts extends IMessageOpts {
 /**
  * Create a reply message.
  *
- * @param {Object} opts Values for the message
- * @param {string} opts.room The room ID for the event.
- * @param {string} opts.user The user ID for the event.
- * @param {string} opts.msg Optional. The content.body for the event.
- * @param {MatrixEvent} opts.replyToMessage The replied message
- * @param {boolean} opts.event True to make a MatrixEvent.
- * @param {MatrixClient} client If passed along with opts.event=true will be used to set up re-emitters.
- * @return {Object|MatrixEvent} The event
+ * @param opts - Values for the message
+ * @param opts.room - The room ID for the event.
+ * @param opts.user - The user ID for the event.
+ * @param opts.msg - Optional. The content.body for the event.
+ * @param opts.replyToMessage - The replied message
+ * @param opts.event - True to make a MatrixEvent.
+ * @param client - If passed along with opts.event=true will be used to set up re-emitters.
+ * @returns The event
  */
 export function mkReplyMessage(opts: IReplyMessageOpts & { event: true }, client?: MatrixClient): MatrixEvent;
 export function mkReplyMessage(opts: IReplyMessageOpts & { event?: false }, client?: MatrixClient): Partial<IEvent>;
@@ -329,8 +329,6 @@ export function mkReplyMessage(
 
 /**
  * A mock implementation of webstorage
- *
- * @constructor
  */
 export class MockStorageApi implements Storage {
     private data: Record<string, any> = {};
@@ -363,8 +361,7 @@ export class MockStorageApi implements Storage {
 /**
  * If an event is being decrypted, wait for it to finish being decrypted.
  *
- * @param {MatrixEvent} event
- * @returns {Promise} promise which resolves (to `event`) when the event has been decrypted
+ * @returns promise which resolves (to `event`) when the event has been decrypted
  */
 export async function awaitDecryption(
     event: MatrixEvent, { waitOnDecryptionFailure = false } = {},
diff --git a/spec/unit/room.spec.ts b/spec/unit/room.spec.ts
index c820f37a074..ad74a285352 100644
--- a/spec/unit/room.spec.ts
+++ b/spec/unit/room.spec.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * This is an internal module. See {@link MatrixClient} for the public class.
- * @module client
  */
 
 import { mocked } from "jest-mock";
diff --git a/src/@types/IIdentityServerProvider.ts b/src/@types/IIdentityServerProvider.ts
index 7b905e316b3..05793d53a5d 100644
--- a/src/@types/IIdentityServerProvider.ts
+++ b/src/@types/IIdentityServerProvider.ts
@@ -18,7 +18,7 @@ export interface IIdentityServerProvider {
     /**
      * Gets an access token for use against the identity server,
      * for the associated client.
-     * @returns {Promise<string>} Resolves to the access token.
+     * @returns Promise which resolves to the access token.
      */
     getAccessToken(): Promise<string>;
 }
diff --git a/src/@types/beacon.ts b/src/@types/beacon.ts
index 6da17061e61..ea8a9c8eb8f 100644
--- a/src/@types/beacon.ts
+++ b/src/@types/beacon.ts
@@ -35,7 +35,8 @@ import { MAssetEvent, MLocationEvent, MTimestampEvent } from "./location";
  * To achieve an arbitrary number of only owner-writable state events
  * we introduce a variable suffix to the event type
  *
- * Eg
+ * @example
+ * ```
  * {
  *      "type": "m.beacon_info.@matthew:matrix.org.1",
  *      "state_key": "@matthew:matrix.org",
@@ -58,6 +59,7 @@ import { MAssetEvent, MLocationEvent, MTimestampEvent } from "./location";
  *          // more content as described below
  *      }
  * }
+ * ```
  */
 
 /**
@@ -78,20 +80,23 @@ export type MBeaconInfoContent = {
 /**
  * m.beacon_info Event example from the spec
  * https://github.com/matrix-org/matrix-spec-proposals/pull/3672
+ * @example
+ * ```
  * {
-    "type": "m.beacon_info",
-    "state_key": "@matthew:matrix.org",
-    "content": {
-        "m.beacon_info": {
-            "description": "The Matthew Tracker", // same as an `m.location` description
-            "timeout": 86400000, // how long from the last event until we consider the beacon inactive in milliseconds
-        },
-        "m.ts": 1436829458432, // creation timestamp of the beacon on the client
-        "m.asset": {
-            "type": "m.self" // the type of asset being tracked as per MSC3488
-        }
-    }
-}
+ *   "type": "m.beacon_info",
+ *   "state_key": "@matthew:matrix.org",
+ *   "content": {
+ *     "m.beacon_info": {
+ *       "description": "The Matthew Tracker", // same as an `m.location` description
+ *       "timeout": 86400000, // how long from the last event until we consider the beacon inactive in milliseconds
+ *     },
+ *     "m.ts": 1436829458432, // creation timestamp of the beacon on the client
+ *     "m.asset": {
+ *       "type": "m.self" // the type of asset being tracked as per MSC3488
+ *     }
+ *   }
+ * }
+ * ```
  */
 
 /**
@@ -107,22 +112,24 @@ export type MBeaconInfoEventContent = &
 /**
  * m.beacon event example
  * https://github.com/matrix-org/matrix-spec-proposals/pull/3672
- *
+ * @example
+ * ```
  * {
-    "type": "m.beacon",
-    "sender": "@matthew:matrix.org",
-    "content": {
-        "m.relates_to": { // from MSC2674: https://github.com/matrix-org/matrix-doc/pull/2674
-            "rel_type": "m.reference", // from MSC3267: https://github.com/matrix-org/matrix-doc/pull/3267
-            "event_id": "$beacon_info"
-        },
-        "m.location": {
-            "uri": "geo:51.5008,0.1247;u=35",
-            "description": "Arbitrary beacon information"
-        },
-        "m.ts": 1636829458432,
-    }
-}
+ *   "type": "m.beacon",
+ *   "sender": "@matthew:matrix.org",
+ *   "content": {
+ *       "m.relates_to": { // from MSC2674: https://github.com/matrix-org/matrix-doc/pull/2674
+ *           "rel_type": "m.reference", // from MSC3267: https://github.com/matrix-org/matrix-doc/pull/3267
+ *           "event_id": "$beacon_info"
+ *       },
+ *       "m.location": {
+ *           "uri": "geo:51.5008,0.1247;u=35",
+ *           "description": "Arbitrary beacon information"
+ *       },
+ *       "m.ts": 1636829458432,
+ *   }
+ * }
+ * ```
 */
 
 /**
diff --git a/src/@types/event.ts b/src/@types/event.ts
index ab07c01d776..d8bb4cc3081 100644
--- a/src/@types/event.ts
+++ b/src/@types/event.ts
@@ -171,17 +171,21 @@ export const UNSTABLE_MSC2716_MARKER = new UnstableValue("m.room.marker", "org.m
  * eventual removal.
  *
  * Schema (TypeScript):
+ * ```
  * {
  *   service_members?: string[]
  * }
+ * ```
  *
- * Example:
+ * @example
+ * ```
  * {
  *   "service_members": [
  *     "@helperbot:localhost",
  *     "@reminderbot:alice.tdl"
  *   ]
  * }
+ * ```
  */
 export const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(
     "io.element.functional_members",
diff --git a/src/@types/requests.ts b/src/@types/requests.ts
index 936ace5b46e..75296940a9c 100644
--- a/src/@types/requests.ts
+++ b/src/@types/requests.ts
@@ -54,17 +54,31 @@ export interface ISendEventResponse {
 }
 
 export interface IPresenceOpts {
+    // One of "online", "offline" or "unavailable"
     presence: "online" | "offline" | "unavailable";
+    // The status message to attach.
     status_msg?: string;
 }
 
 export interface IPaginateOpts {
+    // true to fill backwards, false to go forwards
     backwards?: boolean;
+    // number of events to request
     limit?: number;
 }
 
 export interface IGuestAccessOpts {
+    /**
+     * True to allow guests to join this room. This
+     * implicitly gives guests write access. If false or not given, guests are
+     * explicitly forbidden from joining the room.
+     */
     allowJoin: boolean;
+    /**
+     * True to set history visibility to
+     * be world_readable. This gives guests read access *from this point forward*.
+     * If false or not given, history visibility is not modified.
+     */
     allowRead: boolean;
 }
 
@@ -74,7 +88,9 @@ export interface ISearchOpts {
 }
 
 export interface IEventSearchOpts {
+    // a JSON filter object to pass in the request
     filter?: IRoomEventFilter;
+    // the term to search for
     term: string;
 }
 
@@ -92,9 +108,13 @@ export interface ICreateRoomStateEvent {
 }
 
 export interface ICreateRoomOpts {
+    // The alias localpart to assign to this room.
     room_alias_name?: string;
+    // Either 'public' or 'private'.
     visibility?: Visibility;
+    // The name to give this room.
     name?: string;
+    // The topic to give this room.
     topic?: string;
     preset?: Preset;
     power_level_content_override?: {
@@ -111,6 +131,7 @@ export interface ICreateRoomOpts {
     };
     creation_content?: object;
     initial_state?: ICreateRoomStateEvent[];
+    // A list of user IDs to invite to this room.
     invite?: string[];
     invite_3pid?: IInvite3PID[];
     is_direct?: boolean;
@@ -121,7 +142,10 @@ export interface IRoomDirectoryOptions {
     server?: string;
     limit?: number;
     since?: string;
+
+    // Filter parameters
     filter?: {
+        // String to search for
         generic_search_term?: string;
         room_types?: Array<RoomType | null>;
     };
diff --git a/src/@types/topic.ts b/src/@types/topic.ts
index 0d2708b2e50..5b66e07c46f 100644
--- a/src/@types/topic.ts
+++ b/src/@types/topic.ts
@@ -21,10 +21,9 @@ import { UnstableValue } from "../NamespacedValue";
 /**
  * Extensible topic event type based on MSC3765
  * https://github.com/matrix-org/matrix-spec-proposals/pull/3765
- */
-
-/**
- * Eg
+ *
+ * @example
+ * ```
  * {
  *      "type": "m.room.topic,
  *      "state_key": "",
@@ -39,6 +38,7 @@ import { UnstableValue } from "../NamespacedValue";
  *          }],
  *      }
  * }
+ * ```
  */
 
 /**
diff --git a/src/autodiscovery.ts b/src/autodiscovery.ts
index fe2b6e383f3..35728d1e21d 100644
--- a/src/autodiscovery.ts
+++ b/src/autodiscovery.ts
@@ -15,8 +15,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/** @module auto-discovery */
-
 import { IClientWellKnown, IWellKnownConfig } from "./client";
 import { logger } from './logger';
 import { MatrixError, Method, timeoutSignal } from "./http-api";
@@ -87,8 +85,6 @@ export class AutoDiscovery {
     /**
      * The auto discovery failed. The client is expected to communicate
      * the error to the user and refuse logging in.
-     * @return {string}
-     * @constructor
      */
     public static readonly FAIL_ERROR = AutoDiscoveryAction.FAIL_ERROR;
 
@@ -98,8 +94,6 @@ export class AutoDiscovery {
      * action it would for PROMPT while also warning the user about
      * what went wrong. The client may also treat this the same as
      * a FAIL_ERROR state.
-     * @return {string}
-     * @constructor
      */
     public static readonly FAIL_PROMPT = AutoDiscoveryAction.FAIL_PROMPT;
 
@@ -107,15 +101,11 @@ export class AutoDiscovery {
      * The auto discovery didn't fail but did not find anything of
      * interest. The client is expected to prompt the user for more
      * information, or fail if it prefers.
-     * @return {string}
-     * @constructor
      */
     public static readonly PROMPT = AutoDiscoveryAction.PROMPT;
 
     /**
      * The auto discovery was successful.
-     * @return {string}
-     * @constructor
      */
     public static readonly SUCCESS = AutoDiscoveryAction.SUCCESS;
 
@@ -125,9 +115,9 @@ export class AutoDiscovery {
      * and identity server URL the client would want. Additional details
      * may also be included, and will be transparently brought into the
      * response object unaltered.
-     * @param {object} wellknown The configuration object itself, as returned
+     * @param wellknown - The configuration object itself, as returned
      * by the .well-known auto-discovery endpoint.
-     * @return {Promise<DiscoveredClientConfig>} Resolves to the verified
+     * @returns Promise which resolves to the verified
      * configuration, which may include error states. Rejects on unexpected
      * failure, not when verification fails.
      */
@@ -284,9 +274,9 @@ export class AutoDiscovery {
      * and identity server URL the client would want. Additional details
      * may also be discovered, and will be transparently included in the
      * response object unaltered.
-     * @param {string} domain The homeserver domain to perform discovery
+     * @param domain - The homeserver domain to perform discovery
      * on. For example, "matrix.org".
-     * @return {Promise<DiscoveredClientConfig>} Resolves to the discovered
+     * @returns Promise which resolves to the discovered
      * configuration, which may include error states. Rejects on unexpected
      * failure, not when discovery fails.
      */
@@ -354,8 +344,8 @@ export class AutoDiscovery {
      * Gets the raw discovery client configuration for the given domain name.
      * Should only be used if there's no validation to be done on the resulting
      * object, otherwise use findClientConfig().
-     * @param {string} domain The domain to get the client config for.
-     * @returns {Promise<object>} Resolves to the domain's client config. Can
+     * @param domain - The domain to get the client config for.
+     * @returns Promise which resolves to the domain's client config. Can
      * be an empty object.
      */
     public static async getRawClientConfig(domain?: string): Promise<IClientWellKnown> {
@@ -374,9 +364,9 @@ export class AutoDiscovery {
      * Sanitizes a given URL to ensure it is either an HTTP or HTTP URL and
      * is suitable for the requirements laid out by .well-known auto discovery.
      * If valid, the URL will also be stripped of any trailing slashes.
-     * @param {string} url The potentially invalid URL to sanitize.
-     * @return {string|boolean} The sanitized URL or a falsey value if the URL is invalid.
-     * @private
+     * @param url - The potentially invalid URL to sanitize.
+     * @returns The sanitized URL or a falsey value if the URL is invalid.
+     * @internal
      */
     private static sanitizeWellKnownUrl(url?: string | null): string | false {
         if (!url) return false;
@@ -430,9 +420,9 @@ export class AutoDiscovery {
      *   action: One of SUCCESS, IGNORE, or FAIL_PROMPT.
      *   reason: Relatively human-readable description of what went wrong.
      *   error: The actual Error, if one exists.
-     * @param {string} url The URL to fetch a JSON object from.
-     * @return {Promise<object>} Resolves to the returned state.
-     * @private
+     * @param url - The URL to fetch a JSON object from.
+     * @returns Promise which resolves to the returned state.
+     * @internal
      */
     private static async fetchWellKnownObject(url: string): Promise<IWellKnownConfig> {
         let response: Response;
diff --git a/src/client.ts b/src/client.ts
index 6fb74ca173c..fba259a5671 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * This is an internal module. See {@link MatrixClient} for the public class.
- * @module client
  */
 
 import { EmoteEvent, IPartialEvent, MessageEvent, NoticeEvent, Optional } from "matrix-events-sdk";
@@ -258,7 +257,10 @@ export interface ICreateClientOpts {
     /**
      * A store to be used for end-to-end crypto session data. If not specified,
      * end-to-end crypto will be disabled. The `createClient` helper will create
-     * a default store if needed.
+     * a default store if needed. Calls the factory supplied to
+     * {@link setCryptoStoreFactory} if unspecified; or if no factory has been
+     * specified, uses a default implementation (indexeddb in the browser,
+     * in-memory otherwise).
      */
     cryptoStore?: CryptoStore;
 
@@ -266,7 +268,7 @@ export interface ICreateClientOpts {
      * The scheduler to use. If not
      * specified, this client will not retry requests on failure. This client
      * will supply its own processing function to
-     * {@link module:scheduler~MatrixScheduler#setProcessFunction}.
+     * {@link MatrixScheduler#setProcessFunction}.
      */
     scheduler?: MatrixScheduler;
 
@@ -311,8 +313,8 @@ export interface ICreateClientOpts {
 
     /**
      * Set to true to enable
-     * improved timeline support ({@link module:client~MatrixClient#getEventTimeline getEventTimeline}). It is
-     * disabled by default for compatibility with older clients - in particular to
+     * improved timeline support, see {@link MatrixClient#getEventTimeline}.
+     * It is disabled by default for compatibility with older clients - in particular to
      * maintain support for back-paginating the live timeline after a '/sync'
      * result with a gap.
      */
@@ -321,7 +323,7 @@ export interface ICreateClientOpts {
     /**
      * Extra query parameters to append
      * to all requests with this client. Useful for application services which require
-     * <code>?user_id=</code>.
+     * `?user_id=`.
      */
     queryParams?: Record<string, string>;
 
@@ -395,12 +397,12 @@ export enum PendingEventOrdering {
 
 export interface IStartClientOpts {
     /**
-     * The event <code>limit=</code> to apply to initial sync. Default: 8.
+     * The event `limit=` to apply to initial sync. Default: 8.
      */
     initialSyncLimit?: number;
 
     /**
-     * True to put <code>archived=true</code> on the <code>/initialSync</code> request. Default: false.
+     * True to put `archived=true</code> on the <code>/initialSync` request. Default: false.
      */
     includeArchivedRooms?: boolean;
 
@@ -411,8 +413,8 @@ export interface IStartClientOpts {
 
     /**
      * Controls where pending messages appear in a room's timeline. If "<b>chronological</b>", messages will
-     * appear in the timeline when the call to <code>sendEvent</code> was made. If "<b>detached</b>",
-     * pending messages will appear in a separate list, accessbile via {@link module:models/room#getPendingEvents}.
+     * appear in the timeline when the call to `sendEvent` was made. If "<b>detached</b>",
+     * pending messages will appear in a separate list, accessbile via {@link Room#getPendingEvents}.
      * Default: "chronological".
      */
     pendingEventOrdering?: PendingEventOrdering;
@@ -456,7 +458,14 @@ export interface IStartClientOpts {
 }
 
 export interface IStoredClientOpts extends IStartClientOpts {
+    // Crypto manager
     crypto?: Crypto;
+    /**
+     * A function which is called
+     * with a room ID and returns a boolean. It should return 'true' if the SDK can
+     * SAFELY remove events from this room. It may not be safe to remove events if
+     * there are other references to the timelines for this room.
+     */
     canResetEntireTimeline: ResetTimelineCallback;
 }
 
@@ -916,13 +925,184 @@ export type EmittedEvents = ClientEvent
     | BeaconEvent;
 
 export type ClientEventHandlerMap = {
+    /**
+     * Fires whenever the SDK's syncing state is updated. The state can be one of:
+     * <ul>
+     *
+     * <li>PREPARED: The client has synced with the server at least once and is
+     * ready for methods to be called on it. This will be immediately followed by
+     * a state of SYNCING. <i>This is the equivalent of "syncComplete" in the
+     * previous API.</i></li>
+     *
+     * <li>CATCHUP: The client has detected the connection to the server might be
+     * available again and will now try to do a sync again. As this sync might take
+     * a long time (depending how long ago was last synced, and general server
+     * performance) the client is put in this mode so the UI can reflect trying
+     * to catch up with the server after losing connection.</li>
+     *
+     * <li>SYNCING : The client is currently polling for new events from the server.
+     * This will be called <i>after</i> processing latest events from a sync.</li>
+     *
+     * <li>ERROR : The client has had a problem syncing with the server. If this is
+     * called <i>before</i> PREPARED then there was a problem performing the initial
+     * sync. If this is called <i>after</i> PREPARED then there was a problem polling
+     * the server for updates. This may be called multiple times even if the state is
+     * already ERROR. <i>This is the equivalent of "syncError" in the previous
+     * API.</i></li>
+     *
+     * <li>RECONNECTING: The sync connection has dropped, but not (yet) in a way that
+     * should be considered erroneous.
+     * </li>
+     *
+     * <li>STOPPED: The client has stopped syncing with server due to stopClient
+     * being called.
+     * </li>
+     * </ul>
+     * State transition diagram:
+     * ```
+     *                                          +---->STOPPED
+     *                                          |
+     *              +----->PREPARED -------> SYNCING <--+
+     *              |                        ^  |  ^    |
+     *              |      CATCHUP ----------+  |  |    |
+     *              |        ^                  V  |    |
+     *   null ------+        |  +------- RECONNECTING   |
+     *              |        V  V                       |
+     *              +------->ERROR ---------------------+
+     *
+     * NB: 'null' will never be emitted by this event.
+     *
+     * ```
+     * Transitions:
+     * <ul>
+     *
+     * <li>`null -> PREPARED` : Occurs when the initial sync is completed
+     * first time. This involves setting up filters and obtaining push rules.
+     *
+     * <li>`null -> ERROR` : Occurs when the initial sync failed first time.
+     *
+     * <li>`ERROR -> PREPARED` : Occurs when the initial sync succeeds
+     * after previously failing.
+     *
+     * <li>`PREPARED -> SYNCING` : Occurs immediately after transitioning
+     * to PREPARED. Starts listening for live updates rather than catching up.
+     *
+     * <li>`SYNCING -> RECONNECTING` : Occurs when the live update fails.
+     *
+     * <li>`RECONNECTING -> RECONNECTING` : Can occur if the update calls
+     * continue to fail, but the keepalive calls (to /versions) succeed.
+     *
+     * <li>`RECONNECTING -> ERROR` : Occurs when the keepalive call also fails
+     *
+     * <li>`ERROR -> SYNCING` : Occurs when the client has performed a
+     * live update after having previously failed.
+     *
+     * <li>`ERROR -> ERROR` : Occurs when the client has failed to keepalive
+     * for a second time or more.</li>
+     *
+     * <li>`SYNCING -> SYNCING` : Occurs when the client has performed a live
+     * update. This is called <i>after</i> processing.</li>
+     *
+     * <li>`* -> STOPPED` : Occurs once the client has stopped syncing or
+     * trying to sync after stopClient has been called.</li>
+     * </ul>
+     *
+     * @param state - An enum representing the syncing state. One of "PREPARED",
+     * "SYNCING", "ERROR", "STOPPED".
+     *
+     * @param prevState - An enum representing the previous syncing state.
+     * One of "PREPARED", "SYNCING", "ERROR", "STOPPED" <b>or null</b>.
+     *
+     * @param data - Data about this transition.
+     *
+     * @example
+     * ```
+     * matrixClient.on("sync", function(state, prevState, data) {
+     *   switch (state) {
+     *     case "ERROR":
+     *       // update UI to say "Connection Lost"
+     *       break;
+     *     case "SYNCING":
+     *       // update UI to remove any "Connection Lost" message
+     *       break;
+     *     case "PREPARED":
+     *       // the client instance is ready to be queried.
+     *       var rooms = matrixClient.getRooms();
+     *       break;
+     *   }
+     * });
+     * ```
+     */
     [ClientEvent.Sync]: (state: SyncState, lastState: SyncState | null, data?: ISyncStateData) => void;
+    /**
+     * Fires whenever the SDK receives a new event.
+     * <p>
+     * This is only fired for live events received via /sync - it is not fired for
+     * events received over context, search, or pagination APIs.
+     *
+     * @param event - The matrix event which caused this event to fire.
+     * @example
+     * ```
+     * matrixClient.on("event", function(event){
+     *   var sender = event.getSender();
+     * });
+     * ```
+     */
     [ClientEvent.Event]: (event: MatrixEvent) => void;
+    /**
+     * Fires whenever the SDK receives a new to-device event.
+     * @param event - The matrix event which caused this event to fire.
+     * @example
+     * ```
+     * matrixClient.on("toDeviceEvent", function(event){
+     *   var sender = event.getSender();
+     * });
+     * ```
+     */
     [ClientEvent.ToDeviceEvent]: (event: MatrixEvent) => void;
+    /**
+     * Fires whenever new user-scoped account_data is added.
+     * @param event - The event describing the account_data just added
+     * @param event - The previous account data, if known.
+     * @example
+     * ```
+     * matrixClient.on("accountData", function(event, oldEvent){
+     *   myAccountData[event.type] = event.content;
+     * });
+     * ```
+     */
     [ClientEvent.AccountData]: (event: MatrixEvent, lastEvent?: MatrixEvent) => void;
+    /**
+     * Fires whenever a new Room is added. This will fire when you are invited to a
+     * room, as well as when you join a room. <strong>This event is experimental and
+     * may change.</strong>
+     * @param room - The newly created, fully populated room.
+     * @example
+     * ```
+     * matrixClient.on("Room", function(room){
+     *   var roomId = room.roomId;
+     * });
+     * ```
+     */
     [ClientEvent.Room]: (room: Room) => void;
+    /**
+     * Fires whenever a Room is removed. This will fire when you forget a room.
+     * <strong>This event is experimental and may change.</strong>
+     * @param roomId - The deleted room ID.
+     * @example
+     * ```
+     * matrixClient.on("deleteRoom", function(roomId){
+     *   // update UI from getRooms()
+     * });
+     * ```
+     */
     [ClientEvent.DeleteRoom]: (roomId: string) => void;
     [ClientEvent.SyncUnexpectedError]: (error: Error) => void;
+    /**
+     * Fires when the client .well-known info is fetched.
+     *
+     * @param data - The JSON object returned by the server
+     */
     [ClientEvent.ClientWellKnown]: (data: IClientWellKnown) => void;
     [ClientEvent.ReceivedVoipEvent]: (event: MatrixEvent) => void;
     [ClientEvent.TurnServers]: (servers: ITurnServer[]) => void;
@@ -1185,10 +1365,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * High level helper method to begin syncing and poll for new events. To listen for these
-     * events, add a listener for {@link module:client~MatrixClient#event:"event"}
-     * via {@link module:client~MatrixClient#on}. Alternatively, listen for specific
+     * events, add a listener for {@link ClientEvent.Event}
+     * via {@link MatrixClient#on}. Alternatively, listen for specific
      * state change events.
-     * @param {Object=} opts Options to apply when syncing.
+     * @param opts - Options to apply when syncing.
      */
     public async startClient(opts?: IStartClientOpts): Promise<void> {
         if (this.clientRunning) {
@@ -1302,9 +1482,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * initialized with a `cryptoCallback.getDehydrationKey` option, and this
      * function must be called before initCrypto and startClient are called.
      *
-     * @return {Promise<string>} Resolves to undefined if a device could not be dehydrated, or
+     * @returns Promise which resolves to undefined if a device could not be dehydrated, or
      *     to the new device ID if the dehydration was successful.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Rejects: with an error response.
      */
     public async rehydrateDevice(): Promise<string | undefined> {
         if (this.crypto) {
@@ -1379,7 +1559,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the current dehydrated device, if any
-     * @return {Promise} A promise of an object containing the dehydrated device
+     * @returns A promise of an object containing the dehydrated device
      */
     public async getDehydratedDevice(): Promise<IDehydratedDevice | undefined> {
         try {
@@ -1401,12 +1581,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Set the dehydration key.  This will also periodically dehydrate devices to
      * the server.
      *
-     * @param {Uint8Array} key the dehydration key
-     * @param {IDehydratedDeviceKeyInfo} [keyInfo] Information about the key.  Primarily for
+     * @param key - the dehydration key
+     * @param keyInfo - Information about the key.  Primarily for
      *     information about how to generate the key from a passphrase.
-     * @param {string} [deviceDisplayName] The device display name for the
+     * @param deviceDisplayName - The device display name for the
      *     dehydrated device.
-     * @return {Promise} A promise that resolves when the dehydrated device is stored.
+     * @returns A promise that resolves when the dehydrated device is stored.
      */
     public async setDehydrationKey(
         key: Uint8Array,
@@ -1422,12 +1602,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Creates a new dehydrated device (without queuing periodic dehydration)
-     * @param {Uint8Array} key the dehydration key
-     * @param {IDehydratedDeviceKeyInfo} [keyInfo] Information about the key.  Primarily for
+     * @param key - the dehydration key
+     * @param keyInfo - Information about the key.  Primarily for
      *     information about how to generate the key from a passphrase.
-     * @param {string} [deviceDisplayName] The device display name for the
+     * @param deviceDisplayName - The device display name for the
      *     dehydrated device.
-     * @return {Promise<String>} the device id of the newly created dehydrated device
+     * @returns the device id of the newly created dehydrated device
      */
     public async createDehydratedDevice(
         key: Uint8Array,
@@ -1458,7 +1638,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Clear any data out of the persistent stores used by the client.
      *
-     * @returns {Promise} Promise which resolves when the stores have been cleared.
+     * @returns Promise which resolves when the stores have been cleared.
      */
     public clearStores(): Promise<void> {
         if (this.clientRunning) {
@@ -1477,7 +1657,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the user-id of the logged-in user
      *
-     * @return {?string} MXID for the logged-in user, or null if not logged in
+     * @returns MXID for the logged-in user, or null if not logged in
      */
     public getUserId(): string | null {
         if (this.credentials && this.credentials.userId) {
@@ -1488,7 +1668,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the domain for this client's MXID
-     * @return {?string} Domain of this MXID
+     * @returns Domain of this MXID
      */
     public getDomain(): string | null {
         if (this.credentials && this.credentials.userId) {
@@ -1498,8 +1678,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * Get the local part of the current user ID e.g. "foo" in "@foo:bar".
-     * @return {?string} The user ID localpart or null.
+     * Get the local part of the current user ID e.g. "foo" in "\@foo:bar".
+     * @returns The user ID localpart or null.
      */
     public getUserIdLocalpart(): string | null {
         if (this.credentials && this.credentials.userId) {
@@ -1510,7 +1690,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the device ID of this client
-     * @return {?string} device ID
+     * @returns device ID
      */
     public getDeviceId(): string | null {
         return this.deviceId;
@@ -1518,7 +1698,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the session ID of this client
-     * @return {string} session ID
+     * @returns session ID
      */
     public getSessionId(): string {
         return this.sessionId;
@@ -1526,14 +1706,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Check if the runtime environment supports VoIP calling.
-     * @return {boolean} True if VoIP is supported.
+     * @returns True if VoIP is supported.
      */
     public supportsVoip(): boolean {
         return this.canSupportVoip;
     }
 
     /**
-     * @returns {MediaHandler}
+     * @returns
      */
     public getMediaHandler(): MediaHandler {
         return this.mediaHandler;
@@ -1543,7 +1723,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Set whether VoIP calls are forced to use only TURN
      * candidates. This is the same as the forceTURN option
      * when creating the client.
-     * @param {boolean} force True to force use of TURN servers
+     * @param force - True to force use of TURN servers
      */
     public setForceTURN(force: boolean): void {
         this.forceTURN = force;
@@ -1551,7 +1731,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Set whether to advertise transfer support to other parties on Matrix calls.
-     * @param {boolean} support True to advertise the 'm.call.transferee' capability
+     * @param support - True to advertise the 'm.call.transferee' capability
      */
     public setSupportsCallTransfer(support: boolean): void {
         this.supportsCallTransfer = support;
@@ -1570,8 +1750,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Creates a new call.
      * The place*Call methods on the returned call can be used to actually place a call
      *
-     * @param {string} roomId The room the call is to be placed in.
-     * @return {MatrixCall} the call or null if the browser doesn't support calling.
+     * @param roomId - The room the call is to be placed in.
+     * @returns the call or null if the browser doesn't support calling.
      */
     public createCall(roomId: string): MatrixCall | null {
         return createNewMatrixCall(this, roomId);
@@ -1581,8 +1761,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Creates a new group call and sends the associated state event
      * to alert other members that the room now has a group call.
      *
-     * @param {string} roomId The room the call is to be placed in.
-     * @return {GroupCall}
+     * @param roomId - The room the call is to be placed in.
      */
     public async createGroupCall(
         roomId: string,
@@ -1621,7 +1800,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * avoids races where getGroupCallForRoom is called before the state for that
      * room has been processed. It does not, however, fix other races, eg. two
      * clients both creating a group call at the same time.
-     * @param roomId The room ID to wait for
+     * @param roomId - The room ID to wait for
      * @returns A promise that resolves once existing group calls in the room
      *          have been processed.
      */
@@ -1631,8 +1810,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get an existing group call for the provided room.
-     * @param roomId
-     * @returns {GroupCall} The group call or null if it doesn't already exist.
+     * @returns The group call or null if it doesn't already exist.
      */
     public getGroupCallForRoom(roomId: string): GroupCall | null {
         return this.groupCallEventHandler!.groupCalls.get(roomId) || null;
@@ -1640,8 +1818,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the current sync state.
-     * @return {?SyncState} the sync state, which may be null.
-     * @see module:client~MatrixClient#event:"sync"
+     * @returns the sync state, which may be null.
+     * @see MatrixClient#event:"sync"
      */
     public getSyncState(): SyncState | null {
         return this.syncApi?.getSyncState() ?? null;
@@ -1653,7 +1831,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * such data.
      * Sync errors, if available, are put in the 'error' key of
      * this object.
-     * @return {?Object}
      */
     public getSyncStateData(): ISyncStateData | null {
         if (!this.syncApi) {
@@ -1664,7 +1841,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Whether the initial sync has completed.
-     * @return {boolean} True if at least one sync has happened.
+     * @returns True if at least one sync has happened.
      */
     public isInitialSyncComplete(): boolean {
         const state = this.getSyncState();
@@ -1676,7 +1853,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Return whether the client is configured for a guest account.
-     * @return {boolean} True if this is a guest access_token (or no token is supplied).
+     * @returns True if this is a guest access_token (or no token is supplied).
      */
     public isGuest(): boolean {
         return this.isGuestAccount;
@@ -1685,7 +1862,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Set whether this client is a guest account. <b>This method is experimental
      * and may change without warning.</b>
-     * @param {boolean} guest True if this is a guest account.
+     * @param guest - True if this is a guest account.
      */
     public setGuest(guest: boolean): void {
         // EXPERIMENTAL:
@@ -1697,7 +1874,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Return the provided scheduler, if any.
-     * @return {?module:scheduler~MatrixScheduler} The scheduler or undefined
+     * @returns The scheduler or undefined
      */
     public getScheduler(): MatrixScheduler | undefined {
         return this.scheduler;
@@ -1708,7 +1885,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * the user <b>explicitly</b> attempts to retry their lost connection.
      * Will also retry any outbound to-device messages currently in the queue to be sent
      * (retries of regular outgoing events are handled separately, per-event).
-     * @return {boolean} True if this resulted in a request being retried.
+     * @returns True if this resulted in a request being retried.
      */
     public retryImmediately(): boolean {
         // don't await for this promise: we just want to kick it off
@@ -1719,7 +1896,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Return the global notification EventTimelineSet, if any
      *
-     * @return {EventTimelineSet} the globl notification EventTimelineSet
+     * @returns the globl notification EventTimelineSet
      */
     public getNotifTimelineSet(): EventTimelineSet | null {
         return this.notifTimelineSet;
@@ -1728,7 +1905,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Set the global notification EventTimelineSet
      *
-     * @param {EventTimelineSet} set
      */
     public setNotifTimelineSet(set: EventTimelineSet): void {
         this.notifTimelineSet = set;
@@ -1737,9 +1913,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Gets the capabilities of the homeserver. Always returns an object of
      * capability keys and their options, which may be empty.
-     * @param {boolean} fresh True to ignore any cached values.
-     * @return {Promise} Resolves to the capabilities of the homeserver
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param fresh - True to ignore any cached values.
+     * @returns Promise which resolves to the capabilities of the homeserver
+     * @returns Rejects: with an error response.
      */
     public getCapabilities(fresh = false): Promise<ICapabilities> {
         const now = new Date().getTime();
@@ -1870,7 +2046,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Is end-to-end crypto enabled for this client.
-     * @return {boolean} True if end-to-end is enabled.
+     * @returns True if end-to-end is enabled.
      */
     public isCryptoEnabled(): boolean {
         return !!this.crypto;
@@ -1879,7 +2055,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the Ed25519 key for this device
      *
-     * @return {?string} base64-encoded ed25519 key. Null if crypto is
+     * @returns base64-encoded ed25519 key. Null if crypto is
      *    disabled.
      */
     public getDeviceEd25519Key(): string | null {
@@ -1889,7 +2065,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the Curve25519 key for this device
      *
-     * @return {?string} base64-encoded curve25519 key. Null if crypto is
+     * @returns base64-encoded curve25519 key. Null if crypto is
      *    disabled.
      */
     public getDeviceCurve25519Key(): string | null {
@@ -1906,11 +2082,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Download the keys for a list of users and stores the keys in the session
      * store.
-     * @param {Array} userIds The users to fetch.
-     * @param {boolean} forceDownload Always download the keys even if cached.
+     * @param userIds - The users to fetch.
+     * @param forceDownload - Always download the keys even if cached.
      *
-     * @return {Promise} A promise which resolves to a map userId->deviceId->{@link
-        * module:crypto~DeviceInfo|DeviceInfo}.
+     * @returns A promise which resolves to a map userId-\>deviceId-\>{@link DeviceInfo}
      */
     public downloadKeys(
         userIds: string[],
@@ -1925,9 +2100,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the stored device keys for a user id
      *
-     * @param {string} userId the user to list keys for.
+     * @param userId - the user to list keys for.
      *
-     * @return {module:crypto/deviceinfo[]} list of devices
+     * @returns list of devices
      */
     public getStoredDevicesForUser(userId: string): DeviceInfo[] {
         if (!this.crypto) {
@@ -1939,10 +2114,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the stored device key for a user id and device id
      *
-     * @param {string} userId the user to list keys for.
-     * @param {string} deviceId unique identifier for the device
+     * @param userId - the user to list keys for.
+     * @param deviceId - unique identifier for the device
      *
-     * @return {module:crypto/deviceinfo} device or null
+     * @returns device or null
      */
     public getStoredDevice(userId: string, deviceId: string): DeviceInfo | null {
         if (!this.crypto) {
@@ -1954,16 +2129,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Mark the given device as verified
      *
-     * @param {string} userId owner of the device
-     * @param {string} deviceId unique identifier for the device or user's
+     * @param userId - owner of the device
+     * @param deviceId - unique identifier for the device or user's
      * cross-signing public key ID.
      *
-     * @param {boolean=} verified whether to mark the device as verified. defaults
+     * @param verified - whether to mark the device as verified. defaults
      *   to 'true'.
      *
-     * @returns {Promise}
+     * @returns
      *
-     * @fires module:client~event:MatrixClient"deviceVerificationChanged"
+     * @remarks
+     * Fires {@link CryptoEvent#DeviceVerificationChanged}
      */
     public setDeviceVerified(userId: string, deviceId: string, verified = true): Promise<void> {
         const prom = this.setDeviceVerification(userId, deviceId, verified, null, null);
@@ -1980,16 +2156,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Mark the given device as blocked/unblocked
      *
-     * @param {string} userId owner of the device
-     * @param {string} deviceId unique identifier for the device or user's
+     * @param userId - owner of the device
+     * @param deviceId - unique identifier for the device or user's
      * cross-signing public key ID.
      *
-     * @param {boolean=} blocked whether to mark the device as blocked. defaults
+     * @param blocked - whether to mark the device as blocked. defaults
      *   to 'true'.
      *
-     * @returns {Promise}
+     * @returns
      *
-     * @fires module:client~event:MatrixClient"deviceVerificationChanged"
+     * @remarks
+     * Fires {@link CryptoEvent.DeviceVerificationChanged}
      */
     public setDeviceBlocked(userId: string, deviceId: string, blocked = true): Promise<void> {
         return this.setDeviceVerification(userId, deviceId, null, blocked, null);
@@ -1998,16 +2175,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Mark the given device as known/unknown
      *
-     * @param {string} userId owner of the device
-     * @param {string} deviceId unique identifier for the device or user's
+     * @param userId - owner of the device
+     * @param deviceId - unique identifier for the device or user's
      * cross-signing public key ID.
      *
-     * @param {boolean=} known whether to mark the device as known. defaults
+     * @param known - whether to mark the device as known. defaults
      *   to 'true'.
      *
-     * @returns {Promise}
+     * @returns
      *
-     * @fires module:client~event:MatrixClient"deviceVerificationChanged"
+     * @remarks
+     * Fires {@link CryptoEvent#DeviceVerificationChanged}
      */
     public setDeviceKnown(userId: string, deviceId: string, known = true): Promise<void> {
         return this.setDeviceVerification(userId, deviceId, null, null, known);
@@ -2029,10 +2207,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Request a key verification from another user, using a DM.
      *
-     * @param {string} userId the user to request verification with
-     * @param {string} roomId the room to use for verification
+     * @param userId - the user to request verification with
+     * @param roomId - the room to use for verification
      *
-     * @returns {Promise<module:crypto/verification/request/VerificationRequest>} resolves to a VerificationRequest
+     * @returns resolves to a VerificationRequest
      *    when the request has been sent to the other party.
      */
     public requestVerificationDM(userId: string, roomId: string): Promise<VerificationRequest> {
@@ -2045,9 +2223,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Finds a DM verification request that is already in progress for the given room id
      *
-     * @param {string} roomId the room to use for verification
+     * @param roomId - the room to use for verification
      *
-     * @returns {module:crypto/verification/request/VerificationRequest?} the VerificationRequest that is in progress, if any
+     * @returns the VerificationRequest that is in progress, if any
      */
     public findVerificationRequestDMInProgress(roomId: string): VerificationRequest | undefined {
         if (!this.crypto) {
@@ -2059,9 +2237,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Returns all to-device verification requests that are already in progress for the given user id
      *
-     * @param {string} userId the ID of the user to query
+     * @param userId - the ID of the user to query
      *
-     * @returns {module:crypto/verification/request/VerificationRequest[]} the VerificationRequests that are in progress
+     * @returns the VerificationRequests that are in progress
      */
     public getVerificationRequestsToDeviceInProgress(userId: string): VerificationRequest[] {
         if (!this.crypto) {
@@ -2073,11 +2251,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Request a key verification from another user.
      *
-     * @param {string} userId the user to request verification with
-     * @param {Array} devices array of device IDs to send requests to.  Defaults to
+     * @param userId - the user to request verification with
+     * @param devices - array of device IDs to send requests to.  Defaults to
      *    all devices owned by the user
      *
-     * @returns {Promise<module:crypto/verification/request/VerificationRequest>} resolves to a VerificationRequest
+     * @returns resolves to a VerificationRequest
      *    when the request has been sent to the other party.
      */
     public requestVerification(userId: string, devices?: string[]): Promise<VerificationRequest> {
@@ -2090,11 +2268,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Begin a key verification.
      *
-     * @param {string} method the verification method to use
-     * @param {string} userId the user to verify keys with
-     * @param {string} deviceId the device to verify
+     * @param method - the verification method to use
+     * @param userId - the user to verify keys with
+     * @param deviceId - the device to verify
      *
-     * @returns {Verification} a verification object
+     * @returns a verification object
      * @deprecated Use `requestVerification` instead.
      */
     public beginKeyVerification(method: string, userId: string, deviceId: string): Verification<any, any> {
@@ -2116,7 +2294,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * messages to unverified devices.  This provides the default for rooms which
      * do not specify a value.
      *
-     * @param {boolean} value whether to blacklist all unverified devices by default
+     * @param value - whether to blacklist all unverified devices by default
      */
     public setGlobalBlacklistUnverifiedDevices(value: boolean): boolean {
         if (!this.crypto) {
@@ -2127,7 +2305,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @return {boolean} whether to blacklist all unverified devices by default
+     * @returns whether to blacklist all unverified devices by default
      */
     public getGlobalBlacklistUnverifiedDevices(): boolean {
         if (!this.crypto) {
@@ -2144,7 +2322,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * This API is currently UNSTABLE and may change or be removed without notice.
      *
-     * @param {boolean} value whether error on unknown devices
+     * @param value - whether error on unknown devices
      */
     public setGlobalErrorOnUnknownDevices(value: boolean): void {
         if (!this.crypto) {
@@ -2154,7 +2332,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @return {boolean} whether to error on unknown devices
+     * @returns whether to error on unknown devices
      *
      * This API is currently UNSTABLE and may change or be removed without notice.
      */
@@ -2170,10 +2348,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @param {CrossSigningKey} [type=master] The type of key to get the ID of.  One of
+     * @param type - The type of key to get the ID of.  One of
      *     "master", "self_signing", or "user_signing".  Defaults to "master".
      *
-     * @returns {string} the key ID
+     * @returns the key ID
      */
     public getCrossSigningId(type: CrossSigningKey | string = CrossSigningKey.Master): string | null {
         if (!this.crypto) {
@@ -2187,9 +2365,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} userId the user ID to get the cross-signing info for.
+     * @param userId - the user ID to get the cross-signing info for.
      *
-     * @returns {CrossSigningInfo} the cross signing information for the user.
+     * @returns the cross signing information for the user.
      */
     public getStoredCrossSigningForUser(userId: string): CrossSigningInfo | null {
         if (!this.crypto) {
@@ -2203,9 +2381,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} userId The ID of the user to check.
+     * @param userId - The ID of the user to check.
      *
-     * @returns {UserTrustLevel}
+     * @returns
      */
     public checkUserTrust(userId: string): UserTrustLevel {
         if (!this.crypto) {
@@ -2219,11 +2397,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @function module:client~MatrixClient#checkDeviceTrust
-     * @param {string} userId The ID of the user whose devices is to be checked.
-     * @param {string} deviceId The ID of the device to check
-     *
-     * @returns {DeviceTrustLevel}
+     * @param userId - The ID of the user whose devices is to be checked.
+     * @param deviceId - The ID of the device to check
      */
     public checkDeviceTrust(userId: string, deviceId: string): DeviceTrustLevel {
         if (!this.crypto) {
@@ -2236,9 +2411,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Check whether one of our own devices is cross-signed by our
      * user's stored keys, regardless of whether we trust those keys yet.
      *
-     * @param {string} deviceId The ID of the device to check
+     * @param deviceId - The ID of the device to check
      *
-     * @returns {boolean} true if the device is cross-signed
+     * @returns true if the device is cross-signed
      */
     public checkIfOwnDeviceCrossSigned(deviceId: string): boolean {
         if (!this.crypto) {
@@ -2250,7 +2425,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Check the copy of our cross-signing key that we have in the device list and
      * see if we can get the private key. If so, mark it as trusted.
-     * @param {Object} opts ICheckOwnCrossSigningTrustOpts object
+     * @param opts - ICheckOwnCrossSigningTrustOpts object
      */
     public checkOwnCrossSigningTrust(opts?: ICheckOwnCrossSigningTrustOpts): Promise<void> {
         if (!this.crypto) {
@@ -2263,9 +2438,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Checks that a given cross-signing private key matches a given public key.
      * This can be used by the getCrossSigningKey callback to verify that the
      * private key it is about to supply is the one that was requested.
-     * @param {Uint8Array} privateKey The private key
-     * @param {string} expectedPublicKey The public key
-     * @returns {boolean} true if the key matches, otherwise false
+     * @param privateKey - The private key
+     * @param expectedPublicKey - The public key
+     * @returns true if the key matches, otherwise false
      */
     public checkCrossSigningPrivateKey(privateKey: Uint8Array, expectedPublicKey: string): boolean {
         if (!this.crypto) {
@@ -2289,7 +2464,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Perform any background tasks that can be done before a message is ready to
      * send, in order to speed up sending of the message.
-     * @param {module:models/room} room the room the event is in
+     * @param room - the room the event is in
      */
     public prepareToEncrypt(room: Room): void {
         if (!this.crypto) {
@@ -2307,7 +2482,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * to fix things such that it returns true. That is to say, after
      * bootstrapCrossSigning() completes successfully, this function should
      * return true.
-     * @return {boolean} True if cross-signing is ready to be used on this device
+     * @returns True if cross-signing is ready to be used on this device
      */
     public isCrossSigningReady(): Promise<boolean> {
         if (!this.crypto) {
@@ -2326,15 +2501,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *   secret storage (if it has been setup)
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
-     *
-     * @param {function} opts.authUploadDeviceSigningKeys Function
-     * called to await an interactive auth flow when uploading device signing keys.
-     * @param {boolean} [opts.setupNewCrossSigning] Optional. Reset even if keys
-     * already exist.
-     * Args:
-     *     {function} A function that makes the request requiring auth. Receives the
-     *     auth data as an object. Can be called multiple times, first with an empty
-     *     authDict, to obtain the flows.
      */
     public bootstrapCrossSigning(opts: IBootstrapCrossSigningOpts): Promise<void> {
         if (!this.crypto) {
@@ -2350,7 +2516,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * Default: true
      *
-     * @return {boolean} True if trusting cross-signed devices
+     * @returns True if trusting cross-signed devices
      */
     public getCryptoTrustCrossSignedDevices(): boolean {
         if (!this.crypto) {
@@ -2362,7 +2528,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * See getCryptoTrustCrossSignedDevices
      *
-     * @param {boolean} val True to trust cross-signed devices
+     * @param val - True to trust cross-signed devices
      */
     public setCryptoTrustCrossSignedDevices(val: boolean): void {
         if (!this.crypto) {
@@ -2373,7 +2539,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Counts the number of end to end session keys that are waiting to be backed up
-     * @returns {Promise<number>} Resolves to the number of sessions requiring backup
+     * @returns Promise which resolves to the number of sessions requiring backup
      */
     public countSessionsNeedingBackup(): Promise<number> {
         if (!this.crypto) {
@@ -2385,8 +2551,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get information about the encryption of an event
      *
-     * @param {module:models/event.MatrixEvent} event event to be checked
-     * @returns {IEncryptedEventInfo} The event information.
+     * @param event - event to be checked
+     * @returns The event information.
      */
     public getEventEncryptionInfo(event: MatrixEvent): IEncryptedEventInfo {
         if (!this.crypto) {
@@ -2400,10 +2566,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} password Passphrase string that can be entered by the user
+     * @param password - Passphrase string that can be entered by the user
      *     when restoring the backup as an alternative to entering the recovery key.
      *     Optional.
-     * @returns {Promise<Object>} Object with public key metadata, encoded private
+     * @returns Object with public key metadata, encoded private
      *     recovery key which should be disposed of after displaying to the user,
      *     and raw private key to avoid round tripping if needed.
      */
@@ -2427,7 +2593,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @return {boolean} True if secret storage is ready to be used on this device
+     * @returns True if secret storage is ready to be used on this device
      */
     public isSecretStorageReady(): Promise<boolean> {
         if (!this.crypto) {
@@ -2449,7 +2615,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * - migrates Secure Secret Storage to use the latest algorithm, if an outdated
      *   algorithm is found
      *
-     * @param opts
      */
     public bootstrapSecretStorage(opts: ICreateSecretStorageOpts): Promise<void> {
         if (!this.crypto) {
@@ -2463,14 +2628,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} algorithm the algorithm used by the key
-     * @param {object} opts the options for the algorithm.  The properties used
+     * @param algorithm - the algorithm used by the key
+     * @param opts - the options for the algorithm.  The properties used
      *     depend on the algorithm given.
-     * @param {string} [keyName] the name of the key.  If not given, a random name will be generated.
+     * @param keyName - the name of the key.  If not given, a random name will be generated.
      *
-     * @return {object} An object with:
-     *     keyId: {string} the ID of the key
-     *     keyInfo: {object} details about the key (iv, mac, passphrase)
+     * @returns An object with:
+     *     keyId: the ID of the key
+     *     keyInfo: details about the key (iv, mac, passphrase)
      */
     public addSecretStorageKey(
         algorithm: string,
@@ -2488,9 +2653,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} [keyId = default key's ID] The ID of the key to check
+     * @param keyId - The ID of the key to check
      *     for. Defaults to the default key ID if not provided.
-     * @return {boolean} Whether we have the key.
+     * @returns Whether we have the key.
      */
     public hasSecretStorageKey(keyId?: string): Promise<boolean> {
         if (!this.crypto) {
@@ -2504,9 +2669,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} name The name of the secret
-     * @param {string} secret The secret contents.
-     * @param {Array} keys The IDs of the keys to use to encrypt the secret or null/undefined
+     * @param name - The name of the secret
+     * @param secret - The secret contents.
+     * @param keys - The IDs of the keys to use to encrypt the secret or null/undefined
      *     to use the default (will throw if no default key is set).
      */
     public storeSecret(name: string, secret: string, keys?: string[]): Promise<void> {
@@ -2521,9 +2686,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} name the name of the secret
+     * @param name - the name of the secret
      *
-     * @return {string} the contents of the secret
+     * @returns the contents of the secret
      */
     public getSecret(name: string): Promise<string | undefined> {
         if (!this.crypto) {
@@ -2537,8 +2702,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} name the name of the secret
-     * @return {object?} map of key name to key info the secret is encrypted
+     * @param name - the name of the secret
+     * @returns map of key name to key info the secret is encrypted
      *     with, or null if it is not present or not encrypted with a trusted
      *     key
      */
@@ -2554,10 +2719,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} name the name of the secret to request
-     * @param {string[]} devices the devices to request the secret from
+     * @param name - the name of the secret to request
+     * @param devices - the devices to request the secret from
      *
-     * @return {ISecretRequest} the secret request object
+     * @returns the secret request object
      */
     public requestSecret(name: string, devices: string[]): ISecretRequest {
         if (!this.crypto) {
@@ -2571,7 +2736,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @return {string} The default key ID or null if no default key ID is set
+     * @returns The default key ID or null if no default key ID is set
      */
     public getDefaultSecretStorageKeyId(): Promise<string | null> {
         if (!this.crypto) {
@@ -2585,7 +2750,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} keyId The new default key ID
+     * @param keyId - The new default key ID
      */
     public setDefaultSecretStorageKeyId(keyId: string): Promise<void> {
         if (!this.crypto) {
@@ -2601,9 +2766,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {Uint8Array} privateKey The private key
-     * @param {string} expectedPublicKey The public key
-     * @returns {boolean} true if the key matches, otherwise false
+     * @param privateKey - The private key
+     * @param expectedPublicKey - The public key
+     * @returns true if the key matches, otherwise false
      */
     public checkSecretStoragePrivateKey(privateKey: Uint8Array, expectedPublicKey: string): boolean {
         if (!this.crypto) {
@@ -2615,9 +2780,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get e2e information on the device that sent an event
      *
-     * @param {MatrixEvent} event event to be checked
-     *
-     * @return {Promise<module:crypto/deviceinfo?>}
+     * @param event - event to be checked
      */
     public async getEventSenderDeviceInfo(event: MatrixEvent): Promise<DeviceInfo | null> {
         if (!this.crypto) {
@@ -2629,10 +2792,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Check if the sender of an event is verified
      *
-     * @param {MatrixEvent} event event to be checked
+     * @param event - event to be checked
      *
-     * @return {boolean} true if the sender of this event has been verified using
-     * {@link module:client~MatrixClient#setDeviceVerified|setDeviceVerified}.
+     * @returns true if the sender of this event has been verified using
+     * {@link MatrixClient#setDeviceVerified}.
      */
     public async isEventSenderVerified(event: MatrixEvent): Promise<boolean> {
         const device = await this.getEventSenderDeviceInfo(event);
@@ -2644,9 +2807,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get outgoing room key request for this event if there is one.
-     * @param {MatrixEvent} event The event to check for
+     * @param event - The event to check for
      *
-     * @return {Promise} A room key request, or null if there is none
+     * @returns A room key request, or null if there is none
      */
     public getOutgoingRoomKeyRequest(event: MatrixEvent): Promise<OutgoingRoomKeyRequest | null> {
         if (!this.crypto) {
@@ -2671,9 +2834,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Cancel a room key request for this event if one is ongoing and resend the
      * request.
-     * @param  {MatrixEvent} event event of which to cancel and resend the room
+     * @param event - event of which to cancel and resend the room
      *                            key request.
-     * @return {Promise} A promise that will resolve when the key request is queued
+     * @returns A promise that will resolve when the key request is queued
      */
     public cancelAndResendEventRoomKeyRequest(event: MatrixEvent): Promise<void> {
         if (!this.crypto) {
@@ -2685,9 +2848,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Enable end-to-end encryption for a room. This does not modify room state.
      * Any messages sent before the returned promise resolves will be sent unencrypted.
-     * @param {string} roomId The room ID to enable encryption in.
-     * @param {object} config The encryption config for the room.
-     * @return {Promise} A promise that will resolve when encryption is set up.
+     * @param roomId - The room ID to enable encryption in.
+     * @param config - The encryption config for the room.
+     * @returns A promise that will resolve when encryption is set up.
      */
     public setRoomEncryption(roomId: string, config: IRoomEncryption): Promise<void> {
         if (!this.crypto) {
@@ -2698,8 +2861,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Whether encryption is enabled for a room.
-     * @param {string} roomId the room id to query.
-     * @return {boolean} whether encryption is enabled.
+     * @param roomId - the room id to query.
+     * @returns whether encryption is enabled.
      */
     public isRoomEncrypted(roomId: string): boolean {
         const room = this.getRoom(roomId);
@@ -2726,14 +2889,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Encrypts and sends a given object via Olm to-device messages to a given
      * set of devices.
      *
-     * @param {object[]} userDeviceInfoArr
-     *   mapping from userId to deviceInfo
+     * @param userDeviceMap - mapping from userId to deviceInfo
+     *
+     * @param payload - fields to include in the encrypted payload
      *
-     * @param {object} payload fields to include in the encrypted payload
-     *      *
-     * @return {Promise<{contentMap, deviceInfoByDeviceId}>} Promise which
+     * @returns Promise which
      *     resolves once the message has been encrypted and sent to the given
-     *     userDeviceMap, and returns the { contentMap, deviceInfoByDeviceId }
+     *     userDeviceMap, and returns the `{ contentMap, deviceInfoByDeviceId }`
      *     of the successfully sent messages.
      */
     public encryptAndSendToDevices(
@@ -2750,7 +2912,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Forces the current outbound group session to be discarded such
      * that another one will be created next time an event is sent.
      *
-     * @param {string} roomId The ID of the room to discard the session for
+     * @param roomId - The ID of the room to discard the session for
      *
      * This should not normally be necessary.
      */
@@ -2766,7 +2928,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * This should be encrypted before returning it to the user.
      *
-     * @return {Promise} a promise which resolves to a list of
+     * @returns a promise which resolves to a list of
      *    session export objects
      */
     public exportRoomKeys(): Promise<IMegolmSessionData[]> {
@@ -2779,12 +2941,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Import a list of room keys previously exported by exportRoomKeys
      *
-     * @param {Object[]} keys a list of session export objects
-     * @param {Object} opts
-     * @param {Function} opts.progressCallback called with an object that has a "stage" param
+     * @param keys - a list of session export objects
      *
-     * @return {Promise} a promise which resolves when the keys
-     *    have been imported
+     * @returns a promise which resolves when the keys have been imported
      */
     public importRoomKeys(keys: IMegolmSessionData[], opts?: IImportRoomKeysOpts): Promise<void> {
         if (!this.crypto) {
@@ -2797,7 +2956,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Force a re-check of the local key backup status against
      * what's on the server.
      *
-     * @returns {Object} Object with backup info (as returned by
+     * @returns Object with backup info (as returned by
      *     getKeyBackupVersion) in backupInfo and
      *     trust information (as returned by isKeyBackupTrusted)
      *     in trustInfo.
@@ -2811,7 +2970,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get information about the current key backup.
-     * @returns {Promise<IKeyBackupInfo | null>} Information object from API or null
+     * @returns Information object from API or null
      */
     public async getKeyBackupVersion(): Promise<IKeyBackupInfo | null> {
         let res: IKeyBackupInfo;
@@ -2832,14 +2991,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {object} info key backup info dict from getKeyBackupVersion()
-     * @return {object} {
-     *     usable: [bool], // is the backup trusted, true iff there is a sig that is valid & from a trusted device
-     *     sigs: [
-     *         valid: [bool],
-     *         device: [DeviceInfo],
-     *     ]
-     * }
+     * @param info - key backup info dict from getKeyBackupVersion()
      */
     public isKeyBackupTrusted(info: IKeyBackupInfo): Promise<TrustInfo> {
         if (!this.crypto) {
@@ -2849,7 +3001,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @returns {boolean} true if the client is configured to back up keys to
+     * @returns true if the client is configured to back up keys to
      *     the server, otherwise false. If we haven't completed a successful check
      *     of key backup status yet, returns null.
      */
@@ -2864,8 +3016,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Enable backing up of keys, using data previously returned from
      * getKeyBackupVersion.
      *
-     * @param {object} info Backup information object as returned by getKeyBackupVersion
-     * @returns {Promise<void>} Resolves when complete.
+     * @param info - Backup information object as returned by getKeyBackupVersion
+     * @returns Promise which resolves when complete.
      */
     public enableKeyBackup(info: IKeyBackupInfo): Promise<void> {
         if (!this.crypto) {
@@ -2890,17 +3042,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Set up the data required to create a new backup version.  The backup version
      * will not be created and enabled until createKeyBackupVersion is called.
      *
-     * @param {string} password Passphrase string that can be entered by the user
+     * @param password - Passphrase string that can be entered by the user
      *     when restoring the backup as an alternative to entering the recovery key.
      *     Optional.
-     * @param {boolean} [opts.secureSecretStorage = false] Whether to use Secure
-     *     Secret Storage to store the key encrypting key backups.
-     *     Optional, defaults to false.
      *
-     * @returns {Promise<object>} Object that can be passed to createKeyBackupVersion and
+     * @returns Object that can be passed to createKeyBackupVersion and
      *     additionally has a 'recovery_key' member with the user-facing recovery key string.
      */
-    // TODO: Verify types
     public async prepareKeyBackupVersion(
         password?: string | Uint8Array | null,
         opts: IKeyBackupPrepareOpts = { secureSecretStorage: false },
@@ -2929,7 +3077,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Check whether the key backup private key is stored in secret storage.
-     * @return {Promise<object?>} map of key name to key info the secret is
+     * @returns map of key name to key info the secret is
      *     encrypted with, or null if it is not present or not encrypted with a
      *     trusted key
      */
@@ -2941,8 +3089,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Create a new key backup version and enable it, using the information return
      * from prepareKeyBackupVersion.
      *
-     * @param {object} info Info object from prepareKeyBackupVersion
-     * @returns {Promise<object>} Object with 'version' param indicating the version created
+     * @param info - Info object from prepareKeyBackupVersion
+     * @returns Object with 'version' param indicating the version created
      */
     public async createKeyBackupVersion(info: IKeyBackupInfo): Promise<IKeyBackupInfo> {
         if (!this.crypto) {
@@ -3036,11 +3184,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Back up session keys to the homeserver.
-     * @param {string} roomId ID of the room that the keys are for Optional.
-     * @param {string} sessionId ID of the session that the keys are for Optional.
-     * @param {number} version backup version Optional.
-     * @param {object} data Object keys to send
-     * @return {Promise} a promise that will resolve when the keys
+     * @param roomId - ID of the room that the keys are for Optional.
+     * @param sessionId - ID of the session that the keys are for Optional.
+     * @param version - backup version Optional.
+     * @param data - Object keys to send
+     * @returns a promise that will resolve when the keys
      * are uploaded
      */
     public sendKeyBackup(
@@ -3093,7 +3241,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Marks all group sessions as needing to be backed up without scheduling
      * them to upload in the background.
-     * @returns {Promise<number>} Resolves to the number of sessions requiring a backup.
+     * @returns Promise which resolves to the number of sessions requiring a backup.
      */
     public flagAllGroupSessionsForBackup(): Promise<number> {
         if (!this.crypto) {
@@ -3118,9 +3266,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} password Passphrase
-     * @param {object} backupInfo Backup metadata from `checkKeyBackup`
-     * @return {Promise<Uint8Array>} key backup key
+     * @param password - Passphrase
+     * @param backupInfo - Backup metadata from `checkKeyBackup`
+     * @returns key backup key
      */
     public keyBackupKeyFromPassword(password: string, backupInfo: IKeyBackupInfo): Promise<Uint8Array> {
         return keyFromAuthData(backupInfo.auth_data, password);
@@ -3132,8 +3280,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @param {string} recoveryKey The recovery key
-     * @return {Uint8Array} key backup key
+     * @param recoveryKey - The recovery key
+     * @returns key backup key
      */
     public keyBackupKeyFromRecoveryKey(recoveryKey: string): Uint8Array {
         return decodeRecoveryKey(recoveryKey);
@@ -3142,14 +3290,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Restore from an existing key backup via a passphrase.
      *
-     * @param {string} password Passphrase
-     * @param {string} [targetRoomId] Room ID to target a specific room.
+     * @param password - Passphrase
+     * @param targetRoomId - Room ID to target a specific room.
      * Restores all rooms if omitted.
-     * @param {string} [targetSessionId] Session ID to target a specific session.
+     * @param targetSessionId - Session ID to target a specific session.
      * Restores all sessions if omitted.
-     * @param {object} backupInfo Backup metadata from `checkKeyBackup`
-     * @param {object} opts Optional params such as callbacks
-     * @return {Promise<object>} Status of restoration with `total` and `imported`
+     * @param backupInfo - Backup metadata from `checkKeyBackup`
+     * @param opts - Optional params such as callbacks
+     * @returns Status of restoration with `total` and `imported`
      * key counts.
      */
     public async restoreKeyBackupWithPassword(
@@ -3188,13 +3336,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Restore from an existing key backup via a private key stored in secret
      * storage.
      *
-     * @param {object} backupInfo Backup metadata from `checkKeyBackup`
-     * @param {string} [targetRoomId] Room ID to target a specific room.
+     * @param backupInfo - Backup metadata from `checkKeyBackup`
+     * @param targetRoomId - Room ID to target a specific room.
      * Restores all rooms if omitted.
-     * @param {string} [targetSessionId] Session ID to target a specific session.
+     * @param targetSessionId - Session ID to target a specific session.
      * Restores all sessions if omitted.
-     * @param {object} opts Optional params such as callbacks
-     * @return {Promise<object>} Status of restoration with `total` and `imported`
+     * @param opts - Optional params such as callbacks
+     * @returns Status of restoration with `total` and `imported`
      * key counts.
      */
     public async restoreKeyBackupWithSecretStorage(
@@ -3223,15 +3371,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Restore from an existing key backup via an encoded recovery key.
      *
-     * @param {string} recoveryKey Encoded recovery key
-     * @param {string} [targetRoomId] Room ID to target a specific room.
+     * @param recoveryKey - Encoded recovery key
+     * @param targetRoomId - Room ID to target a specific room.
      * Restores all rooms if omitted.
-     * @param {string} [targetSessionId] Session ID to target a specific session.
+     * @param targetSessionId - Session ID to target a specific session.
      * Restores all sessions if omitted.
-     * @param {object} backupInfo Backup metadata from `checkKeyBackup`
-     * @param {object} opts Optional params such as callbacks
+     * @param backupInfo - Backup metadata from `checkKeyBackup`
+     * @param opts - Optional params such as callbacks
 
-     * @return {Promise<object>} Status of restoration with `total` and `imported`
+     * @returns Status of restoration with `total` and `imported`
      * key counts.
      */
     public restoreKeyBackupWithRecoveryKey(
@@ -3435,8 +3583,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Share shared-history decryption keys with the given users.
      *
-     * @param {string} roomId the room for which keys should be shared.
-     * @param {array} userIds a list of users to share with.  The keys will be sent to
+     * @param roomId - the room for which keys should be shared.
+     * @param userIds - a list of users to share with.  The keys will be sent to
      *     all of the user's current devices.
      */
     public async sendSharedHistoryKeys(roomId: string, userIds: string[]): Promise<void> {
@@ -3468,7 +3616,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the config for the media repository.
-     * @return {Promise} Resolves with an object containing the config.
+     * @returns Promise which resolves with an object containing the config.
      */
     public getMediaConfig(): Promise<IMediaConfig> {
         return this.http.authedRequest(
@@ -3483,8 +3631,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * This function will return a valid room for any room for which a Room event
      * has been emitted. Note in particular that other events, eg. RoomState.members
      * will be emitted for a room before this function will return the given room.
-     * @param {string} roomId The room ID
-     * @return {Room|null} The Room or null if it doesn't exist or there is no data store.
+     * @param roomId - The room ID
+     * @returns The Room or null if it doesn't exist or there is no data store.
      */
     public getRoom(roomId: string | undefined): Room | null {
         if (!roomId) {
@@ -3495,7 +3643,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Retrieve all known rooms.
-     * @return {Room[]} A list of rooms, or an empty list if there is no data store.
+     * @returns A list of rooms, or an empty list if there is no data store.
      */
     public getRooms(): Room[] {
         return this.store.getRooms();
@@ -3506,7 +3654,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * This is essentially getRooms() with some rooms filtered out, eg. old versions
      * of rooms that have been replaced or (in future) other rooms that have been
      * marked at the protocol level as not to be displayed to the user.
-     * @return {Room[]} A list of rooms, or an empty list if there is no data store.
+     * @returns A list of rooms, or an empty list if there is no data store.
      */
     public getVisibleRooms(): Room[] {
         const allRooms = this.store.getRooms();
@@ -3534,8 +3682,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Retrieve a user.
-     * @param {string} userId The user ID to retrieve.
-     * @return {?User} A user or null if there is no data store or the user does
+     * @param userId - The user ID to retrieve.
+     * @returns A user or null if there is no data store or the user does
      * not exist.
      */
     public getUser(userId: string): User | null {
@@ -3544,7 +3692,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Retrieve all known users.
-     * @return {User[]} A list of users, or an empty list if there is no data store.
+     * @returns A list of users, or an empty list if there is no data store.
      */
     public getUsers(): User[] {
         return this.store.getUsers();
@@ -3553,10 +3701,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Set account data event for the current user.
      * It will retry the request up to 5 times.
-     * @param {string} eventType The event type
-     * @param {Object} content the contents object for the event
-     * @return {Promise} Resolves: an empty object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param eventType - The event type
+     * @param content - the contents object for the event
+     * @returns Promise which resolves: an empty object
+     * @returns Rejects: with an error response.
      */
     public setAccountData(eventType: EventType | string, content: IContent): Promise<{}> {
         const path = utils.encodeUri("/user/$userId/account_data/$type", {
@@ -3570,8 +3718,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get account data event of given type for the current user.
-     * @param {string} eventType The event type
-     * @return {?object} The contents of the given account data event
+     * @param eventType - The event type
+     * @returns The contents of the given account data event
      */
     public getAccountData(eventType: string): MatrixEvent | undefined {
         return this.store.getAccountData(eventType);
@@ -3581,9 +3729,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Get account data event of given type for the current user. This variant
      * gets account data directly from the homeserver if the local store is not
      * ready, which can be useful very early in startup before the initial sync.
-     * @param {string} eventType The event type
-     * @return {Promise} Resolves: The contents of the given account data event.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param eventType - The event type
+     * @returns Promise which resolves: The contents of the given account data event.
+     * @returns Rejects: with an error response.
      */
     public async getAccountDataFromServer<T extends {[k: string]: any}>(eventType: string): Promise<T | null> {
         if (this.isInitialSyncComplete()) {
@@ -3611,7 +3759,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Gets the users that are ignored by this client
-     * @returns {string[]} The array of users that are ignored (empty if none)
+     * @returns The array of users that are ignored (empty if none)
      */
     public getIgnoredUsers(): string[] {
         const event = this.getAccountData("m.ignored_user_list");
@@ -3621,9 +3769,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Sets the users that the current user should ignore.
-     * @param {string[]} userIds the user IDs to ignore
-     * @return {Promise} Resolves: an empty object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param userIds - the user IDs to ignore
+     * @returns Promise which resolves: an empty object
+     * @returns Rejects: with an error response.
      */
     public setIgnoredUsers(userIds: string[]): Promise<{}> {
         const content = { ignored_users: {} as Record<string, object> };
@@ -3635,8 +3783,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Gets whether or not a specific user is being ignored by this client.
-     * @param {string} userId the user ID to check
-     * @returns {boolean} true if the user is ignored, false otherwise
+     * @param userId - the user ID to check
+     * @returns true if the user is ignored, false otherwise
      */
     public isUserIgnored(userId: string): boolean {
         return this.getIgnoredUsers().includes(userId);
@@ -3644,15 +3792,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Join a room. If you have already joined the room, this will no-op.
-     * @param {string} roomIdOrAlias The room ID or room alias to join.
-     * @param {Object} opts Options when joining the room.
-     * @param {boolean} opts.syncRoom True to do a room initial sync on the resulting
-     * room. If false, the <strong>returned Room object will have no current state.
-     * </strong> Default: true.
-     * @param {boolean} opts.inviteSignUrl If the caller has a keypair 3pid invite, the signing URL is passed in this parameter.
-     * @param {string[]} opts.viaServers The server names to try and join through in addition to those that are automatically chosen.
-     * @return {Promise} Resolves: Room object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param roomIdOrAlias - The room ID or room alias to join.
+     * @param opts - Options when joining the room.
+     * @returns Promise which resolves: Room object.
+     * @returns Rejects: with an error response.
      */
     public async joinRoom(roomIdOrAlias: string, opts: IJoinRoomOpts = {}): Promise<Room> {
         if (opts.syncRoom === undefined) {
@@ -3702,11 +3845,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Resend an event. Will also retry any to-device messages waiting to be sent.
-     * @param {MatrixEvent} event The event to resend.
-     * @param {Room} room Optional. The room the event is in. Will update the
+     * @param event - The event to resend.
+     * @param room - Optional. The room the event is in. Will update the
      * timeline entry if provided.
-     * @return {Promise} Resolves: to an ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public resendEvent(event: MatrixEvent, room: Room): Promise<ISendEventResponse> {
         // also kick the to-device queue to retry
@@ -3719,7 +3862,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Cancel a queued or unsent event.
      *
-     * @param {MatrixEvent} event   Event to cancel
+     * @param event -   Event to cancel
      * @throws Error if the event is not in QUEUED, NOT_SENT or ENCRYPTING state
      */
     public cancelPendingEvent(event: MatrixEvent): void {
@@ -3742,21 +3885,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} name
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public setRoomName(roomId: string, name: string): Promise<ISendEventResponse> {
         return this.sendStateEvent(roomId, EventType.RoomName, { name: name });
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} topic
-     * @param {string} htmlTopic Optional.
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param htmlTopic - Optional.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public setRoomTopic(
         roomId: string,
@@ -3768,9 +3907,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @return {Promise} Resolves: to an object keyed by tagId with objects containing a numeric order field.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an object keyed by tagId with objects containing a numeric order field.
+     * @returns Rejects: with an error response.
      */
     public getRoomTags(roomId: string): Promise<ITagsResponse> {
         const path = utils.encodeUri("/user/$userId/rooms/$roomId/tags", {
@@ -3781,11 +3919,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} tagName name of room tag to be set
-     * @param {object} metadata associated with that tag to be stored
-     * @return {Promise} Resolves: to an empty object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param tagName - name of room tag to be set
+     * @param metadata - associated with that tag to be stored
+     * @returns Promise which resolves: to an empty object
+     * @returns Rejects: with an error response.
      */
     public setRoomTag(roomId: string, tagName: string, metadata: ITagMetadata): Promise<{}> {
         const path = utils.encodeUri("/user/$userId/rooms/$roomId/tags/$tag", {
@@ -3797,10 +3934,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} tagName name of room tag to be removed
-     * @return {Promise} Resolves: to an empty object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param tagName - name of room tag to be removed
+     * @returns Promise which resolves: to an empty object
+     * @returns Rejects: with an error response.
      */
     public deleteRoomTag(roomId: string, tagName: string): Promise<{}> {
         const path = utils.encodeUri("/user/$userId/rooms/$roomId/tags/$tag", {
@@ -3812,11 +3948,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} eventType event type to be set
-     * @param {object} content event content
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param eventType - event type to be set
+     * @param content - event content
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public setRoomAccountData(
         roomId: string,
@@ -3833,12 +3968,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Set a power level to one or multiple users.
-     * @param {string} roomId
-     * @param {string|string[]} userId
-     * @param {Number} powerLevel
-     * @param {MatrixEvent} event
-     * @return {Promise} Resolves: to an ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public setPowerLevel(
         roomId: string,
@@ -3869,9 +4000,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Create an m.beacon_info event
-     * @param {string} roomId
-     * @param {MBeaconInfoEventContent} beaconInfoContent
-     * @returns {ISendEventResponse}
+     * @returns
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
     public async unstable_createLiveBeacon(
@@ -3884,9 +4013,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Upsert a live beacon event
      * using a specific m.beacon_info.* event variable type
-     * @param {string} roomId string
-     * @param {MBeaconInfoEventContent} beaconInfoContent
-     * @returns {ISendEventResponse}
+     * @param roomId - string
+     * @returns
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
     public async unstable_setLiveBeacon(
@@ -3896,15 +4024,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return this.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, this.getUserId()!);
     }
 
-    /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} eventType
-     * @param {Object} content
-     * @param {string} txnId Optional.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
-     */
     public sendEvent(
         roomId: string,
         eventType: string,
@@ -3966,12 +4085,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {object} eventObject An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.
-     * @param {string} txnId Optional.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param eventObject - An object with the partial structure of an event, to which event_id, user_id, room_id and origin_server_ts will be added.
+     * @param txnId - Optional.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     private sendCompleteEvent(
         roomId: string,
@@ -4041,9 +4158,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * encrypts the event if necessary; adds the event to the queue, or sends it; marks the event as sent/unsent
-     * @param room
-     * @param event
-     * @returns {Promise} returns a promise which resolves with the result of the send request
+     * @returns returns a promise which resolves with the result of the send request
      */
     protected encryptAndSendEvent(room: Room | null, event: MatrixEvent): Promise<ISendEventResponse> {
         let cancelled = false;
@@ -4161,9 +4276,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Returns the eventType that should be used taking encryption into account
      * for a given eventType.
-     * @param {string} roomId the room for the events `eventType` relates to
-     * @param {string} eventType the event type
-     * @return {string} the event type taking encryption into account
+     * @param roomId - the room for the events `eventType` relates to
+     * @param eventType - the event type
+     * @returns the event type taking encryption into account
      */
     private getEncryptedIfNeededEventType(
         roomId: string,
@@ -4222,12 +4337,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} eventId
-     * @param {string} [txnId]  transaction id. One will be made up if not supplied.
-     * @param {IRedactOpts} opts Options to pass on, may contain `reason`.
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param txnId -  transaction id. One will be made up if not supplied.
+     * @param opts - Options to pass on, may contain `reason`.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public redactEvent(
         roomId: string,
@@ -4264,12 +4377,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {Object} content
-     * @param {string} txnId Optional.
-     * @return {Promise} Resolves: to an ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param txnId - Optional.
+     * @returns Promise which resolves: to an ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendMessage(
         roomId: string,
@@ -4343,12 +4453,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} body
-     * @param {string} txnId Optional.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param txnId - Optional.
+     * @returns
+     * @returns Rejects: with an error response.
      */
     public sendTextMessage(
         roomId: string,
@@ -4377,12 +4484,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} body
-     * @param {string} txnId Optional.
-     * @return {Promise} Resolves: to a ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param txnId - Optional.
+     * @returns Promise which resolves: to a ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendNotice(
         roomId: string,
@@ -4411,12 +4515,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} body
-     * @param {string} txnId Optional.
-     * @return {Promise} Resolves: to a ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param txnId - Optional.
+     * @returns Promise which resolves: to a ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendEmoteMessage(
         roomId: string,
@@ -4445,13 +4546,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} url
-     * @param {Object} info
-     * @param {string} text
-     * @return {Promise} Resolves: to a ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to a ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendImageMessage(
         roomId: string,
@@ -4489,13 +4585,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} url
-     * @param {Object} info
-     * @param {string} text
-     * @return {Promise} Resolves: to a ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to a ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendStickerMessage(
         roomId: string,
@@ -4533,12 +4624,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} body
-     * @param {string} htmlBody
-     * @return {Promise} Resolves: to a ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to a ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendHtmlMessage(
         roomId: string,
@@ -4567,11 +4654,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} body
-     * @param {string} htmlBody
-     * @return {Promise} Resolves: to a ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to a ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendHtmlNotice(
         roomId: string,
@@ -4600,12 +4684,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} threadId
-     * @param {string} body
-     * @param {string} htmlBody
-     * @return {Promise} Resolves: to a ISendEventResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to a ISendEventResponse object
+     * @returns Rejects: with an error response.
      */
     public sendHtmlEmote(
         roomId: string,
@@ -4635,13 +4715,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Send a receipt.
-     * @param {Event} event The event being acknowledged
-     * @param {ReceiptType} receiptType The kind of receipt e.g. "m.read". Other than
+     * @param event - The event being acknowledged
+     * @param receiptType - The kind of receipt e.g. "m.read". Other than
      * ReceiptType.Read are experimental!
-     * @param {object} body Additional content to send alongside the receipt.
-     * @param {boolean} unthreaded An unthreaded receipt will clear room+thread notifications
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param body - Additional content to send alongside the receipt.
+     * @param unthreaded - An unthreaded receipt will clear room+thread notifications
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public async sendReceipt(
         event: MatrixEvent,
@@ -4681,10 +4761,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Send a read receipt.
-     * @param {Event} event The event that has been read.
-     * @param {ReceiptType} receiptType other than ReceiptType.Read are experimental! Optional.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param event - The event that has been read.
+     * @param receiptType - other than ReceiptType.Read are experimental! Optional.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public async sendReadReceipt(
         event: MatrixEvent | null,
@@ -4706,14 +4786,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * event. This can be retrieved from room account data (the event type is `m.fully_read`)
      * and displayed as a horizontal line in the timeline that is visually distinct to the
      * position of the user's own read receipt.
-     * @param {string} roomId ID of the room that has been read
-     * @param {string} rmEventId ID of the event that has been read
-     * @param {MatrixEvent} rrEvent the event tracked by the read receipt. This is here for
+     * @param roomId - ID of the room that has been read
+     * @param rmEventId - ID of the event that has been read
+     * @param rrEvent - the event tracked by the read receipt. This is here for
      * convenience because the RR and the RM are commonly updated at the same time as each
      * other. The local echo of this receipt will be done if set. Optional.
-     * @param {MatrixEvent} rpEvent the m.read.private read receipt event for when we don't
+     * @param rpEvent - the m.read.private read receipt event for when we don't
      * want other users to see the read receipts. This is experimental. Optional.
-     * @return {Promise} Resolves: the empty object, {}.
+     * @returns Promise which resolves: the empty object, `{}`.
      */
     public async setRoomReadMarkers(
         roomId: string,
@@ -4754,13 +4834,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * described as an object with OpenGraph keys and associated values.
      * Attributes may be synthesized where actual OG metadata is lacking.
      * Caches results to prevent hammering the server.
-     * @param {string} url The URL to get preview data for
-     * @param {Number} ts The preferred point in time that the preview should
+     * @param url - The URL to get preview data for
+     * @param ts - The preferred point in time that the preview should
      * describe (ms since epoch).  The preview returned will either be the most
      * recent one preceding this timestamp if available, or failing that the next
      * most recent available preview.
-     * @return {Promise} Resolves: Object of OG metadata.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Object of OG metadata.
+     * @returns Rejects: with an error response.
      * May return synthesized attributes if the URL lacked OG meta.
      */
     public getUrlPreview(url: string, ts: number): Promise<IPreviewUrlResponse> {
@@ -4792,11 +4872,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {boolean} isTyping
-     * @param {Number} timeoutMs
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public sendTyping(roomId: string, isTyping: boolean, timeoutMs: number): Promise<{}> {
         if (this.isGuest()) {
@@ -4822,12 +4899,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * oldest and the last entry is the newest (likely current) room. If the
      * provided room is not found, this returns an empty list. This works in
      * both directions, looking for older and newer rooms of the given room.
-     * @param {string} roomId The room ID to search from
-     * @param {boolean} verifyLinks If true, the function will only return rooms
+     * @param roomId - The room ID to search from
+     * @param verifyLinks - If true, the function will only return rooms
      * which can be proven to be linked. For example, rooms which have a create
      * event pointing to an old room which the client is not aware of or doesn't
      * have a matching tombstone would not be returned.
-     * @return {Room[]} An array of rooms representing the upgrade
+     * @returns An array of rooms representing the upgrade
      * history.
      */
     public getRoomUpgradeHistory(roomId: string, verifyLinks = false): Room[] {
@@ -4895,11 +4972,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} userId
-     * @param {string} reason Optional.
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param reason - Optional.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public invite(roomId: string, userId: string, reason?: string): Promise<{}> {
         return this.membershipChange(roomId, userId, "invite", reason);
@@ -4907,10 +4982,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Invite a user to a room based on their email address.
-     * @param {string} roomId The room to invite the user to.
-     * @param {string} email The email address to invite.
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param roomId - The room to invite the user to.
+     * @param email - The email address to invite.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public inviteByEmail(roomId: string, email: string): Promise<{}> {
         return this.inviteByThreePid(roomId, "email", email);
@@ -4918,11 +4993,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Invite a user to a room based on a third-party identifier.
-     * @param {string} roomId The room to invite the user to.
-     * @param {string} medium The medium to invite the user e.g. "email".
-     * @param {string} address The address for the specified medium.
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param roomId - The room to invite the user to.
+     * @param medium - The medium to invite the user e.g. "email".
+     * @param address - The address for the specified medium.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public async inviteByThreePid(roomId: string, medium: string, address: string): Promise<{}> {
         const path = utils.encodeUri(
@@ -4957,9 +5032,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public leave(roomId: string): Promise<{}> {
         return this.membershipChange(roomId, undefined, "leave");
@@ -4970,10 +5044,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * default, this will leave all the previous and upgraded rooms, including the
      * given room. To only leave the given room and any previous rooms, keeping the
      * upgraded (modern) rooms untouched supply `false` to `includeFuture`.
-     * @param {string} roomId The room ID to start leaving at
-     * @param {boolean} includeFuture If true, the whole chain (past and future) of
+     * @param roomId - The room ID to start leaving at
+     * @param includeFuture - If true, the whole chain (past and future) of
      * upgraded rooms will be left.
-     * @return {Promise} Resolves when completed with an object keyed
+     * @returns Promise which resolves when completed with an object keyed
      * by room ID and value of the error encountered when leaving or null.
      */
     public leaveRoomChain(
@@ -5013,22 +5087,19 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} userId
-     * @param {string} reason Optional.
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param reason - Optional.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public ban(roomId: string, userId: string, reason?: string): Promise<{}> {
         return this.membershipChange(roomId, userId, "ban", reason);
     }
 
     /**
-     * @param {string} roomId
-     * @param {boolean} deleteRoom True to delete the room from the store on success.
+     * @param deleteRoom - True to delete the room from the store on success.
      * Default: true.
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public forget(roomId: string, deleteRoom = true): Promise<{}> {
         const promise = this.membershipChange(roomId, undefined, "forget");
@@ -5043,10 +5114,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} userId
-     * @return {Promise} Resolves: Object (currently empty)
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Object (currently empty)
+     * @returns Rejects: with an error response.
      */
     public unban(roomId: string, userId: string): Promise<{}> {
         // unbanning != set their state to leave: this used to be
@@ -5064,11 +5133,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} userId
-     * @param {string} reason Optional.
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param reason - Optional.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public kick(roomId: string, userId: string, reason?: string): Promise<{}> {
         const path = utils.encodeUri("/rooms/$roomId/kick", {
@@ -5102,10 +5169,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Obtain a dict of actions which should be performed for this event according
      * to the push rules for this user.  Caches the dict on the event.
-     * @param {MatrixEvent} event The event to get push actions for.
-     * @param {boolean} forceRecalculate forces to recalculate actions for an event
+     * @param event - The event to get push actions for.
+     * @param forceRecalculate - forces to recalculate actions for an event
      * Useful when an event just got decrypted
-     * @return {module:pushprocessor~PushAction} A dict of actions to perform.
+     * @returns A dict of actions to perform.
      */
     public getPushActionsForEvent(event: MatrixEvent, forceRecalculate = false): IActionsObject | null {
         if (!event.getPushActions() || forceRecalculate) {
@@ -5115,10 +5182,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} info The kind of info to set (e.g. 'avatar_url')
-     * @param {Object} data The JSON object to set.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param info - The kind of info to set (e.g. 'avatar_url')
+     * @param data - The JSON object to set.
+     * @returns
+     * @returns Rejects: with an error response.
      */
     // eslint-disable-next-line camelcase
     public setProfileInfo(info: "avatar_url", data: { avatar_url: string }): Promise<{}>;
@@ -5132,9 +5199,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} name
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public async setDisplayName(name: string): Promise<{}> {
         const prom = await this.setProfileInfo("displayname", { displayname: name });
@@ -5148,9 +5214,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} url
-     * @return {Promise} Resolves: {} an empty object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: `{}` an empty object.
+     * @returns Rejects: with an error response.
      */
     public async setAvatarUrl(url: string): Promise<{}> {
         const prom = await this.setProfileInfo("avatar_url", { avatar_url: url });
@@ -5166,15 +5231,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Turn an MXC URL into an HTTP one. <strong>This method is experimental and
      * may change.</strong>
-     * @param {string} mxcUrl The MXC URL
-     * @param {Number} width The desired width of the thumbnail.
-     * @param {Number} height The desired height of the thumbnail.
-     * @param {string} resizeMethod The thumbnail resize method to use, either
+     * @param mxcUrl - The MXC URL
+     * @param width - The desired width of the thumbnail.
+     * @param height - The desired height of the thumbnail.
+     * @param resizeMethod - The thumbnail resize method to use, either
      * "crop" or "scale".
-     * @param {Boolean} allowDirectLinks If true, return any non-mxc URLs
+     * @param allowDirectLinks - If true, return any non-mxc URLs
      * directly. Fetching such URLs will leak information about the user to
      * anyone they share a room with. If false, will return null for such URLs.
-     * @return {?string} the avatar URL or null.
+     * @returns the avatar URL or null.
      */
     public mxcUrlToHttp(
         mxcUrl: string,
@@ -5187,11 +5252,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {Object} opts Options to apply
-     * @param {string} opts.presence One of "online", "offline" or "unavailable"
-     * @param {string} opts.status_msg The status message to attach.
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param opts - Options to apply
+     * @returns Promise which resolves
+     * @returns Rejects: with an error response.
      * @throws If 'presence' isn't a valid presence enum value.
      */
     public async setPresence(opts: IPresenceOpts): Promise<void> {
@@ -5207,9 +5270,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} userId The user to get presence for
-     * @return {Promise} Resolves: The presence state for this user.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param userId - The user to get presence for
+     * @returns Promise which resolves: The presence state for this user.
+     * @returns Rejects: with an error response.
      */
     public getPresence(userId: string): Promise<IStatusResponse> {
         const path = utils.encodeUri("/presence/$userId/status", {
@@ -5227,13 +5290,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * will be a small delay before another request can be made (to prevent tight-looping
      * when there is no connection).
      *
-     * @param {Room} room The room to get older messages in.
-     * @param {number} limit Optional. The maximum number of previous events to
+     * @param room - The room to get older messages in.
+     * @param limit - Optional. The maximum number of previous events to
      * pull in. Default: 30.
-     * @return {Promise} Resolves: Room. If you are at the beginning
-     * of the timeline, <code>Room.oldState.paginationToken</code> will be
-     * <code>null</code>.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Room. If you are at the beginning
+     * of the timeline, `Room.oldState.paginationToken` will be
+     * `null`.
+     * @returns Rejects: with an error response.
      */
     public scrollback(room: Room, limit = 30): Promise<Room> {
         let timeToWaitMs = 0;
@@ -5302,13 +5365,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return promise;
     }
 
-    /**
-     * @param {object} [options]
-     * @param {boolean} options.preventReEmit don't re-emit events emitted on an event mapped by this mapper on the client
-     * @param {boolean} options.decrypt decrypt event proactively
-     * @param {boolean} options.toDevice the event is a to_device event
-     * @return {Function}
-     */
     public getEventMapper(options?: MapperOpts): EventMapper {
         return eventMapperFor(this, options || {});
     }
@@ -5321,11 +5377,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * made, and used to construct an EventTimeline.
      * If the event does not belong to this EventTimelineSet then undefined will be returned.
      *
-     * @param {EventTimelineSet} timelineSet  The timelineSet to look for the event in, must be bound to a room
-     * @param {string} eventId  The ID of the event to look for
+     * @param timelineSet -  The timelineSet to look for the event in, must be bound to a room
+     * @param eventId -  The ID of the event to look for
      *
-     * @return {Promise} Resolves:
-     *    {@link module:models/event-timeline~EventTimeline} including the given event
+     * @returns Promise which resolves:
+     *    {@link EventTimeline} including the given event
      */
     public async getEventTimeline(timelineSet: EventTimelineSet, eventId: string): Promise<Optional<EventTimeline>> {
         // don't allow any timeline support unless it's been enabled.
@@ -5563,10 +5619,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * call `/messages` to get the latest message in the room, then use
      * `client.getEventTimeline(...)` to construct a new timeline from it.
      *
-     * @param {EventTimelineSet} timelineSet  The timelineSet to find or add the timeline to
+     * @param timelineSet -  The timelineSet to find or add the timeline to
      *
-     * @return {Promise} Resolves:
-     *    {@link module:models/event-timeline~EventTimeline} timeline with the latest events in the room
+     * @returns Promise which resolves:
+     *    {@link EventTimeline} timeline with the latest events in the room
      */
     public async getLatestTimeline(timelineSet: EventTimelineSet): Promise<Optional<EventTimeline>> {
         // don't allow any timeline support unless it's been enabled.
@@ -5628,12 +5684,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * XXX: if we do get rid of scrollback (as it's not used at the moment),
      * we could inline this method again in paginateEventTimeline as that would
      * then be the only call-site
-     * @param {string} roomId
-     * @param {string} fromToken
-     * @param {number} limit the maximum amount of events the retrieve
-     * @param {string} dir 'f' or 'b'
-     * @param {Filter} timelineFilter the timeline filter to pass
-     * @return {Promise}
+     * @param limit - the maximum amount of events the retrieve
+     * @param dir - 'f' or 'b'
+     * @param timelineFilter - the timeline filter to pass
      */
     // XXX: Intended private, used in code.
     public createMessagesRequest(
@@ -5677,12 +5730,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * XXX: if we do get rid of scrollback (as it's not used at the moment),
      * we could inline this method again in paginateEventTimeline as that would
      * then be the only call-site
-     * @param {string} roomId
-     * @param {string} fromToken
-     * @param {number} limit the maximum amount of events the retrieve
-     * @param {string} dir 'f' or 'b'
-     * @param {Filter} timelineFilter the timeline filter to pass
-     * @return {Promise}
+     * @param limit - the maximum amount of events the retrieve
+     * @param dir - 'f' or 'b'
+     * @param timelineFilter - the timeline filter to pass
      */
     // XXX: Intended private, used by room.fetchRoomThreads
     public createThreadListMessagesRequest(
@@ -5743,14 +5793,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Take an EventTimeline, and back/forward-fill results.
      *
-     * @param {module:models/event-timeline~EventTimeline} eventTimeline timeline
-     *    object to be updated
-     * @param {Object}   [opts]
-     * @param {boolean}     [opts.backwards = false]  true to fill backwards,
-     *    false to go forwards
-     * @param {number}   [opts.limit = 30]         number of events to request
+     * @param eventTimeline - timeline object to be updated
      *
-     * @return {Promise} Resolves to a boolean: false if there are no
+     * @returns Promise which resolves to a boolean: false if there are no
      *    events and we reached either end of the timeline; else true.
      */
     public paginateEventTimeline(eventTimeline: EventTimeline, opts: IPaginateOpts): Promise<boolean> {
@@ -5997,9 +6042,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Peek into a room and receive updates about the room. This only works if the
      * history visibility for the room is world_readable.
-     * @param {String} roomId The room to attempt to peek into.
-     * @return {Promise} Resolves: Room object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param roomId - The room to attempt to peek into.
+     * @returns Promise which resolves: Room object
+     * @returns Rejects: with an error response.
      */
     public peekInRoom(roomId: string): Promise<Room> {
         this.peekSync?.stopPeeking();
@@ -6019,16 +6064,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Set r/w flags for guest access in a room.
-     * @param {string} roomId The room to configure guest access in.
-     * @param {Object} opts Options
-     * @param {boolean} opts.allowJoin True to allow guests to join this room. This
-     * implicitly gives guests write access. If false or not given, guests are
-     * explicitly forbidden from joining the room.
-     * @param {boolean} opts.allowRead True to set history visibility to
-     * be world_readable. This gives guests read access *from this point forward*.
-     * If false or not given, history visibility is not modified.
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param roomId - The room to configure guest access in.
+     * @param opts - Options
+     * @returns Promise which resolves
+     * @returns Rejects: with an error response.
      */
     public setGuestAccess(roomId: string, opts: IGuestAccessOpts): Promise<void> {
         const writePromise = this.sendStateEvent(roomId, EventType.RoomGuestAccess, {
@@ -6053,11 +6092,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * Parameters and return value are as for requestEmailToken
 
-     * @param {string} email As requestEmailToken
-     * @param {string} clientSecret As requestEmailToken
-     * @param {number} sendAttempt As requestEmailToken
-     * @param {string} nextLink As requestEmailToken
-     * @return {Promise} Resolves: As requestEmailToken
+     * @param email - As requestEmailToken
+     * @param clientSecret - As requestEmailToken
+     * @param sendAttempt - As requestEmailToken
+     * @param nextLink - As requestEmailToken
+     * @returns Promise which resolves: As requestEmailToken
      */
     public requestRegisterEmailToken(
         email: string,
@@ -6082,13 +6121,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * The doesServerRequireIdServerParam() method can be used to determine if
      * the server requires the id_server parameter to be provided.
      *
-     * @param {string} phoneCountry The ISO 3166-1 alpha-2 code for the country in which
+     * @param phoneCountry - The ISO 3166-1 alpha-2 code for the country in which
      *    phoneNumber should be parsed relative to.
-     * @param {string} phoneNumber The phone number, in national or international format
-     * @param {string} clientSecret As requestEmailToken
-     * @param {number} sendAttempt As requestEmailToken
-     * @param {string} nextLink As requestEmailToken
-     * @return {Promise} Resolves: As requestEmailToken
+     * @param phoneNumber - The phone number, in national or international format
+     * @param clientSecret - As requestEmailToken
+     * @param sendAttempt - As requestEmailToken
+     * @param nextLink - As requestEmailToken
+     * @returns Promise which resolves: As requestEmailToken
      */
     public requestRegisterMsisdnToken(
         phoneCountry: string,
@@ -6120,11 +6159,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * it will either send an email to the address informing them of this
      * or return M_THREEPID_IN_USE (which one is up to the homeserver).
      *
-     * @param {string} email As requestEmailToken
-     * @param {string} clientSecret As requestEmailToken
-     * @param {number} sendAttempt As requestEmailToken
-     * @param {string} nextLink As requestEmailToken
-     * @return {Promise} Resolves: As requestEmailToken
+     * @param email - As requestEmailToken
+     * @param clientSecret - As requestEmailToken
+     * @param sendAttempt - As requestEmailToken
+     * @param nextLink - As requestEmailToken
+     * @returns Promise which resolves: As requestEmailToken
      */
     public requestAdd3pidEmailToken(
         email: string,
@@ -6150,12 +6189,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * adding specific behaviour for the addition of phone numbers to an
      * account, as requestAdd3pidEmailToken.
      *
-     * @param {string} phoneCountry As requestRegisterMsisdnToken
-     * @param {string} phoneNumber As requestRegisterMsisdnToken
-     * @param {string} clientSecret As requestEmailToken
-     * @param {number} sendAttempt As requestEmailToken
-     * @param {string} nextLink As requestEmailToken
-     * @return {Promise} Resolves: As requestEmailToken
+     * @param phoneCountry - As requestRegisterMsisdnToken
+     * @param phoneNumber - As requestRegisterMsisdnToken
+     * @param clientSecret - As requestEmailToken
+     * @param sendAttempt - As requestEmailToken
+     * @param nextLink - As requestEmailToken
+     * @returns Promise which resolves: As requestEmailToken
      */
     public requestAdd3pidMsisdnToken(
         phoneCountry: string,
@@ -6188,11 +6227,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * requestEmailToken calls the equivalent API directly on the identity server,
      * therefore bypassing the password reset specific logic.
      *
-     * @param {string} email As requestEmailToken
-     * @param {string} clientSecret As requestEmailToken
-     * @param {number} sendAttempt As requestEmailToken
-     * @param {string} nextLink As requestEmailToken
-     * @return {Promise} Resolves: As requestEmailToken
+     * @param email - As requestEmailToken
+     * @param clientSecret - As requestEmailToken
+     * @param sendAttempt - As requestEmailToken
+     * @param nextLink - As requestEmailToken
+     * @returns Promise which resolves: As requestEmailToken
      */
     public requestPasswordEmailToken(
         email: string,
@@ -6217,12 +6256,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * This API proxies the identity server /validate/email/requestToken API,
      * adding specific behaviour for the password resetting, as requestPasswordEmailToken.
      *
-     * @param {string} phoneCountry As requestRegisterMsisdnToken
-     * @param {string} phoneNumber As requestRegisterMsisdnToken
-     * @param {string} clientSecret As requestEmailToken
-     * @param {number} sendAttempt As requestEmailToken
-     * @param {string} nextLink As requestEmailToken
-     * @return {Promise} Resolves: As requestEmailToken
+     * @param phoneCountry - As requestRegisterMsisdnToken
+     * @param phoneNumber - As requestRegisterMsisdnToken
+     * @param clientSecret - As requestEmailToken
+     * @param sendAttempt - As requestEmailToken
+     * @param nextLink - As requestEmailToken
+     * @returns Promise which resolves: As requestEmailToken
      */
     public requestPasswordMsisdnToken(
         phoneCountry: string,
@@ -6247,9 +6286,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Internal utility function for requesting validation tokens from usage-specific
      * requestToken endpoints.
      *
-     * @param {string} endpoint The endpoint to send the request to
-     * @param {object} params Parameters for the POST request
-     * @return {Promise} Resolves: As requestEmailToken
+     * @param endpoint - The endpoint to send the request to
+     * @param params - Parameters for the POST request
+     * @returns Promise which resolves: As requestEmailToken
      */
     private async requestTokenFromEndpoint<T extends IRequestTokenResponse>(
         endpoint: string,
@@ -6276,9 +6315,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the room-kind push rule associated with a room.
-     * @param {string} scope "global" or device-specific.
-     * @param {string} roomId the id of the room.
-     * @return {object} the rule or undefined.
+     * @param scope - "global" or device-specific.
+     * @param roomId - the id of the room.
+     * @returns the rule or undefined.
      */
     public getRoomPushRule(scope: "global" | "device", roomId: string): IPushRule | undefined {
         // There can be only room-kind push rule per room
@@ -6295,11 +6334,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Set a room-kind muting push rule in a room.
      * The operation also updates MatrixClient.pushRules at the end.
-     * @param {string} scope "global" or device-specific.
-     * @param {string} roomId the id of the room.
-     * @param {boolean} mute the mute state.
-     * @return {Promise} Resolves: result object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param scope - "global" or device-specific.
+     * @param roomId - the id of the room.
+     * @param mute - the mute state.
+     * @returns Promise which resolves: result object
+     * @returns Rejects: with an error response.
      */
     public setRoomMutePushRule(scope: "global" | "device", roomId: string, mute: boolean): Promise<void> | undefined {
         let promise: Promise<unknown> | undefined;
@@ -6388,20 +6427,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * The returned promise resolves to an object containing the fields:
      *
-     *  * {number}  count:       estimate of the number of results
-     *  * {string}  next_batch:  token for back-pagination; if undefined, there are
-     *                           no more results
-     *  * {Array}   highlights:  a list of words to highlight from the stemming
-     *                           algorithm
-     *  * {Array}   results:     a list of results
+     *  * count:       estimate of the number of results
+     *  * next_batch:  token for back-pagination; if undefined, there are no more results
+     *  * highlights:  a list of words to highlight from the stemming algorithm
+     *  * results:     a list of results
      *
-     * Each entry in the results list is a {module:models/search-result.SearchResult}.
+     * Each entry in the results list is a SearchResult.
      *
-     * @param {Object} opts
-     * @param {string} opts.term     the term to search for
-     * @param {Object} opts.filter   a JSON filter object to pass in the request
-     * @return {Promise} Resolves: result object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: result object
+     * @returns Rejects: with an error response.
      */
     public searchRoomEvents(opts: IEventSearchOpts): Promise<ISearchResults> {
         // TODO: support search groups
@@ -6433,9 +6467,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Take a result from an earlier searchRoomEvents call, and backfill results.
      *
-     * @param  {object} searchResults  the results object to be updated
-     * @return {Promise} Resolves: updated result object
-     * @return {Error} Rejects: with an error response.
+     * @param searchResults -  the results object to be updated
+     * @returns Promise which resolves: updated result object
+     * @returns Rejects: with an error response.
      */
     public backPaginateRoomEventsSearch<T extends ISearchResults>(searchResults: T): Promise<T> {
         // TODO: we should implement a backoff (as per scrollback()) to deal more
@@ -6469,10 +6503,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * helper for searchRoomEvents and backPaginateRoomEventsSearch. Processes the
      * response from the API call and updates the searchResults
      *
-     * @param {Object} searchResults
-     * @param {Object} response
-     * @return {Object} searchResults
-     * @private
+     * @returns searchResults
+     * @internal
      */
     // XXX: Intended private, used in code
     public processRoomEventsSearch<T extends ISearchResults>(searchResults: T, response: ISearchResponse): T {
@@ -6511,9 +6543,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Populate the store with rooms the user has left.
-     * @return {Promise} Resolves: TODO - Resolved when the rooms have
+     * @returns Promise which resolves: TODO - Resolved when the rooms have
      * been added to the data store.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Rejects: with an error response.
      */
     public syncLeftRooms(): Promise<Room[]> {
         // Guard against multiple calls whilst ongoing and multiple calls post success
@@ -6539,9 +6571,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Create a new filter.
-     * @param {Object} content The HTTP body for the request
-     * @return {Filter} Resolves to a Filter object.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param content - The HTTP body for the request
+     * @returns Promise which resolves to a Filter object.
+     * @returns Rejects: with an error response.
      */
     public createFilter(content: IFilterDefinition): Promise<Filter> {
         const path = utils.encodeUri("/user/$userId/filter", {
@@ -6558,12 +6590,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Retrieve a filter.
-     * @param {string} userId The user ID of the filter owner
-     * @param {string} filterId The filter ID to retrieve
-     * @param {boolean} allowCached True to allow cached filters to be returned.
+     * @param userId - The user ID of the filter owner
+     * @param filterId - The filter ID to retrieve
+     * @param allowCached - True to allow cached filters to be returned.
      * Default: True.
-     * @return {Promise} Resolves: a Filter object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: a Filter object
+     * @returns Rejects: with an error response.
      */
     public getFilter(userId: string, filterId: string, allowCached: boolean): Promise<Filter> {
         if (allowCached) {
@@ -6587,9 +6619,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} filterName
-     * @param {Filter} filter
-     * @return {Promise<String>} Filter ID
+     * @returns Filter ID
      */
     public async getOrCreateFilter(filterName: string, filter: Filter): Promise<string> {
         const filterId = this.store.getFilterIdByName(filterName);
@@ -6642,8 +6672,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Gets a bearer token from the homeserver that the user can
      * present to a third party in order to prove their ownership
      * of the Matrix account they are logged into.
-     * @return {Promise} Resolves: Token object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Token object
+     * @returns Rejects: with an error response.
      */
     public getOpenIdToken(): Promise<IOpenIDToken> {
         const path = utils.encodeUri("/user/$userId/openid/request_token", {
@@ -6662,8 +6692,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     };
 
     /**
-     * @return {Promise} Resolves: ITurnServerResponse object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: ITurnServerResponse object
+     * @returns Rejects: with an error response.
      */
     public turnServer(): Promise<ITurnServerResponse> {
         return this.http.authedRequest(Method.Get, "/voip/turnServer");
@@ -6671,7 +6701,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the TURN servers for this homeserver.
-     * @return {Array<Object>} The servers or an empty list.
+     * @returns The servers or an empty list.
      */
     public getTurnServers(): ITurnServer[] {
         return this.turnServers || [];
@@ -6680,7 +6710,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the unix timestamp (in milliseconds) at which the current
      * TURN credentials (from getTurnServers) expire
-     * @return {number} The expiry timestamp in milliseconds
+     * @returns The expiry timestamp in milliseconds
      */
     public getTurnServersExpiry(): number {
         return this.turnServersExpiry;
@@ -6742,7 +6772,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * WebRTC connection if the homeserver doesn't provide any servers. Defaults to
      * false.
      *
-     * @param {boolean} allow
      */
     public setFallbackICEServerAllowed(allow: boolean): void {
         this.fallbackICEServerAllowed = allow;
@@ -6753,7 +6782,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * WebRTC connection if the homeserver doesn't provide any servers. Defaults to
      * false.
      *
-     * @returns {boolean}
+     * @returns
      */
     public isFallbackICEServerAllowed(): boolean {
         return this.fallbackICEServerAllowed;
@@ -6764,7 +6793,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Returns false if untrue or the homeserver does not appear to be a Synapse
      * homeserver. <strong>This function is implementation specific and may change
      * as a result.</strong>
-     * @return {boolean} true if the user appears to be a Synapse administrator.
+     * @returns true if the user appears to be a Synapse administrator.
      */
     public isSynapseAdministrator(): Promise<boolean> {
         const path = utils.encodeUri(
@@ -6780,8 +6809,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Performs a whois lookup on a user using Synapse's administrator API.
      * <strong>This function is implementation specific and may change as a
      * result.</strong>
-     * @param {string} userId the User ID to look up.
-     * @return {object} the whois response - see Synapse docs for information.
+     * @param userId - the User ID to look up.
+     * @returns the whois response - see Synapse docs for information.
      */
     public whoisSynapseUser(userId: string): Promise<ISynapseAdminWhoisResponse> {
         const path = utils.encodeUri(
@@ -6794,8 +6823,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Deactivates a user using Synapse's administrator API. <strong>This
      * function is implementation specific and may change as a result.</strong>
-     * @param {string} userId the User ID to deactivate.
-     * @return {object} the deactivate response - see Synapse docs for information.
+     * @param userId - the User ID to deactivate.
+     * @returns the deactivate response - see Synapse docs for information.
      */
     public deactivateSynapseUser(userId: string): Promise<ISynapseAdminDeactivateResponse> {
         const path = utils.encodeUri(
@@ -6828,8 +6857,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * store client options with boolean/string/numeric values
      * to know in the next session what flags the sync data was
      * created with (e.g. lazy loading)
-     * @param {object} opts the complete set of client options
-     * @return {Promise} for store operation
+     * @param opts - the complete set of client options
+     * @returns for store operation
      */
     public storeClientOptions(): Promise<void> { // XXX: Intended private, used in code
         const primTypes = ["boolean", "string", "number"];
@@ -6846,9 +6875,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Gets a set of room IDs in common with another user
-     * @param {string} userId The userId to check.
-     * @return {Promise<string[]>} Resolves to a set of rooms
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param userId - The userId to check.
+     * @returns Promise which resolves to a set of rooms
+     * @returns Rejects: with an error response.
      */
     public async _unstable_getSharedRooms(userId: string): Promise<string[]> { // eslint-disable-line
         const sharedRoomsSupport = await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666");
@@ -6873,7 +6902,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the API versions supported by the server, along with any
      * unstable APIs it supports
-     * @return {Promise<object>} The server /versions response
+     * @returns The server /versions response
      */
     public async getVersions(): Promise<IServerVersions> {
         if (this.serverVersionsPromise) {
@@ -6906,8 +6935,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Check if a particular spec version is supported by the server.
-     * @param {string} version The spec version (such as "r0.5.0") to check for.
-     * @return {Promise<boolean>} Whether it is supported
+     * @param version - The spec version (such as "r0.5.0") to check for.
+     * @returns Whether it is supported
      */
     public async isVersionSupported(version: string): Promise<boolean> {
         const { versions } = await this.getVersions();
@@ -6916,7 +6945,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Query the server to see if it supports members lazy loading
-     * @return {Promise<boolean>} true if server supports lazy loading
+     * @returns true if server supports lazy loading
      */
     public async doesServerSupportLazyLoading(): Promise<boolean> {
         const response = await this.getVersions();
@@ -6932,7 +6961,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Query the server to see if the `id_server` parameter is required
      * when registering with an 3pid, adding a 3pid or resetting password.
-     * @return {Promise<boolean>} true if id_server parameter is required
+     * @returns true if id_server parameter is required
      */
     public async doesServerRequireIdServerParam(): Promise<boolean> {
         const response = await this.getVersions();
@@ -6958,7 +6987,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Query the server to see if the `id_access_token` parameter can be safely
      * passed to the homeserver. Some homeservers may trigger errors if they are not
      * prepared for the new parameter.
-     * @return {Promise<boolean>} true if id_access_token can be sent
+     * @returns true if id_access_token can be sent
      */
     public async doesServerAcceptIdentityAccessToken(): Promise<boolean> {
         const response = await this.getVersions();
@@ -6974,7 +7003,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Query the server to see if it supports separate 3PID add and bind functions.
      * This affects the sequence of API calls clients should use for these operations,
      * so it's helpful to be able to check for support.
-     * @return {Promise<boolean>} true if separate functions are supported
+     * @returns true if separate functions are supported
      */
     public async doesServerSupportSeparateAddAndBind(): Promise<boolean> {
         const response = await this.getVersions();
@@ -6989,8 +7018,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Query the server to see if it lists support for an unstable feature
      * in the /versions response
-     * @param {string} feature the feature name
-     * @return {Promise<boolean>} true if the feature is supported
+     * @param feature - the feature name
+     * @returns true if the feature is supported
      */
     public async doesServerSupportUnstableFeature(feature: string): Promise<boolean> {
         const response = await this.getVersions();
@@ -7002,8 +7031,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Query the server to see if it is forcing encryption to be enabled for
      * a given room preset, based on the /versions response.
-     * @param {Preset} presetName The name of the preset to check.
-     * @returns {Promise<boolean>} true if the server is forcing encryption
+     * @param presetName - The name of the preset to check.
+     * @returns true if the server is forcing encryption
      * for the preset.
      */
     public async doesServerForceEncryptionForPreset(presetName: Preset): Promise<boolean> {
@@ -7062,7 +7091,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Query the server to see if it supports the MSC2457 `logout_devices` parameter when setting password
-     * @return {Promise<boolean>} true if server supports the `logout_devices` parameter
+     * @returns true if server supports the `logout_devices` parameter
      */
     public doesServerSupportLogoutDevices(): Promise<boolean> {
         return this.isVersionSupported("r0.6.1");
@@ -7070,7 +7099,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get if lazy loading members is being used.
-     * @return {boolean} Whether or not members are lazy loaded by this client
+     * @returns Whether or not members are lazy loaded by this client
      */
     public hasLazyLoadMembersEnabled(): boolean {
         return !!this.clientOpts?.lazyLoadMembers;
@@ -7083,7 +7112,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * are other references to the timelines for this room, e.g because the client is
      * actively viewing events in this room.
      * Default: returns false.
-     * @param {Function} cb The callback which will be invoked.
+     * @param cb - The callback which will be invoked.
      */
     public setCanResetTimelineCallback(cb: ResetTimelineCallback): void {
         this.canResetTimelineCallback = cb;
@@ -7091,7 +7120,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the callback set via `setCanResetTimelineCallback`.
-     * @return {?Function} The callback or null
+     * @returns The callback or null
      */
     public getCanResetTimelineCallback(): ResetTimelineCallback | undefined {
         return this.canResetTimelineCallback;
@@ -7101,12 +7130,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Returns relations for a given event. Handles encryption transparently,
      * with the caveat that the amount of events returned might be 0, even though you get a nextBatch.
      * When the returned promise resolves, all messages should have finished trying to decrypt.
-     * @param {string} roomId the room of the event
-     * @param {string} eventId the id of the event
-     * @param {string} relationType the rel_type of the relations requested
-     * @param {string} eventType the event type of the relations requested
-     * @param {Object} opts options with optional values for the request.
-     * @return {Object} an object with `events` as `MatrixEvent[]` and optionally `nextBatch` if more relations are available.
+     * @param roomId - the room of the event
+     * @param eventId - the id of the event
+     * @param relationType - the rel_type of the relations requested
+     * @param eventType - the event type of the relations requested
+     * @param opts - options with optional values for the request.
+     * @returns an object with `events` as `MatrixEvent[]` and optionally `nextBatch` if more relations are available.
      */
     public async relations(
         roomId: string,
@@ -7152,7 +7181,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * The app may wish to see if we have a key cached without
      * triggering a user interaction.
-     * @return {object}
      */
     public getCrossSigningCacheCallbacks(): ICacheCallbacks | undefined {
         // XXX: Private member access
@@ -7162,7 +7190,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Generates a random string suitable for use as a client secret. <strong>This
      * method is experimental and may change.</strong>
-     * @return {string} A new client secret
+     * @returns A new client secret
      */
     public generateClientSecret(): string {
         return randomString(32);
@@ -7170,11 +7198,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Attempts to decrypt an event
-     * @param {MatrixEvent} event The event to decrypt
-     * @returns {Promise<void>} A decryption promise
-     * @param {object} options
-     * @param {boolean} options.isRetry True if this is a retry (enables more logging)
-     * @param {boolean} options.emit Emits "event.decrypted" if set to true
+     * @param event - The event to decrypt
+     * @returns A decryption promise
      */
     public decryptEventIfNeeded(event: MatrixEvent, options?: IDecryptOptions): Promise<void> {
         if (event.shouldAttemptDecryption() && this.isCryptoEnabled()) {
@@ -7201,7 +7226,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the Homeserver URL of this client
-     * @return {string} Homeserver URL of this client
+     * @returns Homeserver URL of this client
      */
     public getHomeserverUrl(): string {
         return this.baseUrl;
@@ -7209,8 +7234,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the identity server URL of this client
-     * @param {boolean} stripProto whether or not to strip the protocol from the URL
-     * @return {string} Identity server URL of this client
+     * @param stripProto - whether or not to strip the protocol from the URL
+     * @returns Identity server URL of this client
      */
     public getIdentityServerUrl(stripProto = false): string | undefined {
         if (stripProto && (this.idBaseUrl?.startsWith("http://") || this.idBaseUrl?.startsWith("https://"))) {
@@ -7221,7 +7246,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Set the identity server URL of this client
-     * @param {string} url New identity server URL
+     * @param url - New identity server URL
      */
     public setIdentityServerUrl(url: string): void {
         this.idBaseUrl = utils.ensureNoTrailingSlash(url);
@@ -7230,7 +7255,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the access token associated with this account.
-     * @return {?String} The access_token or null
+     * @returns The access_token or null
      */
     public getAccessToken(): string | null {
         return this.http.opts.accessToken || null;
@@ -7238,14 +7263,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Set the access token associated with this account.
-     * @param {string} token The new access token.
+     * @param token - The new access token.
      */
     public setAccessToken(token: string): void {
         this.http.opts.accessToken = token;
     }
 
     /**
-     * @return {boolean} true if there is a valid access_token for this client.
+     * @returns true if there is a valid access_token for this client.
      */
     public isLoggedIn(): boolean {
         return this.http.opts.accessToken !== undefined;
@@ -7254,7 +7279,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Make up a new transaction id
      *
-     * @return {string} a new, unique, transaction id
+     * @returns a new, unique, transaction id
      */
     public makeTxnId(): string {
         return "m" + new Date().getTime() + "." + (this.txnCtr++);
@@ -7263,8 +7288,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Check whether a username is available prior to registration. An error response
      * indicates an invalid/unavailable username.
-     * @param {string} username The username to check the availability of.
-     * @return {Promise} Resolves: to boolean of whether the username is available.
+     * @param username - The username to check the availability of.
+     * @returns Promise which resolves: to boolean of whether the username is available.
      */
     public isUsernameAvailable(username: string): Promise<boolean> {
         return this.http.authedRequest<{ available: true }>(
@@ -7280,17 +7305,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} username
-     * @param {string} password
-     * @param {string} sessionId
-     * @param {Object} auth
-     * @param {Object} bindThreepids Set key 'email' to true to bind any email
+     * @param bindThreepids - Set key 'email' to true to bind any email
      *     threepid uses during registration in the identity server. Set 'msisdn' to
      *     true to bind msisdn.
-     * @param {string} guestAccessToken
-     * @param {string} inhibitLogin
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public register(
         username: string,
@@ -7362,23 +7381,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * client.setGuest(true);
      * ```
      *
-     * @param {Object=} opts Registration options
-     * @param {Object} opts.body JSON HTTP body to provide.
-     * @return {Promise} Resolves: JSON object that contains:
-     *                   { user_id, device_id, access_token, home_server }
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param body - JSON HTTP body to provide.
+     * @returns Promise which resolves: JSON object that contains:
+     *                   `{ user_id, device_id, access_token, home_server }`
+     * @returns Rejects: with an error response.
      */
-    public registerGuest(opts: { body?: any }): Promise<any> { // TODO: Types
-        opts = opts || {};
-        opts.body = opts.body || {};
-        return this.registerRequest(opts.body, "guest");
+    public registerGuest({ body }: { body?: any } = {}): Promise<any> { // TODO: Types
+        return this.registerRequest(body || {}, "guest");
     }
 
     /**
-     * @param {Object} data   parameters for registration request
-     * @param {string=} kind  type of user to register. may be "guest"
-     * @return {Promise} Resolves: to the /register response
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param data - parameters for registration request
+     * @param kind - type of user to register. may be "guest"
+     * @returns Promise which resolves: to the /register response
+     * @returns Rejects: with an error response.
      */
     public registerRequest(data: IRegisterRequestParams, kind?: string): Promise<IAuthData> {
         const params: { kind?: string } = {};
@@ -7396,9 +7412,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Note that this function will not cause a logout if the token is deemed
      * unknown by the server - the caller is responsible for managing logout
      * actions on error.
-     * @param {string} refreshToken The refresh token.
-     * @return {Promise<IRefreshTokenResponse>} Resolves to the new token.
-     * @return {module:http-api.MatrixError} Rejects with an error response.
+     * @param refreshToken - The refresh token.
+     * @returns Promise which resolves to the new token.
+     * @returns Rejects with an error response.
      */
     public refreshToken(refreshToken: string): Promise<IRefreshTokenResponse> {
         return this.http.authedRequest(
@@ -7414,18 +7430,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @return {Promise<ILoginFlowsResponse>} Resolves to the available login flows
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves to the available login flows
+     * @returns Rejects: with an error response.
      */
     public loginFlows(): Promise<ILoginFlowsResponse> {
         return this.http.request(Method.Get, "/login");
     }
 
     /**
-     * @param {string} loginType
-     * @param {Object} data
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public login(loginType: string, data: any): Promise<any> { // TODO: Types
         const loginData = {
@@ -7450,10 +7464,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} user
-     * @param {string} password
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public loginWithPassword(user: string, password: string): Promise<any> { // TODO: Types
         return this.login("m.login.password", {
@@ -7463,9 +7475,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} relayState URL Callback after SAML2 Authentication
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param relayState - URL Callback after SAML2 Authentication
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public loginWithSAML2(relayState: string): Promise<any> { // TODO: Types
         return this.login("m.login.saml2", {
@@ -7474,22 +7486,22 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} redirectUrl The URL to redirect to after the HS
+     * @param redirectUrl - The URL to redirect to after the HS
      * authenticates with CAS.
-     * @return {string} The HS URL to hit to begin the CAS login process.
+     * @returns The HS URL to hit to begin the CAS login process.
      */
     public getCasLoginUrl(redirectUrl: string): string {
         return this.getSsoLoginUrl(redirectUrl, "cas");
     }
 
     /**
-     * @param {string} redirectUrl The URL to redirect to after the HS
+     * @param redirectUrl - The URL to redirect to after the HS
      *     authenticates with the SSO.
-     * @param {string} loginType The type of SSO login we are doing (sso or cas).
+     * @param loginType - The type of SSO login we are doing (sso or cas).
      *     Defaults to 'sso'.
-     * @param {string} idpId The ID of the Identity Provider being targeted, optional.
-     * @param {SSOAction} action the SSO flow to indicate to the IdP, optional.
-     * @return {string} The HS URL to hit to begin the SSO login process.
+     * @param idpId - The ID of the Identity Provider being targeted, optional.
+     * @param action - the SSO flow to indicate to the IdP, optional.
+     * @returns The HS URL to hit to begin the SSO login process.
      */
     public getSsoLoginUrl(
         redirectUrl: string,
@@ -7511,9 +7523,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} token Login token previously received from homeserver
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param token - Login token previously received from homeserver
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public loginWithToken(token: string): Promise<any> { // TODO: Types
         return this.login("m.login.token", {
@@ -7527,8 +7539,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * method is called. The state of the MatrixClient object is not affected:
      * it is up to the caller to either reset or destroy the MatrixClient after
      * this method succeeds.
-     * @param {boolean} stopClient whether to stop the client before calling /logout to prevent invalid token errors.
-     * @return {Promise} Resolves: On success, the empty object {}
+     * @param stopClient - whether to stop the client before calling /logout to prevent invalid token errors.
+     * @returns Promise which resolves: On success, the empty object `{}`
      */
     public async logout(stopClient = false): Promise<{}> {
         if (this.crypto?.backupManager?.getKeyBackupEnabled()) {
@@ -7556,11 +7568,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * method is called. The state of the MatrixClient object is not affected:
      * it is up to the caller to either reset or destroy the MatrixClient after
      * this method succeeds.
-     * @param {object} auth Optional. Auth data to supply for User-Interactive auth.
-     * @param {boolean} erase Optional. If set, send as `erase` attribute in the
+     * @param auth - Optional. Auth data to supply for User-Interactive auth.
+     * @param erase - Optional. If set, send as `erase` attribute in the
      * JSON request body, indicating whether the account should be erased. Defaults
      * to false.
-     * @return {Promise} Resolves: On success, the empty object
+     * @returns Promise which resolves: On success, the empty object
      */
     public deactivateAccount(auth?: any, erase?: boolean): Promise<{}> {
         const body: any = {};
@@ -7579,8 +7591,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * [MSC3882](https://github.com/matrix-org/matrix-spec-proposals/pull/3882).
      * The server may require User-Interactive auth.
      * Note that this is UNSTABLE and subject to breaking changes without notice.
-     * @param {IAuthData} auth Optional. Auth data to supply for User-Interactive auth.
-     * @return {Promise<UIAResponse<LoginTokenPostResponse>>} Resolves: On success, the token response
+     * @param auth - Optional. Auth data to supply for User-Interactive auth.
+     * @returns Promise which resolves: On success, the token response
      * or UIA auth data.
      */
     public requestLoginToken(auth?: IAuthData): Promise<UIAResponse<LoginTokenPostResponse>> {
@@ -7597,10 +7609,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the fallback URL to use for unknown interactive-auth stages.
      *
-     * @param {string} loginType     the type of stage being attempted
-     * @param {string} authSessionId the auth session ID provided by the homeserver
+     * @param loginType -     the type of stage being attempted
+     * @param authSessionId - the auth session ID provided by the homeserver
      *
-     * @return {string} HS URL to hit to for the fallback interface
+     * @returns HS URL to hit to for the fallback interface
      */
     public getFallbackAuthUrl(loginType: string, authSessionId: string): string {
         const path = utils.encodeUri("/auth/$loginType/fallback/web", {
@@ -7614,15 +7626,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Create a new room.
-     * @param {Object} options a list of options to pass to the /createRoom API.
-     * @param {string} options.room_alias_name The alias localpart to assign to
-     * this room.
-     * @param {string} options.visibility Either 'public' or 'private'.
-     * @param {string[]} options.invite A list of user IDs to invite to this room.
-     * @param {string} options.name The name to give this room.
-     * @param {string} options.topic The topic to give this room.
-     * @return {Promise} Resolves: <code>{room_id: {string}}</code>
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param options - a list of options to pass to the /createRoom API.
+     * @returns Promise which resolves: `{room_id: {string}}`
+     * @returns Rejects: with an error response.
      */
     public async createRoom(options: ICreateRoomOpts): Promise<{ room_id: string }> { // eslint-disable-line camelcase
         // some valid options include: room_alias_name, visibility, invite
@@ -7648,12 +7654,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Fetches relations for a given event
-     * @param {string} roomId the room of the event
-     * @param {string} eventId the id of the event
-     * @param {string} [relationType] the rel_type of the relations requested
-     * @param {string} [eventType] the event type of the relations requested
-     * @param {Object} [opts] options with optional values for the request.
-    * @return {Object} the response, with chunk, prev_batch and, next_batch.
+     * @param roomId - the room of the event
+     * @param eventId - the id of the event
+     * @param relationType - the rel_type of the relations requested
+     * @param eventType - the event type of the relations requested
+     * @param opts - options with optional values for the request.
+    * @returns the response, with chunk, prev_batch and, next_batch.
      */
     public fetchRelations(
         roomId: string,
@@ -7695,9 +7701,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public roomState(roomId: string): Promise<IStateEventWithRoomId[]> {
         const path = utils.encodeUri("/rooms/$roomId/state", { $roomId: roomId });
@@ -7706,11 +7711,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get an event in a room by its event id.
-     * @param {string} roomId
-     * @param {string} eventId
      *
-     * @return {Promise} Resolves to an object containing the event.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves to an object containing the event.
+     * @returns Rejects: with an error response.
      */
     public fetchRoomEvent(roomId: string, eventId: string): Promise<Partial<IEvent>> {
         const path = utils.encodeUri(
@@ -7723,12 +7726,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} includeMembership the membership type to include in the response
-     * @param {string} excludeMembership the membership type to exclude from the response
-     * @param {string} atEventId the id of the event for which moment in the timeline the members should be returned for
-     * @return {Promise} Resolves: dictionary of userid to profile information
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param includeMembership - the membership type to include in the response
+     * @param excludeMembership - the membership type to exclude from the response
+     * @param atEventId - the id of the event for which moment in the timeline the members should be returned for
+     * @returns Promise which resolves: dictionary of userid to profile information
+     * @returns Rejects: with an error response.
      */
     public members(
         roomId: string,
@@ -7756,10 +7758,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Upgrades a room to a new protocol version
-     * @param {string} roomId
-     * @param {string} newVersion The target version to upgrade to
-     * @return {Promise} Resolves: Object with key 'replacement_room'
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param newVersion - The target version to upgrade to
+     * @returns Promise which resolves: Object with key 'replacement_room'
+     * @returns Rejects: with an error response.
      */
     public upgradeRoom(
         roomId: string,
@@ -7771,11 +7772,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Retrieve a state event.
-     * @param {string} roomId
-     * @param {string} eventType
-     * @param {string} stateKey
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public getStateEvent(
         roomId: string,
@@ -7795,13 +7793,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {string} eventType
-     * @param {Object} content
-     * @param {string} stateKey
-     * @param {IRequestOpts} opts Options for the request function.
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param opts - Options for the request function.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public sendStateEvent(
         roomId: string,
@@ -7823,10 +7817,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomId
-     * @param {Number} limit
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public roomInitialSync(roomId: string, limit: number): Promise<IRoomInitialSyncResponse> {
         const path = utils.encodeUri("/rooms/$roomId/initialSync",
@@ -7841,14 +7833,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * event. This can be retrieved from room account data (the event type is `m.fully_read`)
      * and displayed as a horizontal line in the timeline that is visually distinct to the
      * position of the user's own read receipt.
-     * @param {string} roomId ID of the room that has been read
-     * @param {string} rmEventId ID of the event that has been read
-     * @param {string} rrEventId ID of the event tracked by the read receipt. This is here
+     * @param roomId - ID of the room that has been read
+     * @param rmEventId - ID of the event that has been read
+     * @param rrEventId - ID of the event tracked by the read receipt. This is here
      * for convenience because the RR and the RM are commonly updated at the same time as
      * each other. Optional.
-     * @param {string} rpEventId rpEvent the m.read.private read receipt event for when we
+     * @param rpEventId - rpEvent the m.read.private read receipt event for when we
      * don't want other users to see the read receipts. This is experimental. Optional.
-     * @return {Promise} Resolves: the empty object, {}.
+     * @returns Promise which resolves: the empty object, `{}`.
      */
     public async setRoomReadMarkersHttpRequest(
         roomId: string,
@@ -7876,8 +7868,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @return {Promise} Resolves: A list of the user's current rooms
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: A list of the user's current rooms
+     * @returns Rejects: with an error response.
      */
     public getJoinedRooms(): Promise<IJoinedRoomsResponse> {
         const path = utils.encodeUri("/joined_rooms", {});
@@ -7886,10 +7878,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Retrieve membership info. for a room.
-     * @param {string} roomId ID of the room to get membership for
-     * @return {Promise} Resolves: A list of currently joined users
+     * @param roomId - ID of the room to get membership for
+     * @returns Promise which resolves: A list of currently joined users
      *                                 and their profile data.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Rejects: with an error response.
      */
     public getJoinedRoomMembers(roomId: string): Promise<IJoinedMembersResponse> {
         const path = utils.encodeUri("/rooms/$roomId/joined_members", {
@@ -7899,16 +7891,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {Object} options Options for this request
-     * @param {string} options.server The remote server to query for the room list.
+     * @param options - Options for this request
+     * @param server - The remote server to query for the room list.
      *                                Optional. If unspecified, get the local home
      *                                server's public room list.
-     * @param {number} options.limit Maximum number of entries to return
-     * @param {string} options.since Token to paginate from
-     * @param {object} options.filter Filter parameters
-     * @param {string} options.filter.generic_search_term String to search for
-     * @return {Promise} Resolves: IPublicRoomsResponse
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param limit - Maximum number of entries to return
+     * @param since - Token to paginate from
+     * @returns Promise which resolves: IPublicRoomsResponse
+     * @returns Rejects: with an error response.
      */
     public publicRooms(
         { server, limit, since, ...options }: IRoomDirectoryOptions = {},
@@ -7923,10 +7913,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Create an alias to room ID mapping.
-     * @param {string} alias The room alias to create.
-     * @param {string} roomId The room ID to link the alias to.
-     * @return {Promise} Resolves: an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param alias - The room alias to create.
+     * @param roomId - The room ID to link the alias to.
+     * @returns Promise which resolves: an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public createAlias(alias: string, roomId: string): Promise<{}> {
         const path = utils.encodeUri("/directory/room/$alias", {
@@ -7941,9 +7931,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Delete an alias to room ID mapping. This alias must be on your local server,
      * and you must have sufficient access to do this operation.
-     * @param {string} alias The room alias to delete.
-     * @return {Promise} Resolves: an empty object {}.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param alias - The room alias to delete.
+     * @returns Promise which resolves: an empty object `{}`.
+     * @returns Rejects: with an error response.
      */
     public deleteAlias(alias: string): Promise<{}> {
         const path = utils.encodeUri("/directory/room/$alias", {
@@ -7955,9 +7945,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Gets the local aliases for the room. Note: this includes all local aliases, unlike the
      * curated list from the m.room.canonical_alias state event.
-     * @param {string} roomId The room ID to get local aliases for.
-     * @return {Promise} Resolves: an object with an `aliases` property, containing an array of local aliases
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param roomId - The room ID to get local aliases for.
+     * @returns Promise which resolves: an object with an `aliases` property, containing an array of local aliases
+     * @returns Rejects: with an error response.
      */
     public getLocalAliases(roomId: string): Promise<{ aliases: string[] }> {
         const path = utils.encodeUri("/rooms/$roomId/aliases", { $roomId: roomId });
@@ -7967,9 +7957,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get room info for the given alias.
-     * @param {string} alias The room alias to resolve.
-     * @return {Promise} Resolves: Object with room_id and servers.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param alias - The room alias to resolve.
+     * @returns Promise which resolves: Object with room_id and servers.
+     * @returns Rejects: with an error response.
      */
     public getRoomIdForAlias(
         alias: string,
@@ -7982,9 +7972,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} roomAlias
-     * @return {Promise} Resolves: Object with room_id and servers.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Object with room_id and servers.
+     * @returns Rejects: with an error response.
      */
     // eslint-disable-next-line camelcase
     public resolveRoomAlias(roomAlias: string): Promise<{ room_id: string, servers: string[] }> {
@@ -7995,9 +7984,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the visibility of a room in the current HS's room directory
-     * @param {string} roomId
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public getRoomDirectoryVisibility(roomId: string): Promise<{ visibility: Visibility }> {
         const path = utils.encodeUri("/directory/list/room/$roomId", {
@@ -8008,12 +7996,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Set the visbility of a room in the current HS's room directory
-     * @param {string} roomId
-     * @param {string} visibility "public" to make the room visible
+     * @param visibility - "public" to make the room visible
      *                 in the public directory, or "private" to make
      *                 it invisible.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public setRoomDirectoryVisibility(roomId: string, visibility: Visibility): Promise<{}> {
         const path = utils.encodeUri("/directory/list/room/$roomId", {
@@ -8025,14 +8012,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Set the visbility of a room bridged to a 3rd party network in
      * the current HS's room directory.
-     * @param {string} networkId the network ID of the 3rd party
+     * @param networkId - the network ID of the 3rd party
      *                 instance under which this room is published under.
-     * @param {string} roomId
-     * @param {string} visibility "public" to make the room visible
+     * @param visibility - "public" to make the room visible
      *                 in the public directory, or "private" to make
      *                 it invisible.
-     * @return {Promise} Resolves: result object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: result object
+     * @returns Rejects: with an error response.
      */
     public setRoomDirectoryVisibilityAppService(
         networkId: string,
@@ -8048,19 +8034,18 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Query the user directory with a term matching user IDs, display names and domains.
-     * @param {object} opts options
-     * @param {string} opts.term the term with which to search.
-     * @param {number} opts.limit the maximum number of results to return. The server will
+     * @param term - the term with which to search.
+     * @param limit - the maximum number of results to return. The server will
      *                 apply a limit if unspecified.
-     * @return {Promise} Resolves: an array of results.
+     * @returns Promise which resolves: an array of results.
      */
-    public searchUserDirectory(opts: { term: string, limit?: number }): Promise<IUserDirectoryResponse> {
+    public searchUserDirectory({ term, limit }: { term: string, limit?: number }): Promise<IUserDirectoryResponse> {
         const body: any = {
-            search_term: opts.term,
+            search_term: term,
         };
 
-        if (opts.limit !== undefined) {
-            body.limit = opts.limit;
+        if (limit !== undefined) {
+            body.limit = limit;
         }
 
         return this.http.authedRequest(Method.Post, "/user_directory/search", undefined, body);
@@ -8069,27 +8054,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Upload a file to the media repository on the homeserver.
      *
-     * @param {object} file The object to upload. On a browser, something that
+     * @param file - The object to upload. On a browser, something that
      *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,
      *   a a Buffer, String or ReadStream.
      *
-     * @param {object} opts  options object
-     *
-     * @param {string=} opts.name   Name to give the file on the server. Defaults
-     *   to <tt>file.name</tt>.
-     *
-     * @param {boolean=} opts.includeFilename if false will not send the filename,
-     *   e.g for encrypted file uploads where filename leaks are undesirable.
-     *   Defaults to true.
-     *
-     * @param {string=} opts.type   Content-type for the upload. Defaults to
-     *   <tt>file.type</tt>, or <tt>applicaton/octet-stream</tt>.
-     *
-     * @param {Function=} opts.progressHandler Optional. Called when a chunk of
-     *    data has been uploaded, with an object containing the fields `loaded`
-     *    (number of bytes transferred) and `total` (total size, if known).
+     * @param opts -  options object
      *
-     * @return {Promise} Resolves to response object, as
+     * @returns Promise which resolves to response object, as
      *    determined by this.opts.onlyData, opts.rawResponse, and
      *    opts.onlyContentUri.  Rejects with an error (usually a MatrixError).
      */
@@ -8099,8 +8070,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Cancel a file upload in progress
-     * @param {Promise} upload The object returned from uploadContent
-     * @return {boolean} true if canceled, otherwise false
+     * @param upload - The object returned from uploadContent
+     * @returns true if canceled, otherwise false
      */
     public cancelUpload(upload: Promise<UploadResponse>): boolean {
         return this.http.cancelUpload(upload);
@@ -8108,7 +8079,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get a list of all file uploads in progress
-     * @return {array} Array of objects representing current uploads.
+     * @returns Array of objects representing current uploads.
      * Currently in progress is element 0. Keys:
      *  - promise: The promise associated with the upload
      *  - loaded: Number of bytes uploaded
@@ -8119,11 +8090,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} userId
-     * @param {string} info The kind of info to retrieve (e.g. 'displayname',
+     * @param info - The kind of info to retrieve (e.g. 'displayname',
      * 'avatar_url').
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      */
     public getProfileInfo(
         userId: string,
@@ -8139,8 +8109,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @return {Promise} Resolves to a list of the user's threepids.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves to a list of the user's threepids.
+     * @returns Rejects: with an error response.
      */
     public getThreePids(): Promise<{ threepids: IThreepid[] }> {
         return this.http.authedRequest(Method.Get, "/account/3pid");
@@ -8153,10 +8123,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * This API is deprecated, and you should instead use `addThreePidOnly`
      * for homeservers that support it.
      *
-     * @param {Object} creds
-     * @param {boolean} bind
-     * @return {Promise} Resolves: on success
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: on success
+     * @returns Rejects: with an error response.
      */
     public addThreePid(creds: any, bind: boolean): Promise<any> { // TODO: Types
         const path = "/account/3pid";
@@ -8174,10 +8142,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * You can check whether a homeserver supports this API via
      * `doesServerSupportSeparateAddAndBind`.
      *
-     * @param {Object} data A object with 3PID validation data from having called
+     * @param data - A object with 3PID validation data from having called
      * `account/3pid/<medium>/requestToken` on the homeserver.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public async addThreePidOnly(data: IAddThreePidOnlyBody): Promise<{}> {
         const path = "/account/3pid/add";
@@ -8193,11 +8161,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * You can check whether a homeserver supports this API via
      * `doesServerSupportSeparateAddAndBind`.
      *
-     * @param {Object} data A object with 3PID validation data from having called
+     * @param data - A object with 3PID validation data from having called
      * `validate/<medium>/requestToken` on the identity server. It should also
      * contain `id_server` and `id_access_token` fields as well.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public async bindThreePid(data: IBindThreePidBody): Promise<{}> {
         const path = "/account/3pid/bind";
@@ -8210,11 +8178,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * homeserver removes its record of the binding to keep an updated record of
      * where all 3PIDs for the account are bound.
      *
-     * @param {string} medium The threepid medium (eg. 'email')
-     * @param {string} address The threepid address (eg. 'bob@example.com')
+     * @param medium - The threepid medium (eg. 'email')
+     * @param address - The threepid address (eg. 'bob\@example.com')
      *        this must be as returned by getThreePids.
-     * @return {Promise} Resolves: on success
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: on success
+     * @returns Rejects: with an error response.
      */
     public async unbindThreePid(
         medium: string,
@@ -8232,12 +8200,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} medium The threepid medium (eg. 'email')
-     * @param {string} address The threepid address (eg. 'bob@example.com')
+     * @param medium - The threepid medium (eg. 'email')
+     * @param address - The threepid address (eg. 'bob\@example.com')
      *        this must be as returned by getThreePids.
-     * @return {Promise} Resolves: The server response on success
+     * @returns Promise which resolves: The server response on success
      *     (generally the empty JSON object)
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Rejects: with an error response.
      */
     public deleteThreePid(
         medium: string,
@@ -8250,11 +8218,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Make a request to change your password.
-     * @param {Object} authDict
-     * @param {string} newPassword The new desired password.
-     * @param {boolean} logoutDevices Should all sessions be logged out after the password change. Defaults to true.
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param newPassword - The new desired password.
+     * @param logoutDevices - Should all sessions be logged out after the password change. Defaults to true.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public setPassword(
         authDict: IAuthDict,
@@ -8273,8 +8240,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Gets all devices recorded for the logged-in user
-     * @return {Promise} Resolves: result object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: result object
+     * @returns Rejects: with an error response.
      */
     public getDevices(): Promise<{ devices: IMyDevice[] }> {
         return this.http.authedRequest(Method.Get, "/devices");
@@ -8282,9 +8249,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Gets specific device details for the logged-in user
-     * @param {string} deviceId  device to query
-     * @return {Promise} Resolves: result object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param deviceId -  device to query
+     * @returns Promise which resolves: result object
+     * @returns Rejects: with an error response.
      */
     public getDevice(deviceId: string): Promise<IMyDevice> {
         const path = utils.encodeUri("/devices/$device_id", {
@@ -8296,10 +8263,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Update the given device
      *
-     * @param {string} deviceId  device to update
-     * @param {Object} body       body of request
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param deviceId -  device to update
+     * @param body -       body of request
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     // eslint-disable-next-line camelcase
     public setDeviceDetails(deviceId: string, body: { display_name: string }): Promise<{}> {
@@ -8313,10 +8280,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Delete the given device
      *
-     * @param {string} deviceId  device to delete
-     * @param {object} auth Optional. Auth data to supply for User-Interactive auth.
-     * @return {Promise} Resolves: result object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param deviceId -  device to delete
+     * @param auth - Optional. Auth data to supply for User-Interactive auth.
+     * @returns Promise which resolves: result object
+     * @returns Rejects: with an error response.
      */
     public deleteDevice(deviceId: string, auth?: IAuthDict): Promise<IAuthData | {}> {
         const path = utils.encodeUri("/devices/$device_id", {
@@ -8335,10 +8302,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Delete multiple device
      *
-     * @param {string[]} devices IDs of the devices to delete
-     * @param {object} auth Optional. Auth data to supply for User-Interactive auth.
-     * @return {Promise} Resolves: result object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param devices - IDs of the devices to delete
+     * @param auth - Optional. Auth data to supply for User-Interactive auth.
+     * @returns Promise which resolves: result object
+     * @returns Rejects: with an error response.
      */
     public deleteMultipleDevices(devices: string[], auth?: IAuthDict): Promise<IAuthData | {}> {
         const body: any = { devices };
@@ -8354,8 +8321,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Gets all pushers registered for the logged-in user
      *
-     * @return {Promise} Resolves: Array of objects representing pushers
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Array of objects representing pushers
+     * @returns Rejects: with an error response.
      */
     public async getPushers(): Promise<{ pushers: IPusher[] }> {
         const response = await this.http.authedRequest<{ pushers: IPusher[] }>(Method.Get, "/pushers");
@@ -8377,9 +8344,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Adds a new pusher or updates an existing pusher
      *
-     * @param {IPusherRequest} pusher Object representing a pusher
-     * @return {Promise} Resolves: Empty json object on success
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param pusher - Object representing a pusher
+     * @returns Promise which resolves: Empty json object on success
+     * @returns Rejects: with an error response.
      */
     public setPusher(pusher: IPusherRequest): Promise<{}> {
         const path = "/pushers/set";
@@ -8388,10 +8355,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Persists local notification settings
-     * @param {string} deviceId
-     * @param {LocalNotificationSettings} notificationSettings
-     * @return {Promise} Resolves: an empty object
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: an empty object
+     * @returns Rejects: with an error response.
      */
     public setLocalNotificationSettings(
         deviceId: string,
@@ -8403,8 +8368,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Get the push rules for the account from the server.
-     * @return {Promise} Resolves to the push rules.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves to the push rules.
+     * @returns Rejects: with an error response.
      */
     public getPushRules(): Promise<IPushRules> {
         return this.http.authedRequest<IPushRules>(Method.Get, "/pushrules/").then((rules: IPushRules) => {
@@ -8413,12 +8378,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} scope
-     * @param {string} kind
-     * @param {string} ruleId
-     * @param {Object} body
-     * @return {Promise} Resolves: an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public addPushRule(
         scope: string,
@@ -8435,11 +8396,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * @param {string} scope
-     * @param {string} kind
-     * @param {string} ruleId
-     * @return {Promise} Resolves: an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public deletePushRule(
         scope: string,
@@ -8456,12 +8414,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Enable or disable a push notification rule.
-     * @param {string} scope
-     * @param {string} kind
-     * @param {string} ruleId
-     * @param {boolean} enabled
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public setPushRuleEnabled(
         scope: string,
@@ -8478,12 +8432,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Set the actions for a push notification rule.
-     * @param {string} scope
-     * @param {string} kind
-     * @param {string} ruleId
-     * @param {array} actions
-     * @return {Promise} Resolves: to an empty object {}
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: to an empty object `{}`
+     * @returns Rejects: with an error response.
      */
     public setPushRuleActions(
         scope: string,
@@ -8500,34 +8450,33 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Perform a server-side search.
-     * @param {Object} opts
-     * @param {string} opts.next_batch the batch token to pass in the query string
-     * @param {Object} opts.body the JSON object to pass to the request body.
-     * @param {AbortSignal=} abortSignal optional signal used to cancel the http request.
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @param next_batch - the batch token to pass in the query string
+     * @param body - the JSON object to pass to the request body.
+     * @param abortSignal - optional signal used to cancel the http request.
+     * @returns Promise which resolves to the search response object.
+     * @returns Rejects: with an error response.
      */
     public search(
-        opts: { body: ISearchRequestBody, next_batch?: string }, // eslint-disable-line camelcase
+        { body, next_batch: nextBatch }: { body: ISearchRequestBody, next_batch?: string },
         abortSignal?: AbortSignal,
     ): Promise<ISearchResponse> {
         const queryParams: any = {};
-        if (opts.next_batch) {
-            queryParams.next_batch = opts.next_batch;
+        if (nextBatch) {
+            queryParams.next_batch = nextBatch;
         }
-        return this.http.authedRequest(Method.Post, "/search", queryParams, opts.body, { abortSignal });
+        return this.http.authedRequest(Method.Post, "/search", queryParams, body, { abortSignal });
     }
 
     /**
      * Upload keys
      *
-     * @param {Object} content  body of upload request
+     * @param content -  body of upload request
      *
-     * @param {Object=} opts this method no longer takes any opts,
+     * @param opts - this method no longer takes any opts,
      *  used to take opts.device_id but this was not removed from the spec as a redundant parameter
      *
-     * @return {Promise} Resolves: result object. Rejects: with
-     *     an error response ({@link module:http-api.MatrixError}).
+     * @returns Promise which resolves: result object. Rejects: with
+     *     an error response ({@link MatrixError}).
      */
     public uploadKeysRequest(
         content: IUploadKeysRequest,
@@ -8548,22 +8497,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Download device keys
      *
-     * @param {string[]} userIds  list of users to get keys for
+     * @param userIds -  list of users to get keys for
      *
-     * @param {Object=} opts
-     *
-     * @param {string=} opts.token   sync token to pass in the query request, to help
+     * @param token - sync token to pass in the query request, to help
      *   the HS give the most recent results
      *
-     * @return {Promise} Resolves: result object. Rejects: with
-     *     an error response ({@link module:http-api.MatrixError}).
+     * @returns Promise which resolves: result object. Rejects: with
+     *     an error response ({@link MatrixError}).
      */
-    public downloadKeysForUsers(userIds: string[], opts: { token?: string } = {}): Promise<IDownloadKeyResult> {
+    public downloadKeysForUsers(userIds: string[], { token }: { token?: string } = {}): Promise<IDownloadKeyResult> {
         const content: IQueryKeysRequest = {
             device_keys: {},
         };
-        if ('token' in opts) {
-            content.token = opts.token;
+        if (token !== undefined) {
+            content.token = token;
         }
         userIds.forEach((u) => {
             content.device_keys[u] = [];
@@ -8575,15 +8522,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Claim one-time keys
      *
-     * @param {string[]} devices  a list of [userId, deviceId] pairs
+     * @param devices -  a list of [userId, deviceId] pairs
      *
-     * @param {string} [keyAlgorithm = signed_curve25519]  desired key type
+     * @param keyAlgorithm -  desired key type
      *
-     * @param {number} [timeout] the time (in milliseconds) to wait for keys from remote
+     * @param timeout - the time (in milliseconds) to wait for keys from remote
      *     servers
      *
-     * @return {Promise} Resolves: result object. Rejects: with
-     *     an error response ({@link module:http-api.MatrixError}).
+     * @returns Promise which resolves: result object. Rejects: with
+     *     an error response ({@link MatrixError}).
      */
     public claimOneTimeKeys(
         devices: [string, string][],
@@ -8613,11 +8560,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Ask the server for a list of users who have changed their device lists
      * between a pair of sync tokens
      *
-     * @param {string} oldToken
-     * @param {string} newToken
      *
-     * @return {Promise} Resolves: result object. Rejects: with
-     *     an error response ({@link module:http-api.MatrixError}).
+     * @returns Promise which resolves: result object. Rejects: with
+     *     an error response ({@link MatrixError}).
      */
     public getKeyChanges(oldToken: string, newToken: string): Promise<{ changed: string[], left: string[] }> {
         const qps = {
@@ -8641,15 +8586,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Register with an identity server using the OpenID token from the user's
      * Homeserver, which can be retrieved via
-     * {@link module:client~MatrixClient#getOpenIdToken}.
+     * {@link MatrixClient#getOpenIdToken}.
      *
      * Note that the `/account/register` endpoint (as well as IS authentication in
      * general) was added as part of the v2 API version.
      *
-     * @param {object} hsOpenIdToken
-     * @return {Promise} Resolves: with object containing an Identity
+     * @returns Promise which resolves: with object containing an Identity
      * Server access token.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Rejects: with an error response.
      */
     public registerWithIdentityServer(hsOpenIdToken: IOpenIDToken): Promise<{
         access_token: string;
@@ -8670,20 +8614,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * server. The validation data that results should be passed to the
      * `bindThreePid` method to complete the binding process.
      *
-     * @param {string} email The email address to request a token for
-     * @param {string} clientSecret A secret binary string generated by the client.
+     * @param email - The email address to request a token for
+     * @param clientSecret - A secret binary string generated by the client.
      *                 It is recommended this be around 16 ASCII characters.
-     * @param {number} sendAttempt If an identity server sees a duplicate request
+     * @param sendAttempt - If an identity server sees a duplicate request
      *                 with the same sendAttempt, it will not send another email.
      *                 To request another email to be sent, use a larger value for
      *                 the sendAttempt param as was used in the previous request.
-     * @param {string} nextLink Optional If specified, the client will be redirected
+     * @param nextLink - Optional If specified, the client will be redirected
      *                 to this link after validation.
-     * @param {string} identityAccessToken The `access_token` field of the identity
+     * @param identityAccessToken - The `access_token` field of the identity
      * server `/account/register` response (see {@link registerWithIdentityServer}).
      *
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      * @throws Error if no identity server is set
      */
     public requestEmailToken(
@@ -8713,23 +8657,23 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * server. The validation data that results should be passed to the
      * `bindThreePid` method to complete the binding process.
      *
-     * @param {string} phoneCountry The ISO 3166-1 alpha-2 code for the country in
+     * @param phoneCountry - The ISO 3166-1 alpha-2 code for the country in
      *                 which phoneNumber should be parsed relative to.
-     * @param {string} phoneNumber The phone number, in national or international
+     * @param phoneNumber - The phone number, in national or international
      *                 format
-     * @param {string} clientSecret A secret binary string generated by the client.
+     * @param clientSecret - A secret binary string generated by the client.
      *                 It is recommended this be around 16 ASCII characters.
-     * @param {number} sendAttempt If an identity server sees a duplicate request
+     * @param sendAttempt - If an identity server sees a duplicate request
      *                 with the same sendAttempt, it will not send another SMS.
      *                 To request another SMS to be sent, use a larger value for
      *                 the sendAttempt param as was used in the previous request.
-     * @param {string} nextLink Optional If specified, the client will be redirected
+     * @param nextLink - Optional If specified, the client will be redirected
      *                 to this link after validation.
-     * @param {string} identityAccessToken The `access_token` field of the Identity
+     * @param identityAccessToken - The `access_token` field of the Identity
      * Server `/account/register` response (see {@link registerWithIdentityServer}).
      *
-     * @return {Promise} Resolves: TODO
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: TODO
+     * @returns Rejects: with an error response.
      * @throws Error if no identity server is set
      */
     public requestMsisdnToken(
@@ -8762,15 +8706,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * not expose this, since email is normally validated by the user clicking
      * a link rather than entering a code.
      *
-     * @param {string} sid The sid given in the response to requestToken
-     * @param {string} clientSecret A secret binary string generated by the client.
+     * @param sid - The sid given in the response to requestToken
+     * @param clientSecret - A secret binary string generated by the client.
      *                 This must be the same value submitted in the requestToken call.
-     * @param {string} msisdnToken The MSISDN token, as enetered by the user.
-     * @param {string} identityAccessToken The `access_token` field of the Identity
+     * @param msisdnToken - The MSISDN token, as enetered by the user.
+     * @param identityAccessToken - The `access_token` field of the Identity
      * Server `/account/register` response (see {@link registerWithIdentityServer}).
      *
-     * @return {Promise} Resolves: Object, currently with no parameters.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Object, currently with no parameters.
+     * @returns Rejects: with an error response.
      * @throws Error if No identity server is set
      */
     public submitMsisdnToken(
@@ -8800,14 +8744,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * `submit_url` to specify where the token should be sent, and this helper can
      * be used to pass the token to this URL.
      *
-     * @param {string} url The URL to submit the token to
-     * @param {string} sid The sid given in the response to requestToken
-     * @param {string} clientSecret A secret binary string generated by the client.
+     * @param url - The URL to submit the token to
+     * @param sid - The sid given in the response to requestToken
+     * @param clientSecret - A secret binary string generated by the client.
      *                 This must be the same value submitted in the requestToken call.
-     * @param {string} msisdnToken The MSISDN token, as enetered by the user.
+     * @param msisdnToken - The MSISDN token, as enetered by the user.
      *
-     * @return {Promise} Resolves: Object, currently with no parameters.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Object, currently with no parameters.
+     * @returns Rejects: with an error response.
      */
     public submitMsisdnTokenOtherUrl(
         url: string,
@@ -8826,8 +8770,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Gets the V2 hashing information from the identity server. Primarily useful for
      * lookups.
-     * @param {string} identityAccessToken The access token for the identity server.
-     * @returns {Promise<object>} The hashing information for the identity server.
+     * @param identityAccessToken - The access token for the identity server.
+     * @returns The hashing information for the identity server.
      */
     public getIdentityHashDetails(identityAccessToken: string): Promise<any> { // TODO: Types
         return this.http.idServerRequest(
@@ -8842,11 +8786,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Performs a hashed lookup of addresses against the identity server. This is
      * only supported on identity servers which have at least the version 2 API.
-     * @param {Array<Array<string,string>>} addressPairs An array of 2 element arrays.
+     * @param addressPairs - An array of 2 element arrays.
      * The first element of each pair is the address, the second is the 3PID medium.
-     * Eg: ["email@example.org", "email"]
-     * @param {string} identityAccessToken The access token for the identity server.
-     * @returns {Promise<Array<{address, mxid}>>} A collection of address mappings to
+     * Eg: `["email@example.org", "email"]`
+     * @param identityAccessToken - The access token for the identity server.
+     * @returns A collection of address mappings to
      * found MXIDs. Results where no user could be found will not be listed.
      */
     public async identityHashedLookup(
@@ -8925,15 +8869,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * Looks up the public Matrix ID mapping for a given 3rd party
      * identifier from the identity server
      *
-     * @param {string} medium The medium of the threepid, eg. 'email'
-     * @param {string} address The textual address of the threepid
-     * @param {string} identityAccessToken The `access_token` field of the Identity
+     * @param medium - The medium of the threepid, eg. 'email'
+     * @param address - The textual address of the threepid
+     * @param identityAccessToken - The `access_token` field of the Identity
      * Server `/account/register` response (see {@link registerWithIdentityServer}).
      *
-     * @return {Promise} Resolves: A threepid mapping
+     * @returns Promise which resolves: A threepid mapping
      *                                 object or the empty object if no mapping
      *                                 exists
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Rejects: with an error response.
      */
     public async lookupThreePid(
         medium: string,
@@ -8967,13 +8911,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Looks up the public Matrix ID mappings for multiple 3PIDs.
      *
-     * @param {Array.<Array.<string>>} query Array of arrays containing
+     * @param query - Array of arrays containing
      * [medium, address]
-     * @param {string} identityAccessToken The `access_token` field of the Identity
+     * @param identityAccessToken - The `access_token` field of the Identity
      * Server `/account/register` response (see {@link registerWithIdentityServer}).
      *
-     * @return {Promise} Resolves: Lookup results from IS.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: Lookup results from IS.
+     * @returns Rejects: with an error response.
      */
     public async bulkLookupThreePids(query: [string, string][], identityAccessToken: string): Promise<any> { // TODO: Types
         // Note: we're using the V2 API by calling this function, but our
@@ -9006,11 +8950,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * to verify that other APIs are likely to approve access by testing that the
      * token is valid, terms have been agreed, etc.
      *
-     * @param {string} identityAccessToken The `access_token` field of the Identity
+     * @param identityAccessToken - The `access_token` field of the Identity
      * Server `/account/register` response (see {@link registerWithIdentityServer}).
      *
-     * @return {Promise} Resolves: an object with account info.
-     * @return {module:http-api.MatrixError} Rejects: with an error response.
+     * @returns Promise which resolves: an object with account info.
+     * @returns Rejects: with an error response.
      */
     public getIdentityAccount(identityAccessToken: string): Promise<any> { // TODO: Types
         return this.http.idServerRequest(
@@ -9025,12 +8969,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * call to send to-device messages. We recommend using
      * queueToDevice() which is a higher level API.
      *
-     * @param {string} eventType  type of event to send
-     * @param {Object.<string, Object<string, Object>>} contentMap
+     * @param eventType -  type of event to send
      *    content to send. Map from user_id to device_id to content object.
-     * @param {string=} txnId     transaction id. One will be made up if not
+     * @param txnId -     transaction id. One will be made up if not
      *    supplied.
-     * @return {Promise} Resolves: to an empty object {}
+     * @returns Promise which resolves: to an empty object `{}`
      */
     public sendToDevice(
         eventType: string,
@@ -9060,7 +9003,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * messaging system. The batch will be split up into appropriately sized
      * batches for sending and stored in the store so they can be retried
      * later if they fail to send. Retries will happen automatically.
-     * @param batch The to-device messages to send
+     * @param batch - The to-device messages to send
      */
     public queueToDevice(batch: ToDeviceBatch): Promise<void> {
         return this.toDeviceMessageQueue.queueBatch(batch);
@@ -9069,7 +9012,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get the third party protocols that can be reached using
      * this HS
-     * @return {Promise} Resolves to the result object
+     * @returns Promise which resolves to the result object
      */
     public getThirdpartyProtocols(): Promise<{ [protocol: string]: IProtocol }> {
         return this.http.authedRequest<Record<string, IProtocol>>(
@@ -9086,10 +9029,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get information on how a specific place on a third party protocol
      * may be reached.
-     * @param {string} protocol The protocol given in getThirdpartyProtocols()
-     * @param {object} params Protocol-specific parameters, as given in the
+     * @param protocol - The protocol given in getThirdpartyProtocols()
+     * @param params - Protocol-specific parameters, as given in the
      *                        response to getThirdpartyProtocols()
-     * @return {Promise} Resolves to the result object
+     * @returns Promise which resolves to the result object
      */
     public getThirdpartyLocation(
         protocol: string,
@@ -9105,10 +9048,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Get information on how a specific user on a third party protocol
      * may be reached.
-     * @param {string} protocol The protocol given in getThirdpartyProtocols()
-     * @param {object} params Protocol-specific parameters, as given in the
+     * @param protocol - The protocol given in getThirdpartyProtocols()
+     * @param params - Protocol-specific parameters, as given in the
      *                        response to getThirdpartyProtocols()
-     * @return {Promise} Resolves to the result object
+     * @returns Promise which resolves to the result object
      */
     public getThirdpartyUser(protocol: string, params: any): Promise<IThirdPartyUser[]> { // TODO: Types
         const path = utils.encodeUri("/thirdparty/user/$protocol", {
@@ -9140,11 +9083,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Reports an event as inappropriate to the server, which may then notify the appropriate people.
-     * @param {string} roomId The room in which the event being reported is located.
-     * @param {string} eventId The event to report.
-     * @param {number} score The score to rate this content as where -100 is most offensive and 0 is inoffensive.
-     * @param {string} reason The reason the content is being reported. May be blank.
-     * @returns {Promise} Resolves to an empty object if successful
+     * @param roomId - The room in which the event being reported is located.
+     * @param eventId - The event to report.
+     * @param score - The score to rate this content as where -100 is most offensive and 0 is inoffensive.
+     * @param reason - The reason the content is being reported. May be blank.
+     * @returns Promise which resolves to an empty object if successful
      */
     public reportEvent(roomId: string, eventId: string, score: number, reason: string): Promise<{}> {
         const path = utils.encodeUri("/rooms/$roomId/report/$eventId", {
@@ -9158,12 +9101,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Fetches or paginates a room hierarchy as defined by MSC2946.
      * Falls back gracefully to sourcing its data from `getSpaceSummary` if this API is not yet supported by the server.
-     * @param {string} roomId The ID of the space-room to use as the root of the summary.
-     * @param {number?} limit The maximum number of rooms to return per page.
-     * @param {number?} maxDepth The maximum depth in the tree from the root room to return.
-     * @param {boolean?} suggestedOnly Whether to only return rooms with suggested=true.
-     * @param {string?} fromToken The opaque token to paginate a previous request.
-     * @returns {Promise} the response, with next_batch & rooms fields.
+     * @param roomId - The ID of the space-room to use as the root of the summary.
+     * @param limit - The maximum number of rooms to return per page.
+     * @param maxDepth - The maximum depth in the tree from the root room to return.
+     * @param suggestedOnly - Whether to only return rooms with suggested=true.
+     * @param fromToken - The opaque token to paginate a previous request.
+     * @returns the response, with next_batch & rooms fields.
      */
     public getRoomHierarchy(
         roomId: string,
@@ -9203,8 +9146,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * by the returned class.
      *
      * Note that this is UNSTABLE and may have breaking changes without notice.
-     * @param {string} name The name of the tree space.
-     * @returns {Promise<MSC3089TreeSpace>} Resolves to the created space.
+     * @param name - The name of the tree space.
+     * @returns Promise which resolves to the created space.
      */
     public async unstableCreateFileTree(name: string): Promise<MSC3089TreeSpace> {
         const { room_id: roomId } = await this.createRoom({
@@ -9244,8 +9187,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * does not appear to be a tree space then null is returned.
      *
      * Note that this is UNSTABLE and may have breaking changes without notice.
-     * @param {string} roomId The room ID to get a tree space reference for.
-     * @returns {MSC3089TreeSpace} The tree space, or null if not a tree space.
+     * @param roomId - The room ID to get a tree space reference for.
+     * @returns The tree space, or null if not a tree space.
      */
     public unstableGetFileTreeSpace(roomId: string): MSC3089TreeSpace | null {
         const room = this.getRoom(roomId);
@@ -9266,10 +9209,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Perform a single MSC3575 sliding sync request.
-     * @param {MSC3575SlidingSyncRequest} req The request to make.
-     * @param {string} proxyBaseUrl The base URL for the sliding sync proxy.
-     * @param {AbortSignal} abortSignal Optional signal to abort request mid-flight.
-     * @returns {MSC3575SlidingSyncResponse} The sliding sync response, or a standard error.
+     * @param req - The request to make.
+     * @param proxyBaseUrl - The base URL for the sliding sync proxy.
+     * @param abortSignal - Optional signal to abort request mid-flight.
+     * @returns The sliding sync response, or a standard error.
      * @throws on non 2xx status codes with an object with a field "httpStatus":number.
      */
     public slidingSync(
@@ -9312,8 +9255,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Fetches the summary of a room as defined by an initial version of MSC3266 and implemented in Synapse
      * Proposed at https://github.com/matrix-org/matrix-doc/pull/3266
-     * @param {string} roomIdOrAlias The ID or alias of the room to get the summary of.
-     * @param {string[]?} via The list of servers which know about the room if only an ID was provided.
+     * @param roomIdOrAlias - The ID or alias of the room to get the summary of.
+     * @param via - The list of servers which know about the room if only an ID was provided.
      */
     public async getRoomSummary(roomIdOrAlias: string, via?: string[]): Promise<IRoomSummary> {
         const path = utils.encodeUri("/rooms/$roomid/summary", { $roomid: roomIdOrAlias });
@@ -9355,7 +9298,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     /**
      * Find the event_id closest to the given timestamp in the given direction.
-     * @return {Promise} A promise of an object containing the event_id and
+     * @returns A promise of an object containing the event_id and
      *    origin_server_ts of the closest event to the timestamp in the given
      *    direction
      */
@@ -9445,333 +9388,3 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
         }
     }
 }
-
-/**
- * Fires whenever the SDK receives a new event.
- * <p>
- * This is only fired for live events received via /sync - it is not fired for
- * events received over context, search, or pagination APIs.
- *
- * @event module:client~MatrixClient#"event"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @example
- * matrixClient.on("event", function(event){
- *   var sender = event.getSender();
- * });
- */
-
-/**
- * Fires whenever the SDK receives a new to-device event.
- * @event module:client~MatrixClient#"toDeviceEvent"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @example
- * matrixClient.on("toDeviceEvent", function(event){
- *   var sender = event.getSender();
- * });
- */
-
-/**
- * Fires whenever the SDK's syncing state is updated. The state can be one of:
- * <ul>
- *
- * <li>PREPARED: The client has synced with the server at least once and is
- * ready for methods to be called on it. This will be immediately followed by
- * a state of SYNCING. <i>This is the equivalent of "syncComplete" in the
- * previous API.</i></li>
- *
- * <li>CATCHUP: The client has detected the connection to the server might be
- * available again and will now try to do a sync again. As this sync might take
- * a long time (depending how long ago was last synced, and general server
- * performance) the client is put in this mode so the UI can reflect trying
- * to catch up with the server after losing connection.</li>
- *
- * <li>SYNCING : The client is currently polling for new events from the server.
- * This will be called <i>after</i> processing latest events from a sync.</li>
- *
- * <li>ERROR : The client has had a problem syncing with the server. If this is
- * called <i>before</i> PREPARED then there was a problem performing the initial
- * sync. If this is called <i>after</i> PREPARED then there was a problem polling
- * the server for updates. This may be called multiple times even if the state is
- * already ERROR. <i>This is the equivalent of "syncError" in the previous
- * API.</i></li>
- *
- * <li>RECONNECTING: The sync connection has dropped, but not (yet) in a way that
- * should be considered erroneous.
- * </li>
- *
- * <li>STOPPED: The client has stopped syncing with server due to stopClient
- * being called.
- * </li>
- * </ul>
- * State transition diagram:
- * <pre>
- *                                          +---->STOPPED
- *                                          |
- *              +----->PREPARED -------> SYNCING <--+
- *              |                        ^  |  ^    |
- *              |      CATCHUP ----------+  |  |    |
- *              |        ^                  V  |    |
- *   null ------+        |  +------- RECONNECTING   |
- *              |        V  V                       |
- *              +------->ERROR ---------------------+
- *
- * NB: 'null' will never be emitted by this event.
- *
- * </pre>
- * Transitions:
- * <ul>
- *
- * <li><code>null -> PREPARED</code> : Occurs when the initial sync is completed
- * first time. This involves setting up filters and obtaining push rules.
- *
- * <li><code>null -> ERROR</code> : Occurs when the initial sync failed first time.
- *
- * <li><code>ERROR -> PREPARED</code> : Occurs when the initial sync succeeds
- * after previously failing.
- *
- * <li><code>PREPARED -> SYNCING</code> : Occurs immediately after transitioning
- * to PREPARED. Starts listening for live updates rather than catching up.
- *
- * <li><code>SYNCING -> RECONNECTING</code> : Occurs when the live update fails.
- *
- * <li><code>RECONNECTING -> RECONNECTING</code> : Can occur if the update calls
- * continue to fail, but the keepalive calls (to /versions) succeed.
- *
- * <li><code>RECONNECTING -> ERROR</code> : Occurs when the keepalive call also fails
- *
- * <li><code>ERROR -> SYNCING</code> : Occurs when the client has performed a
- * live update after having previously failed.
- *
- * <li><code>ERROR -> ERROR</code> : Occurs when the client has failed to keepalive
- * for a second time or more.</li>
- *
- * <li><code>SYNCING -> SYNCING</code> : Occurs when the client has performed a live
- * update. This is called <i>after</i> processing.</li>
- *
- * <li><code>* -> STOPPED</code> : Occurs once the client has stopped syncing or
- * trying to sync after stopClient has been called.</li>
- * </ul>
- *
- * @event module:client~MatrixClient#"sync"
- *
- * @param {string} state An enum representing the syncing state. One of "PREPARED",
- * "SYNCING", "ERROR", "STOPPED".
- *
- * @param {?string} prevState An enum representing the previous syncing state.
- * One of "PREPARED", "SYNCING", "ERROR", "STOPPED" <b>or null</b>.
- *
- * @param {?Object} data Data about this transition.
- *
- * @param {MatrixError} data.error The matrix error if <code>state=ERROR</code>.
- *
- * @param {String} data.oldSyncToken The 'since' token passed to /sync.
- *    <code>null</code> for the first successful sync since this client was
- *    started. Only present if <code>state=PREPARED</code> or
- *    <code>state=SYNCING</code>.
- *
- * @param {String} data.nextSyncToken The 'next_batch' result from /sync, which
- *    will become the 'since' token for the next call to /sync. Only present if
- *    <code>state=PREPARED</code> or <code>state=SYNCING</code>.
- *
- * @param {boolean} data.catchingUp True if we are working our way through a
- *    backlog of events after connecting. Only present if <code>state=SYNCING</code>.
- *
- * @example
- * matrixClient.on("sync", function(state, prevState, data) {
- *   switch (state) {
- *     case "ERROR":
- *       // update UI to say "Connection Lost"
- *       break;
- *     case "SYNCING":
- *       // update UI to remove any "Connection Lost" message
- *       break;
- *     case "PREPARED":
- *       // the client instance is ready to be queried.
- *       var rooms = matrixClient.getRooms();
- *       break;
- *   }
- * });
- */
-
-/**
- * Fires whenever a new Room is added. This will fire when you are invited to a
- * room, as well as when you join a room. <strong>This event is experimental and
- * may change.</strong>
- * @event module:client~MatrixClient#"Room"
- * @param {Room} room The newly created, fully populated room.
- * @example
- * matrixClient.on("Room", function(room){
- *   var roomId = room.roomId;
- * });
- */
-
-/**
- * Fires whenever a Room is removed. This will fire when you forget a room.
- * <strong>This event is experimental and may change.</strong>
- * @event module:client~MatrixClient#"deleteRoom"
- * @param {string} roomId The deleted room ID.
- * @example
- * matrixClient.on("deleteRoom", function(roomId){
- *   // update UI from getRooms()
- * });
- */
-
-/**
- * Fires whenever an incoming call arrives.
- * @event module:client~MatrixClient#"Call.incoming"
- * @param {module:webrtc/call~MatrixCall} call The incoming call.
- * @example
- * matrixClient.on("Call.incoming", function(call){
- *   call.answer(); // auto-answer
- * });
- */
-
-/**
- * Fires whenever the login session the JS SDK is using is no
- * longer valid and the user must log in again.
- * NB. This only fires when action is required from the user, not
- * when then login session can be renewed by using a refresh token.
- * @event module:client~MatrixClient#"Session.logged_out"
- * @example
- * matrixClient.on("Session.logged_out", function(errorObj){
- *   // show the login screen
- * });
- */
-
-/**
- * Fires when the JS SDK receives a M_CONSENT_NOT_GIVEN error in response
- * to a HTTP request.
- * @event module:client~MatrixClient#"no_consent"
- * @example
- * matrixClient.on("no_consent", function(message, contentUri) {
- *     console.info(message + ' Go to ' + contentUri);
- * });
- */
-
-/**
- * Fires when a device is marked as verified/unverified/blocked/unblocked by
- * {@link module:client~MatrixClient#setDeviceVerified|MatrixClient.setDeviceVerified} or
- * {@link module:client~MatrixClient#setDeviceBlocked|MatrixClient.setDeviceBlocked}.
- *
- * @event module:client~MatrixClient#"deviceVerificationChanged"
- * @param {string} userId the owner of the verified device
- * @param {string} deviceId the id of the verified device
- * @param {module:crypto/deviceinfo} deviceInfo updated device information
- */
-
-/**
- * Fires when the trust status of a user changes
- * If userId is the userId of the logged in user, this indicated a change
- * in the trust status of the cross-signing data on the account.
- *
- * The cross-signing API is currently UNSTABLE and may change without notice.
- *
- * @event module:client~MatrixClient#"userTrustStatusChanged"
- * @param {string} userId the userId of the user in question
- * @param {UserTrustLevel} trustLevel The new trust level of the user
- */
-
-/**
- * Fires when the user's cross-signing keys have changed or cross-signing
- * has been enabled/disabled. The client can use getStoredCrossSigningForUser
- * with the user ID of the logged in user to check if cross-signing is
- * enabled on the account. If enabled, it can test whether the current key
- * is trusted using with checkUserTrust with the user ID of the logged
- * in user. The checkOwnCrossSigningTrust function may be used to reconcile
- * the trust in the account key.
- *
- * The cross-signing API is currently UNSTABLE and may change without notice.
- *
- * @event module:client~MatrixClient#"crossSigning.keysChanged"
- */
-
-/**
- * Fires whenever new user-scoped account_data is added.
- * @event module:client~MatrixClient#"accountData"
- * @param {MatrixEvent} event The event describing the account_data just added
- * @param {MatrixEvent} event The previous account data, if known.
- * @example
- * matrixClient.on("accountData", function(event, oldEvent){
- *   myAccountData[event.type] = event.content;
- * });
- */
-
-/**
- * Fires whenever the stored devices for a user have changed
- * @event module:client~MatrixClient#"crypto.devicesUpdated"
- * @param {String[]} users A list of user IDs that were updated
- * @param {boolean} initialFetch If true, the store was empty (apart
- *     from our own device) and has been seeded.
- */
-
-/**
- * Fires whenever the stored devices for a user will be updated
- * @event module:client~MatrixClient#"crypto.willUpdateDevices"
- * @param {String[]} users A list of user IDs that will be updated
- * @param {boolean} initialFetch If true, the store is empty (apart
- *     from our own device) and is being seeded.
- */
-
-/**
- * Fires whenever the status of e2e key backup changes, as returned by getKeyBackupEnabled()
- * @event module:client~MatrixClient#"crypto.keyBackupStatus"
- * @param {boolean} enabled true if key backup has been enabled, otherwise false
- * @example
- * matrixClient.on("crypto.keyBackupStatus", function(enabled){
- *   if (enabled) {
- *     [...]
- *   }
- * });
- */
-
-/**
- * Fires when we want to suggest to the user that they restore their megolm keys
- * from backup or by cross-signing the device.
- *
- * @event module:client~MatrixClient#"crypto.suggestKeyRestore"
- */
-
-/**
- * Fires when a key verification is requested.
- * @event module:client~MatrixClient#"crypto.verification.request"
- * @param {object} data
- * @param {MatrixEvent} data.event the original verification request message
- * @param {Array} data.methods the verification methods that can be used
- * @param {Number} data.timeout the amount of milliseconds that should be waited
- *                 before cancelling the request automatically.
- * @param {Function} data.beginKeyVerification a function to call if a key
- *     verification should be performed.  The function takes one argument: the
- *     name of the key verification method (taken from data.methods) to use.
- * @param {Function} data.cancel a function to call if the key verification is
- *     rejected.
- */
-
-/**
- * Fires when a key verification is requested with an unknown method.
- * @event module:client~MatrixClient#"crypto.verification.request.unknown"
- * @param {string} userId the user ID who requested the key verification
- * @param {Function} cancel a function that will send a cancellation message to
- *     reject the key verification.
- */
-
-/**
- * Fires when a secret request has been cancelled.  If the client is prompting
- * the user to ask whether they want to share a secret, the prompt can be
- * dismissed.
- *
- * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
- *
- * @event module:client~MatrixClient#"crypto.secrets.requestCancelled"
- * @param {object} data
- * @param {string} data.user_id The user ID of the client that had requested the secret.
- * @param {string} data.device_id The device ID of the client that had requested the
- *     secret.
- * @param {string} data.request_id The ID of the original request.
- */
-
-/**
- * Fires when the client .well-known info is fetched.
- *
- * @event module:client~MatrixClient#"WellKnown.client"
- * @param {object} data The JSON object returned by the server
- */
diff --git a/src/content-helpers.ts b/src/content-helpers.ts
index 6fa4b684b5b..b66f0d10235 100644
--- a/src/content-helpers.ts
+++ b/src/content-helpers.ts
@@ -14,8 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/** @module ContentHelpers */
-
 import { isProvided, REFERENCE_RELATION } from "matrix-events-sdk";
 
 import { MBeaconEventContent, MBeaconInfoContent, MBeaconInfoEventContent } from "./@types/beacon";
@@ -37,9 +35,9 @@ import { IContent } from "./models/event";
 
 /**
  * Generates the content for a HTML Message event
- * @param {string} body the plaintext body of the message
- * @param {string} htmlBody the HTML representation of the message
- * @returns {{msgtype: string, format: string, body: string, formatted_body: string}}
+ * @param body - the plaintext body of the message
+ * @param htmlBody - the HTML representation of the message
+ * @returns
  */
 export function makeHtmlMessage(body: string, htmlBody: string): IContent {
     return {
@@ -52,9 +50,9 @@ export function makeHtmlMessage(body: string, htmlBody: string): IContent {
 
 /**
  * Generates the content for a HTML Notice event
- * @param {string} body the plaintext body of the notice
- * @param {string} htmlBody the HTML representation of the notice
- * @returns {{msgtype: string, format: string, body: string, formatted_body: string}}
+ * @param body - the plaintext body of the notice
+ * @param htmlBody - the HTML representation of the notice
+ * @returns
  */
 export function makeHtmlNotice(body: string, htmlBody: string): IContent {
     return {
@@ -67,9 +65,9 @@ export function makeHtmlNotice(body: string, htmlBody: string): IContent {
 
 /**
  * Generates the content for a HTML Emote event
- * @param {string} body the plaintext body of the emote
- * @param {string} htmlBody the HTML representation of the emote
- * @returns {{msgtype: string, format: string, body: string, formatted_body: string}}
+ * @param body - the plaintext body of the emote
+ * @param htmlBody - the HTML representation of the emote
+ * @returns
  */
 export function makeHtmlEmote(body: string, htmlBody: string): IContent {
     return {
@@ -82,8 +80,8 @@ export function makeHtmlEmote(body: string, htmlBody: string): IContent {
 
 /**
  * Generates the content for a Plaintext Message event
- * @param {string} body the plaintext body of the emote
- * @returns {{msgtype: string, body: string}}
+ * @param body - the plaintext body of the emote
+ * @returns
  */
 export function makeTextMessage(body: string): IContent {
     return {
@@ -94,8 +92,8 @@ export function makeTextMessage(body: string): IContent {
 
 /**
  * Generates the content for a Plaintext Notice event
- * @param {string} body the plaintext body of the notice
- * @returns {{msgtype: string, body: string}}
+ * @param body - the plaintext body of the notice
+ * @returns
  */
 export function makeNotice(body: string): IContent {
     return {
@@ -106,8 +104,8 @@ export function makeNotice(body: string): IContent {
 
 /**
  * Generates the content for a Plaintext Emote event
- * @param {string} body the plaintext body of the emote
- * @returns {{msgtype: string, body: string}}
+ * @param body - the plaintext body of the emote
+ * @returns
  */
 export function makeEmoteMessage(body: string): IContent {
     return {
@@ -139,11 +137,11 @@ export const getTextForLocationEvent = (
 
 /**
  * Generates the content for a Location event
- * @param uri a geo:// uri for the location
- * @param timestamp the timestamp when the location was correct (milliseconds since the UNIX epoch)
- * @param description the (optional) label for this location on the map
- * @param assetType the (optional) asset type of this location e.g. "m.self"
- * @param text optional. A text for the location
+ * @param uri - a geo:// uri for the location
+ * @param timestamp - the timestamp when the location was correct (milliseconds since the UNIX epoch)
+ * @param description - the (optional) label for this location on the map
+ * @param assetType - the (optional) asset type of this location e.g. "m.self"
+ * @param text - optional. A text for the location
  */
 export const makeLocationContent = (
     // this is first but optional
diff --git a/src/content-repo.ts b/src/content-repo.ts
index d6cf81f2ec6..9b6f6d37217 100644
--- a/src/content-repo.ts
+++ b/src/content-repo.ts
@@ -13,25 +13,22 @@ 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.
 */
-/**
- * @module content-repo
- */
 
 import * as utils from "./utils";
 
 /**
  * Get the HTTP URL for an MXC URI.
- * @param {string} baseUrl The base homeserver url which has a content repo.
- * @param {string} mxc The mxc:// URI.
- * @param {Number} width The desired width of the thumbnail.
- * @param {Number} height The desired height of the thumbnail.
- * @param {string} resizeMethod The thumbnail resize method to use, either
+ * @param baseUrl - The base homeserver url which has a content repo.
+ * @param mxc - The mxc:// URI.
+ * @param width - The desired width of the thumbnail.
+ * @param height - The desired height of the thumbnail.
+ * @param resizeMethod - The thumbnail resize method to use, either
  * "crop" or "scale".
- * @param {Boolean} allowDirectLinks If true, return any non-mxc URLs
+ * @param allowDirectLinks - If true, return any non-mxc URLs
  * directly. Fetching such URLs will leak information about the user to
  * anyone they share a room with. If false, will return the emptry string
  * for such URLs.
- * @return {string} The complete URL to the content.
+ * @returns The complete URL to the content.
  */
 export function getHttpUriForMxc(
     baseUrl: string,
diff --git a/src/crypto/CrossSigning.ts b/src/crypto/CrossSigning.ts
index 4035db04cf7..1ac9e214479 100644
--- a/src/crypto/CrossSigning.ts
+++ b/src/crypto/CrossSigning.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * Cross signing methods
- * @module crypto/CrossSigning
  */
 
 import { PkSigning } from "@matrix-org/olm";
@@ -67,12 +66,10 @@ export class CrossSigningInfo {
     /**
      * Information about a user's cross-signing keys
      *
-     * @class
-     *
-     * @param {string} userId the user that the information is about
-     * @param {object} callbacks Callbacks used to interact with the app
+     * @param userId - the user that the information is about
+     * @param callbacks - Callbacks used to interact with the app
      *     Requires getCrossSigningKey and saveCrossSigningKeys
-     * @param {object} cacheCallbacks Callbacks used to interact with the cache
+     * @param cacheCallbacks - Callbacks used to interact with the cache
      */
     public constructor(
         public readonly userId: string,
@@ -102,10 +99,10 @@ export class CrossSigningInfo {
     /**
      * Calls the app callback to ask for a private key
      *
-     * @param {string} type The key type ("master", "self_signing", or "user_signing")
-     * @param {string} expectedPubkey The matching public key or undefined to use
+     * @param type - The key type ("master", "self_signing", or "user_signing")
+     * @param expectedPubkey - The matching public key or undefined to use
      *     the stored public key for the given key type.
-     * @returns {Array} An array with [ public key, Olm.PkSigning ]
+     * @returns An array with [ public key, Olm.PkSigning ]
      */
     public async getCrossSigningKey(type: string, expectedPubkey?: string): Promise<[string, PkSigning]> {
         const shouldCache = ["master", "self_signing", "user_signing"].indexOf(type) >= 0;
@@ -165,8 +162,8 @@ export class CrossSigningInfo {
      * XXX: This could be static, be we often seem to have an instance when we
      * want to know this anyway...
      *
-     * @param {SecretStorage} secretStorage The secret store using account data
-     * @returns {object} map of key name to key info the secret is encrypted
+     * @param secretStorage - The secret store using account data
+     * @returns map of key name to key info the secret is encrypted
      *     with, or null if it is not present or not encrypted with a trusted
      *     key
      */
@@ -194,8 +191,8 @@ export class CrossSigningInfo {
      * typically called in conjunction with the creation of new cross-signing
      * keys.
      *
-     * @param {Map} keys The keys to store
-     * @param {SecretStorage} secretStorage The secret store using account data
+     * @param keys - The keys to store
+     * @param secretStorage - The secret store using account data
      */
     public static async storeInSecretStorage(
         keys: Map<string, Uint8Array>,
@@ -211,10 +208,10 @@ export class CrossSigningInfo {
      * Get private keys from secret storage created by some other device. This
      * also passes the private keys to the app-specific callback.
      *
-     * @param {string} type The type of key to get.  One of "master",
+     * @param type - The type of key to get.  One of "master",
      * "self_signing", or "user_signing".
-     * @param {SecretStorage} secretStorage The secret store using account data
-     * @return {Uint8Array} The private key
+     * @param secretStorage - The secret store using account data
+     * @returns The private key
      */
     public static async getFromSecretStorage(type: string, secretStorage: SecretStorage): Promise<Uint8Array | null> {
         const encodedKey = await secretStorage.get(`m.cross_signing.${type}`);
@@ -227,9 +224,9 @@ export class CrossSigningInfo {
     /**
      * Check whether the private keys exist in the local key cache.
      *
-     * @param {string} [type] The type of key to get. One of "master",
+     * @param type - The type of key to get. One of "master",
      * "self_signing", or "user_signing". Optional, will check all by default.
-     * @returns {boolean} True if all keys are stored in the local cache.
+     * @returns True if all keys are stored in the local cache.
      */
     public async isStoredInKeyCache(type?: string): Promise<boolean> {
         const cacheCallbacks = this.cacheCallbacks;
@@ -246,7 +243,7 @@ export class CrossSigningInfo {
     /**
      * Get cross-signing private keys from the local cache.
      *
-     * @returns {Map} A map from key type (string) to private key (Uint8Array)
+     * @returns A map from key type (string) to private key (Uint8Array)
      */
     public async getCrossSigningKeysFromCache(): Promise<Map<string, Uint8Array>> {
         const keys = new Map();
@@ -266,10 +263,10 @@ export class CrossSigningInfo {
      * Get the ID used to identify the user. This can also be used to test for
      * the existence of a given key type.
      *
-     * @param {string} type The type of key to get the ID of.  One of "master",
+     * @param type - The type of key to get the ID of.  One of "master",
      * "self_signing", or "user_signing".  Defaults to "master".
      *
-     * @return {string} the ID
+     * @returns the ID
      */
     public getId(type = "master"): string | null {
         if (!this.keys[type]) return null;
@@ -282,7 +279,7 @@ export class CrossSigningInfo {
      * will be held in this class, while the private keys are passed off to the
      * `saveCrossSigningKeys` application callback.
      *
-     * @param {CrossSigningLevel} level The key types to reset
+     * @param level - The key types to reset
      */
     public async resetKeys(level?: CrossSigningLevel): Promise<void> {
         if (!this.callbacks.saveCrossSigningKeys) {
@@ -502,9 +499,9 @@ export class CrossSigningInfo {
     /**
      * Check whether a given user is trusted.
      *
-     * @param {CrossSigningInfo} userCrossSigning Cross signing info for user
+     * @param userCrossSigning - Cross signing info for user
      *
-     * @returns {UserTrustLevel}
+     * @returns
      */
     public checkUserTrust(userCrossSigning: CrossSigningInfo): UserTrustLevel {
         // if we're checking our own key, then it's trusted if the master key
@@ -542,12 +539,12 @@ export class CrossSigningInfo {
     /**
      * Check whether a given device is trusted.
      *
-     * @param {CrossSigningInfo} userCrossSigning Cross signing info for user
-     * @param {module:crypto/deviceinfo} device The device to check
-     * @param {boolean} localTrust Whether the device is trusted locally
-     * @param {boolean} trustCrossSignedDevices Whether we trust cross signed devices
+     * @param userCrossSigning - Cross signing info for user
+     * @param device - The device to check
+     * @param localTrust - Whether the device is trusted locally
+     * @param trustCrossSignedDevices - Whether we trust cross signed devices
      *
-     * @returns {DeviceTrustLevel}
+     * @returns
      */
     public checkDeviceTrust(
         userCrossSigning: CrossSigningInfo,
@@ -580,7 +577,7 @@ export class CrossSigningInfo {
     }
 
     /**
-     * @returns {object} Cache callbacks
+     * @returns Cache callbacks
      */
     public getCacheCallbacks(): ICacheCallbacks {
         return this.cacheCallbacks;
@@ -621,21 +618,21 @@ export class UserTrustLevel {
     ) {}
 
     /**
-     * @returns {boolean} true if this user is verified via any means
+     * @returns true if this user is verified via any means
      */
     public isVerified(): boolean {
         return this.isCrossSigningVerified();
     }
 
     /**
-     * @returns {boolean} true if this user is verified via cross signing
+     * @returns true if this user is verified via cross signing
      */
     public isCrossSigningVerified(): boolean {
         return this.crossSigningVerified;
     }
 
     /**
-     * @returns {boolean} true if we ever verified this user before (at least for
+     * @returns true if we ever verified this user before (at least for
      * the history of verifications observed by this device).
      */
     public wasCrossSigningVerified(): boolean {
@@ -643,7 +640,7 @@ export class UserTrustLevel {
     }
 
     /**
-     * @returns {boolean} true if this user's key is trusted on first use
+     * @returns true if this user's key is trusted on first use
      */
     public isTofu(): boolean {
         return this.tofu;
@@ -675,7 +672,7 @@ export class DeviceTrustLevel {
     }
 
     /**
-     * @returns {boolean} true if this device is verified via any means
+     * @returns true if this device is verified via any means
      */
     public isVerified(): boolean {
         return Boolean(this.isLocallyVerified() || (
@@ -684,21 +681,21 @@ export class DeviceTrustLevel {
     }
 
     /**
-     * @returns {boolean} true if this device is verified via cross signing
+     * @returns true if this device is verified via cross signing
      */
     public isCrossSigningVerified(): boolean {
         return this.crossSigningVerified;
     }
 
     /**
-     * @returns {boolean} true if this device is verified locally
+     * @returns true if this device is verified locally
      */
     public isLocallyVerified(): boolean {
         return this.localVerified;
     }
 
     /**
-     * @returns {boolean} true if this device is trusted from a user's key
+     * @returns true if this device is trusted from a user's key
      * that is trusted on first use
      */
     public isTofu(): boolean {
@@ -757,9 +754,9 @@ export type KeysDuringVerification = [[string, PkSigning], [string, PkSigning],
 /**
  * Request cross-signing keys from another device during verification.
  *
- * @param {MatrixClient} baseApis base Matrix API interface
- * @param {string} userId The user ID being verified
- * @param {string} deviceId The device ID being verified
+ * @param baseApis - base Matrix API interface
+ * @param userId - The user ID being verified
+ * @param deviceId - The device ID being verified
  */
 export async function requestKeysDuringVerification(
     baseApis: MatrixClient,
diff --git a/src/crypto/DeviceList.ts b/src/crypto/DeviceList.ts
index da40a03f231..81dc5e18e68 100644
--- a/src/crypto/DeviceList.ts
+++ b/src/crypto/DeviceList.ts
@@ -15,8 +15,6 @@ limitations under the License.
 */
 
 /**
- * @module crypto/DeviceList
- *
  * Manages the list of other users' devices
  */
 
@@ -64,9 +62,6 @@ export type DeviceInfoMap = Record<string, Record<string, DeviceInfo>>;
 
 type EmittedEvents = CryptoEvent.WillUpdateDevices | CryptoEvent.DevicesUpdated | CryptoEvent.UserCrossSigningUpdated;
 
-/**
- * @alias module:crypto/DeviceList
- */
 export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHandlerMap> {
     private devices: { [userId: string]: { [deviceId: string]: IDevice } } = {};
 
@@ -163,11 +158,11 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * The actual save will be delayed by a short amount of time to
      * aggregate multiple writes to the database.
      *
-     * @param {number} delay Time in ms before which the save actually happens.
+     * @param delay - Time in ms before which the save actually happens.
      *     By default, the save is delayed for a short period in order to batch
      *     multiple writes, but this behaviour can be disabled by passing 0.
      *
-     * @return {Promise<boolean>} true if the data was saved, false if
+     * @returns true if the data was saved, false if
      *     it was not (eg. because no changes were pending). The promise
      *     will only resolve once the data is saved, so may take some time
      *     to resolve.
@@ -236,7 +231,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Gets the sync token last set with setSyncToken
      *
-     * @return {string} The sync token
+     * @returns The sync token
      */
     public getSyncToken(): string | null {
         return this.syncToken;
@@ -250,7 +245,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * those changed will not be synced from the server if a new client starts
      * up with that data.
      *
-     * @param {string} st The sync token
+     * @param st - The sync token
      */
     public setSyncToken(st: string | null): void {
         this.syncToken = st;
@@ -260,11 +255,10 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * Ensures up to date keys for a list of users are stored in the session store,
      * downloading and storing them if they're not (or if forceDownload is
      * true).
-     * @param {Array} userIds The users to fetch.
-     * @param {boolean} forceDownload Always download the keys even if cached.
+     * @param userIds - The users to fetch.
+     * @param forceDownload - Always download the keys even if cached.
      *
-     * @return {Promise} A promise which resolves to a map userId->deviceId->{@link
-     * module:crypto/deviceinfo|DeviceInfo}.
+     * @returns A promise which resolves to a map userId-\>deviceId-\>{@link DeviceInfo}.
      */
     public downloadKeys(userIds: string[], forceDownload: boolean): Promise<DeviceInfoMap> {
         const usersToDownload: string[] = [];
@@ -303,9 +297,9 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Get the stored device keys for a list of user ids
      *
-     * @param {string[]} userIds the list of users to list keys for.
+     * @param userIds - the list of users to list keys for.
      *
-     * @return {Object} userId->deviceId->{@link module:crypto/deviceinfo|DeviceInfo}.
+     * @returns userId-\>deviceId-\>{@link DeviceInfo}.
      */
     private getDevicesFromStore(userIds: string[]): DeviceInfoMap {
         const stored: DeviceInfoMap = {};
@@ -322,7 +316,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Returns a list of all user IDs the DeviceList knows about
      *
-     * @return {array} All known user IDs
+     * @returns All known user IDs
      */
     public getKnownUserIds(): string[] {
         return Object.keys(this.devices);
@@ -331,9 +325,9 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Get the stored device keys for a user id
      *
-     * @param {string} userId the user to list keys for.
+     * @param userId - the user to list keys for.
      *
-     * @return {module:crypto/deviceinfo[]|null} list of devices, or null if we haven't
+     * @returns list of devices, or null if we haven't
      * managed to get a list of devices for this user yet.
      */
     public getStoredDevicesForUser(userId: string): DeviceInfo[] | null {
@@ -353,9 +347,9 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Get the stored device data for a user, in raw object form
      *
-     * @param {string} userId the user to get data for
+     * @param userId - the user to get data for
      *
-     * @return {Object} deviceId->{object} devices, or undefined if
+     * @returns `deviceId->{object}` devices, or undefined if
      * there is no data for this user.
      */
     public getRawStoredDevicesForUser(userId: string): Record<string, IDevice> {
@@ -376,10 +370,8 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Get the stored keys for a single device
      *
-     * @param {string} userId
-     * @param {string} deviceId
      *
-     * @return {module:crypto/deviceinfo?} device, or undefined
+     * @returns device, or undefined
      * if we don't know about this device
      */
     public getStoredDevice(userId: string, deviceId: string): DeviceInfo | undefined {
@@ -393,10 +385,10 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Get a user ID by one of their device's curve25519 identity key
      *
-     * @param {string} algorithm  encryption algorithm
-     * @param {string} senderKey  curve25519 key to match
+     * @param algorithm -  encryption algorithm
+     * @param senderKey -  curve25519 key to match
      *
-     * @return {string} user ID
+     * @returns user ID
      */
     public getUserByIdentityKey(algorithm: string, senderKey: string): string | null {
         if (algorithm !== olmlib.OLM_ALGORITHM && algorithm !== olmlib.MEGOLM_ALGORITHM) {
@@ -410,10 +402,8 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Find a device by curve25519 identity key
      *
-     * @param {string} algorithm  encryption algorithm
-     * @param {string} senderKey  curve25519 key to match
-     *
-     * @return {module:crypto/deviceinfo?}
+     * @param algorithm -  encryption algorithm
+     * @param senderKey -  curve25519 key to match
      */
     public getDeviceByIdentityKey(algorithm: string, senderKey: string): DeviceInfo | null {
         const userId = this.getUserByIdentityKey(algorithm, senderKey);
@@ -453,8 +443,8 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * Replaces the list of devices for a user with the given device list
      *
-     * @param {string} userId The user ID
-     * @param {Object} devices New device info for user
+     * @param userId - The user ID
+     * @param devices - New device info for user
      */
     public storeDevicesForUser(userId: string, devices: Record<string, IDevice>): void {
         this.setRawStoredDevicesForUser(userId, devices);
@@ -468,7 +458,6 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * will download the device list for the user, and that subsequent calls to
      * invalidateUserDeviceList will trigger more updates.
      *
-     * @param {String} userId
      */
     public startTrackingDeviceList(userId: string): void {
         // sanity-check the userId. This is mostly paranoia, but if synapse
@@ -497,7 +486,6 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * complete; it will just mean that we don't think that we have an up-to-date
      * list for future calls to downloadKeys.
      *
-     * @param {String} userId
      */
     public stopTrackingDeviceList(userId: string): void {
         if (this.deviceTrackingStatus[userId]) {
@@ -532,7 +520,6 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * This doesn't actually set off an update, so that several users can be
      * batched together. Call refreshOutdatedDeviceLists() for that.
      *
-     * @param {String} userId
      */
     public invalidateUserDeviceList(userId: string): void {
         if (this.deviceTrackingStatus[userId]) {
@@ -548,7 +535,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
     /**
      * If we have users who have outdated device lists, start key downloads for them
      *
-     * @returns {Promise} which completes when the download completes; normally there
+     * @returns which completes when the download completes; normally there
      *    is no need to wait for this (it's mostly for the unit tests).
      */
     public refreshOutdatedDeviceLists(): Promise<void> {
@@ -569,9 +556,9 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * Set the stored device data for a user, in raw object form
      * Used only by internal class DeviceListUpdateSerialiser
      *
-     * @param {string} userId the user to get data for
+     * @param userId - the user to get data for
      *
-     * @param {Object} devices deviceId->{object} the new devices
+     * @param devices - `deviceId->{object}` the new devices
      */
     public setRawStoredDevicesForUser(userId: string, devices: Record<string, IDevice>): void {
         // remove old devices from userByIdentityKey
@@ -602,9 +589,9 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * device list tracking status for them, and the
      * keyDownloadsInProgressByUser map for them.
      *
-     * @param {String[]} users  list of userIds
+     * @param users -  list of userIds
      *
-     * @return {Promise} resolves when all the users listed have
+     * @returns resolves when all the users listed have
      *     been updated. rejects if there was a problem updating any of the
      *     users.
      */
@@ -689,9 +676,9 @@ class DeviceListUpdateSerialiser {
     private syncToken?: string; // The sync token we send with the requests
 
     /*
-     * @param {object} baseApis Base API object
-     * @param {object} olmDevice The Olm Device
-     * @param {object} deviceList The device list object, the device list to be updated
+     * @param baseApis - Base API object
+     * @param olmDevice - The Olm Device
+     * @param deviceList - The device list object, the device list to be updated
      */
     public constructor(
         private readonly baseApis: MatrixClient,
@@ -702,12 +689,12 @@ class DeviceListUpdateSerialiser {
     /**
      * Make a key query request for the given users
      *
-     * @param {String[]} users list of user ids
+     * @param users - list of user ids
      *
-     * @param {String} syncToken sync token to pass in the query request, to
+     * @param syncToken - sync token to pass in the query request, to
      *     help the HS give the most recent results
      *
-     * @return {Promise} resolves when all the users listed have
+     * @returns resolves when all the users listed have
      *     been updated. rejects if there was a problem updating any of the
      *     users.
      */
diff --git a/src/crypto/EncryptionSetup.ts b/src/crypto/EncryptionSetup.ts
index a46afdc4df6..41310252bfd 100644
--- a/src/crypto/EncryptionSetup.ts
+++ b/src/crypto/EncryptionSetup.ts
@@ -58,8 +58,8 @@ export class EncryptionSetupBuilder {
     private sessionBackupPrivateKey?: Uint8Array;
 
     /**
-     * @param {Object.<String, MatrixEvent>} accountData pre-existing account data, will only be read, not written.
-     * @param {CryptoCallbacks} delegateCryptoCallbacks crypto callbacks to delegate to if the key isn't in cache yet
+     * @param accountData - pre-existing account data, will only be read, not written.
+     * @param delegateCryptoCallbacks - crypto callbacks to delegate to if the key isn't in cache yet
      */
     public constructor(accountData: Record<string, MatrixEvent>, delegateCryptoCallbacks?: ICryptoCallbacks) {
         this.accountDataClientAdapter = new AccountDataClientAdapter(accountData);
@@ -70,13 +70,13 @@ export class EncryptionSetupBuilder {
     /**
      * Adds new cross-signing public keys
      *
-     * @param {function} authUpload Function called to await an interactive auth
+     * @param authUpload - Function called to await an interactive auth
      * flow when uploading device signing keys.
      * Args:
-     *     {function} A function that makes the request requiring auth. Receives
+     *     A function that makes the request requiring auth. Receives
      *     the auth data as an object. Can be called multiple times, first with
      *     an empty authDict, to obtain the flows.
-     * @param {Object} keys the new keys
+     * @param keys - the new keys
      */
     public addCrossSigningKeys(authUpload: ICrossSigningKeys["authUpload"], keys: ICrossSigningKeys["keys"]): void {
         this.crossSigningKeys = { authUpload, keys };
@@ -88,7 +88,7 @@ export class EncryptionSetupBuilder {
      * Used either to create a new key backup, or add signatures
      * from the new MSK.
      *
-     * @param {Object} keyBackupInfo as received from/sent to the server
+     * @param keyBackupInfo - as received from/sent to the server
      */
     public addSessionBackup(keyBackupInfo: IKeyBackupInfo): void {
         this.keyBackupInfo = keyBackupInfo;
@@ -99,7 +99,6 @@ export class EncryptionSetupBuilder {
      *
      * Used after fixing the format of the key
      *
-     * @param {Uint8Array} privateKey
      */
     public addSessionBackupPrivateKeyToCache(privateKey: Uint8Array): void {
         this.sessionBackupPrivateKey = privateKey;
@@ -109,9 +108,6 @@ export class EncryptionSetupBuilder {
      * Add signatures from a given user and device/x-sign key
      * Used to sign the new cross-signing key with the device key
      *
-     * @param {String} userId
-     * @param {String} deviceId
-     * @param {Object} signature
      */
     public addKeySignature(userId: string, deviceId: string, signature: ISignedKey): void {
         if (!this.keySignatures) {
@@ -122,18 +118,12 @@ export class EncryptionSetupBuilder {
         userSignatures[deviceId] = signature;
     }
 
-    /**
-     * @param {String} type
-     * @param {Object} content
-     * @return {Promise}
-     */
     public async setAccountData(type: string, content: object): Promise<void> {
         await this.accountDataClientAdapter.setAccountData(type, content);
     }
 
     /**
      * builds the operation containing all the parts that have been added to the builder
-     * @return {EncryptionSetupOperation}
      */
     public buildOperation(): EncryptionSetupOperation {
         const accountData = this.accountDataClientAdapter.values;
@@ -150,9 +140,6 @@ export class EncryptionSetupBuilder {
      *
      * This does not yet store the operation in a way that it can be restored,
      * but that is the idea in the future.
-     *
-     * @param  {Crypto} crypto
-     * @return {Promise}
      */
     public async persist(crypto: Crypto): Promise<void> {
         // store private keys in cache
@@ -187,10 +174,6 @@ export class EncryptionSetupBuilder {
  */
 export class EncryptionSetupOperation {
     /**
-     * @param  {Map<String, Object>} accountData
-     * @param  {Object} crossSigningKeys
-     * @param  {Object} keyBackupInfo
-     * @param  {Object} keySignatures
      */
     public constructor(
         private readonly accountData: Map<string, object>,
@@ -201,7 +184,6 @@ export class EncryptionSetupOperation {
 
     /**
      * Runs the (remaining part of, in the future) operation by sending requests to the server.
-     * @param {Crypto} crypto
      */
     public async apply(crypto: Crypto): Promise<void> {
         const baseApis = crypto.baseApis;
@@ -270,23 +252,21 @@ class AccountDataClientAdapter
     public readonly values = new Map<string, MatrixEvent>();
 
     /**
-     * @param  {Object.<String, MatrixEvent>} existingValues existing account data
+     * @param existingValues - existing account data
      */
     public constructor(private readonly existingValues: Record<string, MatrixEvent>) {
         super();
     }
 
     /**
-     * @param  {String} type
-     * @return {Promise<Object>} the content of the account data
+     * @returns the content of the account data
      */
     public getAccountDataFromServer<T extends {[k: string]: any}>(type: string): Promise<T> {
         return Promise.resolve(this.getAccountData(type) as T);
     }
 
     /**
-     * @param  {String} type
-     * @return {Object} the content of the account data
+     * @returns the content of the account data
      */
     public getAccountData(type: string): IContent | null {
         const modifiedValue = this.values.get(type);
@@ -300,11 +280,6 @@ class AccountDataClientAdapter
         return null;
     }
 
-    /**
-     * @param {String} type
-     * @param {Object} content
-     * @return {Promise}
-     */
     public setAccountData(type: string, content: any): Promise<{}> {
         const lastEvent = this.values.get(type);
         this.values.set(type, content);
diff --git a/src/crypto/OlmDevice.ts b/src/crypto/OlmDevice.ts
index 13463ef115c..d7d62099d82 100644
--- a/src/crypto/OlmDevice.ts
+++ b/src/crypto/OlmDevice.ts
@@ -53,43 +53,22 @@ function checkPayloadLength(payloadString: string): void {
     }
 }
 
-/**
- * The type of object we use for importing and exporting megolm session data.
- *
- * @typedef {Object} module:crypto/OlmDevice.MegolmSessionData
- * @property {String} sender_key  Sender's Curve25519 device key
- * @property {String[]} forwarding_curve25519_key_chain Devices which forwarded
- *     this session to us (normally empty).
- * @property {Object<string, string>} sender_claimed_keys Other keys the sender claims.
- * @property {String} room_id     Room this session is used in
- * @property {String} session_id  Unique id for the session
- * @property {String} session_key Base64'ed key data
- */
-
 interface IInitOpts {
     fromExportedDevice?: IExportedDevice;
     pickleKey?: string;
 }
 
-/**
- * data stored in the session store about an inbound group session
- *
- * @typedef {Object} InboundGroupSessionData
- * @property {string} room_id
- * @property {string} session   pickled Olm.InboundGroupSession
- * @property {Object<string, string>} keysClaimed
- * @property {Array<string>} forwardingCurve25519KeyChain  Devices involved in forwarding
- *     this session to us (normally empty).
- * @property {boolean=} untrusted whether this session is untrusted.
- * @property {boolean=} sharedHistory whether this session exists during the room being set to shared history.
- */
-
+/** data stored in the session store about an inbound group session */
 export interface InboundGroupSessionData {
     room_id: string; // eslint-disable-line camelcase
+    /** pickled Olm.InboundGroupSession */
     session: string;
     keysClaimed: Record<string, string>;
+    /** Devices involved in forwarding this session to us (normally empty). */
     forwardingCurve25519KeyChain: string[];
+    /** whether this session is untrusted. */
     untrusted?: boolean;
+    /** whether this session exists during the room being set to shared history. */
     sharedHistory?: boolean;
 }
 
@@ -134,20 +113,13 @@ type OneTimeKeys = { curve25519: { [keyId: string]: string } };
  * OlmAccount and a number of OlmSessions.
  *
  * Accounts and sessions are kept pickled in the cryptoStore.
- *
- * @constructor
- * @alias module:crypto/OlmDevice
- *
- * @param {Object} cryptoStore A store for crypto data
- *
- * @property {string} deviceCurve25519Key   Curve25519 key for the account
- * @property {string} deviceEd25519Key      Ed25519 key for the account
  */
 export class OlmDevice {
     public pickleKey = "DEFAULT_KEY"; // set by consumers
 
-    // don't know these until we load the account from storage in init()
+    /** Curve25519 key for the account, unknown until we load the account from storage in init() */
     public deviceCurve25519Key: string | null = null;
+    /** Ed25519 key for the account, unknown until we load the account from storage in init() */
     public deviceEd25519Key: string | null = null;
     private maxOneTimeKeys: number | null = null;
 
@@ -184,7 +156,7 @@ export class OlmDevice {
     }
 
     /**
-     * @return {array} The version of Olm.
+     * @returns The version of Olm.
      */
     public static getOlmVersion(): [number, number, number] {
         return global.Olm.get_library_version();
@@ -202,12 +174,11 @@ export class OlmDevice {
      *
      * Reads the device keys from the OlmAccount object.
      *
-     * @param {object} opts
-     * @param {object} opts.fromExportedDevice (Optional) data from exported device
+     * @param fromExportedDevice - (Optional) data from exported device
      *     that must be re-created.
      *     If present, opts.pickleKey is ignored
      *     (exported data already provides a pickle key)
-     * @param {object} opts.pickleKey (Optional) pickle key to set instead of default one
+     * @param pickleKey - (Optional) pickle key to set instead of default one
      */
     public async init({ pickleKey, fromExportedDevice }: IInitOpts = {}): Promise<void> {
         let e2eKeys;
@@ -245,9 +216,9 @@ export class OlmDevice {
      * Note that for now only the “account” and “sessions” stores are populated;
      * Other stores will be as with a new device.
      *
-     * @param {IExportedDevice} exportedData Data exported from another device
+     * @param exportedData - Data exported from another device
      *     through the “export” method.
-     * @param {Olm.Account} account an olm account to initialize
+     * @param account - an olm account to initialize
      */
     private async initialiseFromExportedDevice(exportedData: IExportedDevice, account: Account): Promise<void> {
         await this.cryptoStore.doTxn(
@@ -305,9 +276,8 @@ export class OlmDevice {
      * This function requires a live transaction object from cryptoStore.doTxn()
      * and therefore may only be called in a doTxn() callback.
      *
-     * @param {*} txn Opaque transaction object from cryptoStore.doTxn()
-     * @param {function} func
-     * @private
+     * @param txn - Opaque transaction object from cryptoStore.doTxn()
+     * @internal
      */
     private getAccount(txn: unknown, func: (account: Account) => void): void {
         this.cryptoStore.getAccount(txn, (pickledAccount: string | null) => {
@@ -326,9 +296,9 @@ export class OlmDevice {
      * This function requires a live transaction object from cryptoStore.doTxn()
      * and therefore may only be called in a doTxn() callback.
      *
-     * @param {*} txn Opaque transaction object from cryptoStore.doTxn()
-     * @param {object} Olm.Account object
-     * @private
+     * @param txn - Opaque transaction object from cryptoStore.doTxn()
+     * @param Olm.Account object
+     * @internal
      */
     private storeAccount(txn: unknown, account: Account): void {
         this.cryptoStore.storeAccount(txn, account.pickle(this.pickleKey));
@@ -338,7 +308,7 @@ export class OlmDevice {
      * Export data for re-creating the Olm device later.
      * TODO export data other than just account and (P2P) sessions.
      *
-     * @return {Promise<object>} The exported data
+     * @returns The exported data
      */
     public async export(): Promise<IExportedDevice> {
         const result: Partial<IExportedDevice> = {
@@ -373,11 +343,8 @@ export class OlmDevice {
      * function and will be freed as soon the callback returns. It is *not*
      * usable for the rest of the lifetime of the transaction.
      *
-     * @param {string} deviceKey
-     * @param {string} sessionId
-     * @param {*} txn Opaque transaction object from cryptoStore.doTxn()
-     * @param {function} func
-     * @private
+     * @param txn - Opaque transaction object from cryptoStore.doTxn()
+     * @internal
      */
     private getSession(
         deviceKey: string,
@@ -397,9 +364,7 @@ export class OlmDevice {
      * function with it. The session object is destroyed once the function
      * returns.
      *
-     * @param {object} sessionInfo
-     * @param {function} func
-     * @private
+     * @internal
      */
     private unpickleSession(
         sessionInfo: ISessionInfo,
@@ -419,10 +384,9 @@ export class OlmDevice {
     /**
      * store our OlmSession in the session store
      *
-     * @param {string} deviceKey
-     * @param {object} sessionInfo {session: OlmSession, lastReceivedMessageTs: int}
-     * @param {*} txn Opaque transaction object from cryptoStore.doTxn()
-     * @private
+     * @param sessionInfo - `{session: OlmSession, lastReceivedMessageTs: int}`
+     * @param txn - Opaque transaction object from cryptoStore.doTxn()
+     * @internal
      */
     private saveSession(deviceKey: string, sessionInfo: IUnpickledSessionInfo, txn: unknown): void {
         const sessionId = sessionInfo.session.session_id();
@@ -435,9 +399,8 @@ export class OlmDevice {
     /**
      * get an OlmUtility and call the given function
      *
-     * @param {function} func
-     * @return {object} result of func
-     * @private
+     * @returns result of func
+     * @internal
      */
     private getUtility<T>(func: (utility: Utility) => T): T {
         const utility = new global.Olm.Utility();
@@ -451,8 +414,8 @@ export class OlmDevice {
     /**
      * Signs a message with the ed25519 key for this account.
      *
-     * @param {string} message  message to be signed
-     * @return {Promise<string>} base64-encoded signature
+     * @param message -  message to be signed
+     * @returns base64-encoded signature
      */
     public async sign(message: string): Promise<string> {
         let result: string;
@@ -469,7 +432,7 @@ export class OlmDevice {
     /**
      * Get the current (unused, unpublished) one-time keys for this account.
      *
-     * @return {object} one time keys; an object with the single property
+     * @returns one time keys; an object with the single property
      * <tt>curve25519</tt>, which is itself an object mapping key id to Curve25519
      * key.
      */
@@ -490,7 +453,7 @@ export class OlmDevice {
     /**
      * Get the maximum number of one-time keys we can store.
      *
-     * @return {number} number of keys
+     * @returns number of keys
      */
     public maxNumberOfOneTimeKeys(): number {
         return this.maxOneTimeKeys ?? -1;
@@ -514,8 +477,8 @@ export class OlmDevice {
     /**
      * Generate some new one-time keys
      *
-     * @param {number} numKeys number of keys to generate
-     * @return {Promise} Resolved once the account is saved back having generated the keys
+     * @param numKeys - number of keys to generate
+     * @returns Resolved once the account is saved back having generated the keys
      */
     public generateOneTimeKeys(numKeys: number): Promise<void> {
         return this.cryptoStore.doTxn(
@@ -532,7 +495,7 @@ export class OlmDevice {
     /**
      * Generate a new fallback keys
      *
-     * @return {Promise} Resolved once the account is saved back having generated the key
+     * @returns Resolved once the account is saved back having generated the key
      */
     public async generateFallbackKey(): Promise<void> {
         await this.cryptoStore.doTxn(
@@ -576,9 +539,9 @@ export class OlmDevice {
      *
      * The new session will be stored in the cryptoStore.
      *
-     * @param {string} theirIdentityKey remote user's Curve25519 identity key
-     * @param {string} theirOneTimeKey  remote user's one-time Curve25519 key
-     * @return {string} sessionId for the outbound session.
+     * @param theirIdentityKey - remote user's Curve25519 identity key
+     * @param theirOneTimeKey -  remote user's one-time Curve25519 key
+     * @returns sessionId for the outbound session.
      */
     public async createOutboundSession(theirIdentityKey: string, theirOneTimeKey: string): Promise<string> {
         let newSessionId: string;
@@ -615,15 +578,14 @@ export class OlmDevice {
     /**
      * Generate a new inbound session, given an incoming message
      *
-     * @param {string} theirDeviceIdentityKey remote user's Curve25519 identity key
-     * @param {number} messageType  messageType field from the received message (must be 0)
-     * @param {string} ciphertext base64-encoded body from the received message
+     * @param theirDeviceIdentityKey - remote user's Curve25519 identity key
+     * @param messageType -  messageType field from the received message (must be 0)
+     * @param ciphertext - base64-encoded body from the received message
      *
-     * @return {{payload: string, session_id: string}} decrypted payload, and
+     * @returns decrypted payload, and
      *     session id of new session
      *
-     * @raises {Error} if the received message was not valid (for instance, it
-     *     didn't use a valid one-time key).
+     * @throws Error if the received message was not valid (for instance, it didn't use a valid one-time key).
      */
     public async createInboundSession(
         theirDeviceIdentityKey: string,
@@ -676,9 +638,9 @@ export class OlmDevice {
     /**
      * Get a list of known session IDs for the given device
      *
-     * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
+     * @param theirDeviceIdentityKey - Curve25519 identity key for the
      *     remote device
-     * @return {Promise<string[]>}  a list of known session ids for the device
+     * @returns  a list of known session ids for the device
      */
     public async getSessionIdsForDevice(theirDeviceIdentityKey: string): Promise<string[]> {
         const log = logger.withPrefix("[getSessionIdsForDevice]");
@@ -711,13 +673,13 @@ export class OlmDevice {
     /**
      * Get the right olm session id for encrypting messages to the given identity key
      *
-     * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
+     * @param theirDeviceIdentityKey - Curve25519 identity key for the
      *     remote device
-     * @param {boolean} nowait Don't wait for an in-progress session to complete.
+     * @param nowait - Don't wait for an in-progress session to complete.
      *     This should only be set to true of the calling function is the function
      *     that marked the session as being in-progress.
-     * @param {PrefixedLogger} [log] A possibly customised log
-     * @return {Promise<?string>}  session id, or null if no established session
+     * @param log - A possibly customised log
+     * @returns  session id, or null if no established session
      */
     public async getSessionIdForDevice(
         theirDeviceIdentityKey: string,
@@ -759,12 +721,11 @@ export class OlmDevice {
      * the keys 'hasReceivedMessage' (true if the session has received an incoming
      * message and is therefore past the pre-key stage), and 'sessionId'.
      *
-     * @param {string} deviceIdentityKey Curve25519 identity key for the device
-     * @param {boolean} nowait Don't wait for an in-progress session to complete.
+     * @param deviceIdentityKey - Curve25519 identity key for the device
+     * @param nowait - Don't wait for an in-progress session to complete.
      *     This should only be set to true of the calling function is the function
      *     that marked the session as being in-progress.
-     * @param {Logger} [log] A possibly customised log
-     * @return {Array.<{sessionId: string, hasReceivedMessage: boolean}>}
+     * @param log - A possibly customised log
      */
     public async getSessionInfoForDevice(
         deviceIdentityKey: string,
@@ -813,12 +774,12 @@ export class OlmDevice {
     /**
      * Encrypt an outgoing message using an existing session
      *
-     * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
+     * @param theirDeviceIdentityKey - Curve25519 identity key for the
      *     remote device
-     * @param {string} sessionId  the id of the active session
-     * @param {string} payloadString  payload to be encrypted and sent
+     * @param sessionId -  the id of the active session
+     * @param payloadString -  payload to be encrypted and sent
      *
-     * @return {Promise<string>} ciphertext
+     * @returns ciphertext
      */
     public async encryptMessage(
         theirDeviceIdentityKey: string,
@@ -849,13 +810,13 @@ export class OlmDevice {
     /**
      * Decrypt an incoming message using an existing session
      *
-     * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
+     * @param theirDeviceIdentityKey - Curve25519 identity key for the
      *     remote device
-     * @param {string} sessionId  the id of the active session
-     * @param {number} messageType  messageType field from the received message
-     * @param {string} ciphertext base64-encoded body from the received message
+     * @param sessionId -  the id of the active session
+     * @param messageType -  messageType field from the received message
+     * @param ciphertext - base64-encoded body from the received message
      *
-     * @return {Promise<string>} decrypted payload.
+     * @returns decrypted payload.
      */
     public async decryptMessage(
         theirDeviceIdentityKey: string,
@@ -886,13 +847,13 @@ export class OlmDevice {
     /**
      * Determine if an incoming messages is a prekey message matching an existing session
      *
-     * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
+     * @param theirDeviceIdentityKey - Curve25519 identity key for the
      *     remote device
-     * @param {string} sessionId  the id of the active session
-     * @param {number} messageType  messageType field from the received message
-     * @param {string} ciphertext base64-encoded body from the received message
+     * @param sessionId -  the id of the active session
+     * @param messageType -  messageType field from the received message
+     * @param ciphertext - base64-encoded body from the received message
      *
-     * @return {Promise<boolean>} true if the received message is a prekey message which matches
+     * @returns true if the received message is a prekey message which matches
      *    the given session.
      */
     public async matchesSession(
@@ -937,8 +898,7 @@ export class OlmDevice {
     /**
      * store an OutboundGroupSession in outboundGroupSessionStore
      *
-     * @param {Olm.OutboundGroupSession} session
-     * @private
+     * @internal
      */
     private saveOutboundGroupSession(session: OutboundGroupSession): void {
         this.outboundGroupSessionStore[session.session_id()] = session.pickle(this.pickleKey);
@@ -948,10 +908,8 @@ export class OlmDevice {
      * extract an OutboundGroupSession from outboundGroupSessionStore and call the
      * given function
      *
-     * @param {string} sessionId
-     * @param {function} func
-     * @return {object} result of func
-     * @private
+     * @returns result of func
+     * @internal
      */
     private getOutboundGroupSession<T>(sessionId: string, func: (session: OutboundGroupSession) => T): T {
         const pickled = this.outboundGroupSessionStore[sessionId];
@@ -971,7 +929,7 @@ export class OlmDevice {
     /**
      * Generate a new outbound group session
      *
-     * @return {string} sessionId for the outbound session.
+     * @returns sessionId for the outbound session.
      */
     public createOutboundGroupSession(): string {
         const session = new global.Olm.OutboundGroupSession();
@@ -987,10 +945,10 @@ export class OlmDevice {
     /**
      * Encrypt an outgoing message with an outbound group session
      *
-     * @param {string} sessionId  the id of the outboundgroupsession
-     * @param {string} payloadString  payload to be encrypted and sent
+     * @param sessionId -  the id of the outboundgroupsession
+     * @param payloadString -  payload to be encrypted and sent
      *
-     * @return {string} ciphertext
+     * @returns ciphertext
      */
     public encryptGroupMessage(sessionId: string, payloadString: string): string {
         logger.log(`encrypting msg with megolm session ${sessionId}`);
@@ -1007,9 +965,9 @@ export class OlmDevice {
     /**
      * Get the session keys for an outbound group session
      *
-     * @param {string} sessionId  the id of the outbound group session
+     * @param sessionId -  the id of the outbound group session
      *
-     * @return {{chain_index: number, key: string}} current chain index, and
+     * @returns current chain index, and
      *     base64-encoded secret key.
      */
     public getOutboundGroupSessionKey(sessionId: string): IOutboundGroupSessionKey {
@@ -1028,9 +986,9 @@ export class OlmDevice {
      * Unpickle a session from a sessionData object and invoke the given function.
      * The session is valid only until func returns.
      *
-     * @param {Object} sessionData Object describing the session.
-     * @param {function(Olm.InboundGroupSession)} func Invoked with the unpickled session
-     * @return {*} result of func
+     * @param sessionData - Object describing the session.
+     * @param func - Invoked with the unpickled session
+     * @returns result of func
      */
     private unpickleInboundGroupSession<T>(
         sessionData: InboundGroupSessionData,
@@ -1048,15 +1006,12 @@ export class OlmDevice {
     /**
      * extract an InboundGroupSession from the crypto store and call the given function
      *
-     * @param {string} roomId The room ID to extract the session for, or null to fetch
+     * @param roomId - The room ID to extract the session for, or null to fetch
      *     sessions for any room.
-     * @param {string} senderKey
-     * @param {string} sessionId
-     * @param {*} txn Opaque transaction object from cryptoStore.doTxn()
-     * @param {function(Olm.InboundGroupSession, InboundGroupSessionData)} func
-     *   function to call.
+     * @param txn - Opaque transaction object from cryptoStore.doTxn()
+     * @param func - function to call.
      *
-     * @private
+     * @internal
      */
     private getInboundGroupSession(
         roomId: string,
@@ -1095,16 +1050,16 @@ export class OlmDevice {
     /**
      * Add an inbound group session to the session store
      *
-     * @param {string} roomId     room in which this session will be used
-     * @param {string} senderKey  base64-encoded curve25519 key of the sender
-     * @param {Array<string>} forwardingCurve25519KeyChain  Devices involved in forwarding
+     * @param roomId -     room in which this session will be used
+     * @param senderKey -  base64-encoded curve25519 key of the sender
+     * @param forwardingCurve25519KeyChain -  Devices involved in forwarding
      *     this session to us.
-     * @param {string} sessionId  session identifier
-     * @param {string} sessionKey base64-encoded secret key
-     * @param {Object<string, string>} keysClaimed Other keys the sender claims.
-     * @param {boolean} exportFormat true if the megolm keys are in export format
+     * @param sessionId -  session identifier
+     * @param sessionKey - base64-encoded secret key
+     * @param keysClaimed - Other keys the sender claims.
+     * @param exportFormat - true if the megolm keys are in export format
      *    (ie, they lack an ed25519 signature)
-     * @param {Object} [extraSessionData={}] any other data to be include with the session
+     * @param extraSessionData - any other data to be include with the session
      */
     public async addInboundGroupSession(
         roomId: string,
@@ -1216,11 +1171,11 @@ export class OlmDevice {
     /**
      * Record in the data store why an inbound group session was withheld.
      *
-     * @param {string} roomId     room that the session belongs to
-     * @param {string} senderKey  base64-encoded curve25519 key of the sender
-     * @param {string} sessionId  session identifier
-     * @param {string} code       reason code
-     * @param {string} reason     human-readable version of `code`
+     * @param roomId -     room that the session belongs to
+     * @param senderKey -  base64-encoded curve25519 key of the sender
+     * @param sessionId -  session identifier
+     * @param code -       reason code
+     * @param reason -     human-readable version of `code`
      */
     public async addInboundGroupSessionWithheld(
         roomId: string,
@@ -1248,18 +1203,14 @@ export class OlmDevice {
     /**
      * Decrypt a received message with an inbound group session
      *
-     * @param {string} roomId    room in which the message was received
-     * @param {string} senderKey base64-encoded curve25519 key of the sender
-     * @param {string} sessionId session identifier
-     * @param {string} body      base64-encoded body of the encrypted message
-     * @param {string} eventId   ID of the event being decrypted
-     * @param {Number} timestamp timestamp of the event being decrypted
-     *
-     * @return {null} the sessionId is unknown
+     * @param roomId -    room in which the message was received
+     * @param senderKey - base64-encoded curve25519 key of the sender
+     * @param sessionId - session identifier
+     * @param body -      base64-encoded body of the encrypted message
+     * @param eventId -   ID of the event being decrypted
+     * @param timestamp - timestamp of the event being decrypted
      *
-     * @return {Promise<{result: string, senderKey: string,
-     *    forwardingCurve25519KeyChain: Array<string>,
-     *    keysClaimed: Object<string, string>}>}
+     * @returns null if the sessionId is unknown
      */
     public async decryptGroupMessage(
         roomId: string,
@@ -1375,11 +1326,11 @@ export class OlmDevice {
     /**
      * Determine if we have the keys for a given megolm session
      *
-     * @param {string} roomId    room in which the message was received
-     * @param {string} senderKey base64-encoded curve25519 key of the sender
-     * @param {string} sessionId session identifier
+     * @param roomId -    room in which the message was received
+     * @param senderKey - base64-encoded curve25519 key of the sender
+     * @param sessionId - session identifier
      *
-     * @returns {Promise<boolean>} true if we have the keys to this session
+     * @returns true if we have the keys to this session
      */
     public async hasInboundSessionKeys(roomId: string, senderKey: string, sessionId: string): Promise<boolean> {
         let result: boolean;
@@ -1418,16 +1369,13 @@ export class OlmDevice {
     /**
      * Extract the keys to a given megolm session, for sharing
      *
-     * @param {string} roomId    room in which the message was received
-     * @param {string} senderKey base64-encoded curve25519 key of the sender
-     * @param {string} sessionId session identifier
-     * @param {number} chainIndex The chain index at which to export the session.
+     * @param roomId -    room in which the message was received
+     * @param senderKey - base64-encoded curve25519 key of the sender
+     * @param sessionId - session identifier
+     * @param chainIndex - The chain index at which to export the session.
      *     If omitted, export at the first index we know about.
      *
-     * @returns {Promise<{chain_index: number, key: string,
-     *        forwarding_curve25519_key_chain: Array<string>,
-     *        sender_claimed_ed25519_key: string
-     *    }>}
+     * @returns
      *    details of the session key. The key is a base64-encoded megolm key in
      *    export format.
      *
@@ -1492,10 +1440,10 @@ export class OlmDevice {
     /**
      * Export an inbound group session
      *
-     * @param {string} senderKey base64-encoded curve25519 key of the sender
-     * @param {string} sessionId session identifier
-     * @param {ISessionInfo} sessionData The session object from the store
-     * @return {module:crypto/OlmDevice.MegolmSessionData} exported session data
+     * @param senderKey - base64-encoded curve25519 key of the sender
+     * @param sessionId - session identifier
+     * @param sessionData - The session object from the store
+     * @returns exported session data
      */
     public exportInboundGroupSession(
         senderKey: string,
@@ -1539,11 +1487,11 @@ export class OlmDevice {
     /**
      * Verify an ed25519 signature.
      *
-     * @param {string} key ed25519 key
-     * @param {string} message message which was signed
-     * @param {string} signature base64-encoded signature to be checked
+     * @param key - ed25519 key
+     * @param message - message which was signed
+     * @param signature - base64-encoded signature to be checked
      *
-     * @raises {Error} if there is a problem with the verification. If the key was
+     * @throws Error if there is a problem with the verification. If the key was
      * too small then the message will be "OLM.INVALID_BASE64". If the signature
      * was invalid then the message will be "OLM.BAD_MESSAGE_MAC".
      */
@@ -1568,11 +1516,11 @@ export const WITHHELD_MESSAGES: Record<string, string> = {
 /**
  * Calculate the message to use for the exception when a session key is withheld.
  *
- * @param {object} withheld  An object that describes why the key was withheld.
+ * @param withheld -  An object that describes why the key was withheld.
  *
- * @return {string} the message
+ * @returns the message
  *
- * @private
+ * @internal
  */
 function calculateWithheldMessage(withheld: IWithheld): string {
     if (withheld.code && withheld.code in WITHHELD_MESSAGES) {
diff --git a/src/crypto/OutgoingRoomKeyRequestManager.ts b/src/crypto/OutgoingRoomKeyRequestManager.ts
index cb93851b9d1..833592a4cc1 100644
--- a/src/crypto/OutgoingRoomKeyRequestManager.ts
+++ b/src/crypto/OutgoingRoomKeyRequestManager.ts
@@ -27,17 +27,17 @@ import { EventType, ToDeviceMessageId } from "../@types/event";
  *
  * See https://docs.google.com/document/d/1m4gQkcnJkxNuBmb5NoFCIadIY-DyqqNAS3lloE73BlQ
  * for draft documentation on what we're supposed to be implementing here.
- *
- * @module
  */
 
 // delay between deciding we want some keys, and sending out the request, to
 // allow for (a) it turning up anyway, (b) grouping requests together
 const SEND_KEY_REQUESTS_DELAY_MS = 500;
 
-/** possible states for a room key request
+/**
+ *  possible states for a room key request
  *
  * The state machine looks like:
+ * ```
  *
  *     |         (cancellation sent)
  *     | .-------------------------------------------------.
@@ -60,8 +60,7 @@ const SEND_KEY_REQUESTS_DELAY_MS = 500;
  *     | (cancellation sent)              |
  *     V                                  |
  * (deleted)  <---------------------------+
- *
- * @enum {number}
+ * ```
  */
 export enum RoomKeyRequestState {
     /** request not yet sent */
@@ -134,12 +133,10 @@ export class OutgoingRoomKeyRequestManager {
      * Otherwise, a request is added to the pending list, and a job is started
      * in the background to send it.
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     * @param {Array<{userId: string, deviceId: string}>} recipients
-     * @param {boolean} resend whether to resend the key request if there is
+     * @param resend - whether to resend the key request if there is
      *    already one
      *
-     * @returns {Promise} resolves when the request has been added to the
+     * @returns resolves when the request has been added to the
      *    pending list (or we have established that a similar request already
      *    exists)
      */
@@ -239,9 +236,8 @@ export class OutgoingRoomKeyRequestManager {
     /**
      * Cancel room key requests, if any match the given requestBody
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
      *
-     * @returns {Promise} resolves when the request has been updated in our
+     * @returns resolves when the request has been updated in our
      *    pending list.
      */
     public cancelRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<unknown> {
@@ -324,11 +320,10 @@ export class OutgoingRoomKeyRequestManager {
     /**
      * Look for room key requests by target device and state
      *
-     * @param {string} userId Target user ID
-     * @param {string} deviceId Target device ID
+     * @param userId - Target user ID
+     * @param deviceId - Target device ID
      *
-     * @return {Promise} resolves to a list of all the
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
+     * @returns resolves to a list of all the {@link OutgoingRoomKeyRequest}
      */
     public getOutgoingSentRoomKeyRequest(userId: string, deviceId: string): Promise<OutgoingRoomKeyRequest[]> {
         return this.cryptoStore.getOutgoingRoomKeyRequestsByTarget(userId, deviceId, [RoomKeyRequestState.Sent]);
@@ -339,7 +334,7 @@ export class OutgoingRoomKeyRequestManager {
      * This is intended for situations where something substantial has changed, and we
      * don't really expect the other end to even care about the cancellation.
      * For example, after initialization or self-verification.
-     * @return {Promise} An array of `queueRoomKeyRequest` outputs.
+     * @returns An array of `queueRoomKeyRequest` outputs.
      */
     public async cancelAndResendAllOutgoingRequests(): Promise<void[]> {
         const outgoings = await this.cryptoStore.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
diff --git a/src/crypto/RoomList.ts b/src/crypto/RoomList.ts
index 672ef473c05..2f5233bd2e4 100644
--- a/src/crypto/RoomList.ts
+++ b/src/crypto/RoomList.ts
@@ -15,8 +15,6 @@ limitations under the License.
 */
 
 /**
- * @module crypto/RoomList
- *
  * Manages the list of encrypted rooms
  */
 
@@ -31,9 +29,6 @@ export interface IRoomEncryption {
 }
 /* eslint-enable camelcase */
 
-/**
- * @alias module:crypto/RoomList
- */
 export class RoomList {
     // Object of roomId -> room e2e info object (body of the m.room.encryption event)
     private roomEncryption: Record<string, IRoomEncryption> = {};
diff --git a/src/crypto/SecretStorage.ts b/src/crypto/SecretStorage.ts
index 54702034f46..921207c4a16 100644
--- a/src/crypto/SecretStorage.ts
+++ b/src/crypto/SecretStorage.ts
@@ -66,7 +66,6 @@ interface ISecretInfo {
 
 /**
  * Implements Secure Secret Storage and Sharing (MSC1946)
- * @module crypto/SecretStorage
  */
 export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     private requests = new Map<string, ISecretRequestInternal>();
@@ -119,15 +118,15 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Add a key for encrypting secrets.
      *
-     * @param {string} algorithm the algorithm used by the key.
-     * @param {object} opts the options for the algorithm.  The properties used
+     * @param algorithm - the algorithm used by the key.
+     * @param opts - the options for the algorithm.  The properties used
      *     depend on the algorithm given.
-     * @param {string} [keyId] the ID of the key.  If not given, a random
+     * @param keyId - the ID of the key.  If not given, a random
      *     ID will be generated.
      *
-     * @return {object} An object with:
-     *     keyId: {string} the ID of the key
-     *     keyInfo: {object} details about the key (iv, mac, passphrase)
+     * @returns An object with:
+     *     keyId: the ID of the key
+     *     keyInfo: details about the key (iv, mac, passphrase)
      */
     public async addKey(
         algorithm: string,
@@ -176,9 +175,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Get the key information for a given ID.
      *
-     * @param {string} [keyId = default key's ID] The ID of the key to check
+     * @param keyId - The ID of the key to check
      *     for. Defaults to the default key ID if not provided.
-     * @returns {Array?} If the key was found, the return value is an array of
+     * @returns If the key was found, the return value is an array of
      *     the form [keyId, keyInfo].  Otherwise, null is returned.
      *     XXX: why is this an array when addKey returns an object?
      */
@@ -199,9 +198,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Check whether we have a key with a given ID.
      *
-     * @param {string} [keyId = default key's ID] The ID of the key to check
+     * @param keyId - The ID of the key to check
      *     for. Defaults to the default key ID if not provided.
-     * @return {boolean} Whether we have the key.
+     * @returns Whether we have the key.
      */
     public async hasKey(keyId?: string): Promise<boolean> {
         return Boolean(await this.getKey(keyId));
@@ -210,10 +209,10 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Check whether a key matches what we expect based on the key info
      *
-     * @param {Uint8Array} key the key to check
-     * @param {object} info the key info
+     * @param key - the key to check
+     * @param info - the key info
      *
-     * @return {boolean} whether or not the key matches
+     * @returns whether or not the key matches
      */
     public async checkKey(key: Uint8Array, info: ISecretStorageKeyInfo): Promise<boolean> {
         if (info.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {
@@ -232,9 +231,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Store an encrypted secret on the server
      *
-     * @param {string} name The name of the secret
-     * @param {string} secret The secret contents.
-     * @param {Array} keys The IDs of the keys to use to encrypt the secret
+     * @param name - The name of the secret
+     * @param secret - The secret contents.
+     * @param keys - The IDs of the keys to use to encrypt the secret
      *     or null/undefined to use the default key.
      */
     public async store(name: string, secret: string, keys?: string[] | null): Promise<void> {
@@ -280,9 +279,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Get a secret from storage.
      *
-     * @param {string} name the name of the secret
+     * @param name - the name of the secret
      *
-     * @return {string} the contents of the secret
+     * @returns the contents of the secret
      */
     public async get(name: string): Promise<string | undefined> {
         const secretInfo = await this.accountDataAdapter.getAccountDataFromServer<ISecretInfo>(name);
@@ -326,9 +325,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Check if a secret is stored on the server.
      *
-     * @param {string} name the name of the secret
+     * @param name - the name of the secret
      *
-     * @return {object?} map of key name to key info the secret is encrypted
+     * @returns map of key name to key info the secret is encrypted
      *     with, or null if it is not present or not encrypted with a trusted
      *     key
      */
@@ -361,8 +360,8 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     /**
      * Request a secret from another device
      *
-     * @param {string} name the name of the secret to request
-     * @param {string[]} devices the devices to request the secret from
+     * @param name - the name of the secret to request
+     * @param devices - the devices to request the secret from
      */
     public request(this: SecretStorage<MatrixClient>, name: string, devices: string[]): ISecretRequest {
         const requestId = this.baseApis.makeTxnId();
diff --git a/src/crypto/aes.ts b/src/crypto/aes.ts
index 33971e6346b..da546483439 100644
--- a/src/crypto/aes.ts
+++ b/src/crypto/aes.ts
@@ -22,18 +22,21 @@ const zeroSalt = new Uint8Array(8);
 
 export interface IEncryptedPayload {
     [key: string]: any; // extensible
+    /** the initialization vector in base64 */
     iv: string;
+    /** the ciphertext in base64 */
     ciphertext: string;
+    /** the HMAC in base64 */
     mac: string;
 }
 
 /**
  * encrypt a string
  *
- * @param {string} data the plaintext to encrypt
- * @param {Uint8Array} key the encryption key to use
- * @param {string} name the name of the secret
- * @param {string} ivStr the initialization vector to use
+ * @param data - the plaintext to encrypt
+ * @param key - the encryption key to use
+ * @param name - the name of the secret
+ * @param ivStr - the initialization vector to use
  */
 export async function encryptAES(
     data: string,
@@ -83,12 +86,9 @@ export async function encryptAES(
 /**
  * decrypt a string
  *
- * @param {object} data the encrypted data
- * @param {string} data.ciphertext the ciphertext in base64
- * @param {string} data.iv the initialization vector in base64
- * @param {string} data.mac the HMAC in base64
- * @param {Uint8Array} key the encryption key to use
- * @param {string} name the name of the secret
+ * @param data - the encrypted data
+ * @param key - the encryption key to use
+ * @param name - the name of the secret
  */
 export async function decryptAES(data: IEncryptedPayload, key: Uint8Array, name: string): Promise<string> {
     const [aesKey, hmacKey] = await deriveKeys(key, name);
@@ -168,10 +168,10 @@ const ZERO_STR = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0
 
 /** Calculate the MAC for checking the key.
  *
- * @param {Uint8Array} key the key to use
- * @param {string} [iv] The initialization vector as a base64-encoded string.
+ * @param key - the key to use
+ * @param iv - The initialization vector as a base64-encoded string.
  *     If omitted, a random initialization vector will be created.
- * @return {Promise<object>} An object that contains, `mac` and `iv` properties.
+ * @returns An object that contains, `mac` and `iv` properties.
  */
 export function calculateKeyCheck(key: Uint8Array, iv?: string): Promise<IEncryptedPayload> {
     return encryptAES(ZERO_STR, key, "", iv);
diff --git a/src/crypto/algorithms/base.ts b/src/crypto/algorithms/base.ts
index 32b9ab73b7e..3229ad39bd2 100644
--- a/src/crypto/algorithms/base.ts
+++ b/src/crypto/algorithms/base.ts
@@ -16,8 +16,6 @@ limitations under the License.
 
 /**
  * Internal module. Defines the base classes of the encryption implementations
- *
- * @module
  */
 
 import { MatrixClient } from "../../client";
@@ -35,46 +33,36 @@ import { DeviceInfo } from "../deviceinfo";
 import { IRoomEncryption } from "../RoomList";
 
 /**
- * map of registered encryption algorithm classes. A map from string to {@link
- * module:crypto/algorithms/base.EncryptionAlgorithm|EncryptionAlgorithm} class
- *
- * @type {Object.<string, function(new: module:crypto/algorithms/base.EncryptionAlgorithm)>}
+ * Map of registered encryption algorithm classes. A map from string to {@link EncryptionAlgorithm} class
  */
 export const ENCRYPTION_CLASSES = new Map<string, new (params: IParams) => EncryptionAlgorithm>();
 
 export type DecryptionClassParams<P extends IParams = IParams> = Omit<P, "deviceId" | "config">;
 
 /**
- * map of registered encryption algorithm classes. Map from string to {@link
- * module:crypto/algorithms/base.DecryptionAlgorithm|DecryptionAlgorithm} class
- *
- * @type {Object.<string, function(new: module:crypto/algorithms/base.DecryptionAlgorithm)>}
+ * map of registered encryption algorithm classes. Map from string to {@link DecryptionAlgorithm} class
  */
 export const DECRYPTION_CLASSES = new Map<string, new (params: DecryptionClassParams) => DecryptionAlgorithm>();
 
 export interface IParams {
+    /** The UserID for the local user */
     userId: string;
+    /** The identifier for this device. */
     deviceId: string;
+    /** crypto core */
     crypto: Crypto;
+    /** olm.js wrapper */
     olmDevice: OlmDevice;
+    /** base matrix api interface */
     baseApis: MatrixClient;
+    /** The ID of the room we will be sending to */
     roomId?: string;
+    /** The body of the m.room.encryption event */
     config: IRoomEncryption & object;
 }
 
 /**
  * base type for encryption implementations
- *
- * @alias module:crypto/algorithms/base.EncryptionAlgorithm
- *
- * @param {object} params parameters
- * @param {string} params.userId  The UserID for the local user
- * @param {string} params.deviceId The identifier for this device.
- * @param {module:crypto} params.crypto crypto core
- * @param {module:crypto/OlmDevice} params.olmDevice olm.js wrapper
- * @param {MatrixClient} baseApis base matrix api interface
- * @param {string} params.roomId  The ID of the room we will be sending to
- * @param {object} params.config  The body of the m.room.encryption event
  */
 export abstract class EncryptionAlgorithm {
     protected readonly userId: string;
@@ -84,6 +72,9 @@ export abstract class EncryptionAlgorithm {
     protected readonly baseApis: MatrixClient;
     protected readonly roomId?: string;
 
+    /**
+     * @param params - parameters
+     */
     public constructor(params: IParams) {
         this.userId = params.userId;
         this.deviceId = params.deviceId;
@@ -97,33 +88,28 @@ export abstract class EncryptionAlgorithm {
      * Perform any background tasks that can be done before a message is ready to
      * send, in order to speed up sending of the message.
      *
-     * @param {module:models/room} room the room the event is in
+     * @param room - the room the event is in
      */
     public prepareToEncrypt(room: Room): void {}
 
     /**
      * Encrypt a message event
      *
-     * @method module:crypto/algorithms/base.EncryptionAlgorithm.encryptMessage
      * @public
-     * @abstract
      *
-     * @param {module:models/room} room
-     * @param {string} eventType
-     * @param {object} content event content
+     * @param content - event content
      *
-     * @return {Promise} Promise which resolves to the new event body
+     * @returns Promise which resolves to the new event body
      */
     public abstract encryptMessage(room: Room, eventType: string, content: IContent): Promise<IEncryptedContent>;
 
     /**
      * Called when the membership of a member of the room changes.
      *
-     * @param {module:models/event.MatrixEvent} event  event causing the change
-     * @param {module:models/room-member} member  user whose membership changed
-     * @param {string=} oldMembership  previous membership
+     * @param event -  event causing the change
+     * @param member -  user whose membership changed
+     * @param oldMembership -  previous membership
      * @public
-     * @abstract
      */
     public onRoomMembership(event: MatrixEvent, member: RoomMember, oldMembership?: string): void {}
 
@@ -139,15 +125,6 @@ export abstract class EncryptionAlgorithm {
 
 /**
  * base type for decryption implementations
- *
- * @alias module:crypto/algorithms/base.DecryptionAlgorithm
- * @param {object} params parameters
- * @param {string} params.userId  The UserID for the local user
- * @param {module:crypto} params.crypto crypto core
- * @param {module:crypto/OlmDevice} params.olmDevice olm.js wrapper
- * @param {MatrixClient} baseApis base matrix api interface
- * @param {string=} params.roomId The ID of the room we will be receiving
- *     from. Null for to-device events.
  */
 export abstract class DecryptionAlgorithm {
     protected readonly userId: string;
@@ -167,12 +144,9 @@ export abstract class DecryptionAlgorithm {
     /**
      * Decrypt an event
      *
-     * @method module:crypto/algorithms/base.DecryptionAlgorithm#decryptEvent
-     * @abstract
-     *
-     * @param {MatrixEvent} event undecrypted event
+     * @param event - undecrypted event
      *
-     * @return {Promise<module:crypto~EventDecryptionResult>} promise which
+     * @returns promise which
      * resolves once we have finished decrypting. Rejects with an
      * `algorithms.DecryptionError` if there is a problem decrypting the event.
      */
@@ -181,9 +155,7 @@ export abstract class DecryptionAlgorithm {
     /**
      * Handle a key event
      *
-     * @method module:crypto/algorithms/base.DecryptionAlgorithm#onRoomKeyEvent
-     *
-     * @param {module:models/event.MatrixEvent} params event key event
+     * @param params - event key event
      */
     public async onRoomKeyEvent(params: MatrixEvent): Promise<void> {
         // ignore by default
@@ -192,8 +164,7 @@ export abstract class DecryptionAlgorithm {
     /**
      * Import a room key
      *
-     * @param {module:crypto/OlmDevice.MegolmSessionData} session
-     * @param {object} opts object
+     * @param opts - object
      */
     public async importRoomKey(session: IMegolmSessionData, opts: object): Promise<void> {
         // ignore by default
@@ -202,8 +173,7 @@ export abstract class DecryptionAlgorithm {
     /**
      * Determine if we have the keys necessary to respond to a room key request
      *
-     * @param {module:crypto~IncomingRoomKeyRequest} keyRequest
-     * @return {Promise<boolean>} true if we have the keys and could (theoretically) share
+     * @returns true if we have the keys and could (theoretically) share
      *  them; else false.
      */
     public hasKeysForKeyRequest(keyRequest: IncomingRoomKeyRequest): Promise<boolean> {
@@ -213,7 +183,6 @@ export abstract class DecryptionAlgorithm {
     /**
      * Send the response to a room key request
      *
-     * @param {module:crypto~IncomingRoomKeyRequest} keyRequest
      */
     public shareKeysWithDevice(keyRequest: IncomingRoomKeyRequest): void {
         throw new Error("shareKeysWithDevice not supported for this DecryptionAlgorithm");
@@ -223,7 +192,7 @@ export abstract class DecryptionAlgorithm {
      * Retry decrypting all the events from a sender that haven't been
      * decrypted yet.
      *
-     * @param {string} senderKey the sender's key
+     * @param senderKey - the sender's key
      */
     public async retryDecryptionFromSender(senderKey: string): Promise<boolean> {
         // ignore by default
@@ -237,13 +206,10 @@ export abstract class DecryptionAlgorithm {
 /**
  * Exception thrown when decryption fails
  *
- * @alias module:crypto/algorithms/base.DecryptionError
- * @param {string} msg user-visible message describing the problem
+ * @param msg - user-visible message describing the problem
  *
- * @param {Object=} details key/value pairs reported in the logs but not shown
+ * @param details - key/value pairs reported in the logs but not shown
  *   to the user.
- *
- * @extends Error
  */
 export class DecryptionError extends Error {
     public readonly detailedString: string;
@@ -268,16 +234,14 @@ function detailedStringForDecryptionError(err: DecryptionError, details?: Record
     return result;
 }
 
-/**
- * Exception thrown specifically when we want to warn the user to consider
- * the security of their conversation before continuing
- *
- * @param {string} msg message describing the problem
- * @param {Object} devices userId -> {deviceId -> object}
- *      set of unknown devices per user we're warning about
- * @extends Error
- */
 export class UnknownDeviceError extends Error {
+    /**
+     * Exception thrown specifically when we want to warn the user to consider
+     * the security of their conversation before continuing
+     *
+     * @param msg - message describing the problem
+     * @param devices - set of unknown devices per user we're warning about
+     */
     public constructor(
         msg: string,
         public readonly devices: Record<string, Record<string, object>>,
@@ -292,15 +256,11 @@ export class UnknownDeviceError extends Error {
 /**
  * Registers an encryption/decryption class for a particular algorithm
  *
- * @param {string} algorithm algorithm tag to register for
+ * @param algorithm - algorithm tag to register for
  *
- * @param {class} encryptor {@link
- *     module:crypto/algorithms/base.EncryptionAlgorithm|EncryptionAlgorithm}
- *     implementation
+ * @param encryptor - {@link EncryptionAlgorithm} implementation
  *
- * @param {class} decryptor {@link
- *     module:crypto/algorithms/base.DecryptionAlgorithm|DecryptionAlgorithm}
- *     implementation
+ * @param decryptor - {@link DecryptionAlgorithm} implementation
  */
 export function registerAlgorithm<P extends IParams = IParams>(
     algorithm: string,
diff --git a/src/crypto/algorithms/index.ts b/src/crypto/algorithms/index.ts
index 3dd1158a0c5..b3c5b0ede84 100644
--- a/src/crypto/algorithms/index.ts
+++ b/src/crypto/algorithms/index.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module crypto/algorithms
- */
-
 import "./olm";
 import "./megolm";
 
diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index b099ef40ae6..d995623d4ed 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -16,8 +16,6 @@ limitations under the License.
 
 /**
  * Defines m.olm encryption/decryption
- *
- * @module crypto/algorithms/megolm
  */
 
 import { v4 as uuidv4 } from "uuid";
@@ -123,37 +121,27 @@ interface SharedWithData {
 }
 
 /**
- * @private
- * @constructor
- *
- * @param {string} sessionId
- * @param {boolean} sharedHistory whether the session can be freely shared with
- *    other group members, according to the room history visibility settings
- *
- * @property {string} sessionId
- * @property {Number} useCount     number of times this session has been used
- * @property {Number} creationTime when the session was created (ms since the epoch)
- *
- * @property {object} sharedWithDevices
- *    devices with which we have shared the session key
- *        userId -> {deviceId -> SharedWithData}
+ * @internal
  */
 class OutboundSessionInfo {
+    /** number of times this session has been used */
     public useCount = 0;
+    /** when the session was created (ms since the epoch) */
     public creationTime: number;
+    /** devices with which we have shared the session key `userId -> {deviceId -> SharedWithData}` */
     public sharedWithDevices: Record<string, Record<string, SharedWithData>> = {};
     public blockedDevicesNotified: Record<string, Record<string, boolean>> = {};
 
+    /**
+     * @param sharedHistory - whether the session can be freely shared with
+     *    other group members, according to the room history visibility settings
+     */
     public constructor(public readonly sessionId: string, public readonly sharedHistory = false) {
         this.creationTime = new Date().getTime();
     }
 
     /**
      * Check if it's time to rotate the session
-     *
-     * @param {Number} rotationPeriodMsgs
-     * @param {Number} rotationPeriodMs
-     * @return {Boolean}
      */
     public needsRotation(rotationPeriodMsgs: number, rotationPeriodMs: number): boolean {
         const sessionLifetime = new Date().getTime() - this.creationTime;
@@ -189,10 +177,10 @@ class OutboundSessionInfo {
      * Determine if this session has been shared with devices which it shouldn't
      * have been.
      *
-     * @param {Object} devicesInRoom userId -> {deviceId -> object}
+     * @param devicesInRoom - `userId -> {deviceId -> object}`
      *   devices we should shared the session with.
      *
-     * @return {Boolean} true if we have shared the session with devices which aren't
+     * @returns true if we have shared the session with devices which aren't
      * in devicesInRoom.
      */
     public sharedWithTooManyDevices(devicesInRoom: Record<string, Record<string, object>>): boolean {
@@ -228,11 +216,7 @@ class OutboundSessionInfo {
 /**
  * Megolm encryption implementation
  *
- * @constructor
- * @extends {module:crypto/algorithms/EncryptionAlgorithm}
- *
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/EncryptionAlgorithm}
+ * @param params - parameters, as per {@link EncryptionAlgorithm}
  */
 export class MegolmEncryption extends EncryptionAlgorithm {
     // the most recent attempt to set up a session. This is used to serialise
@@ -265,15 +249,14 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     }
 
     /**
-     * @private
+     * @internal
      *
-     * @param {module:models/room} room
-     * @param {Object} devicesInRoom The devices in this room, indexed by user ID
-     * @param {Object} blocked The devices that are blocked, indexed by user ID
-     * @param {boolean} [singleOlmCreationPhase] Only perform one round of olm
+     * @param devicesInRoom - The devices in this room, indexed by user ID
+     * @param blocked - The devices that are blocked, indexed by user ID
+     * @param singleOlmCreationPhase - Only perform one round of olm
      *     session creation
      *
-     * @return {Promise} Promise which resolves to the
+     * @returns Promise which resolves to the
      *    OutboundSessionInfo when setup is complete.
      */
     private async ensureOutboundSession(
@@ -488,11 +471,10 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     }
 
     /**
-     * @private
+     * @internal
      *
-     * @param {boolean} sharedHistory
      *
-     * @return {module:crypto/algorithms/megolm.OutboundSessionInfo} session
+     * @returns session
      */
     private async prepareNewSession(sharedHistory: boolean): Promise<OutboundSessionInfo> {
         const sessionId = this.olmDevice.createOutboundGroupSession();
@@ -514,15 +496,15 @@ export class MegolmEncryption extends EncryptionAlgorithm {
      * Determines what devices in devicesByUser don't have an olm session as given
      * in devicemap.
      *
-     * @private
+     * @internal
      *
-     * @param {object} devicemap the devices that have olm sessions, as returned by
+     * @param devicemap - the devices that have olm sessions, as returned by
      *     olmlib.ensureOlmSessionsForDevices.
-     * @param {object} devicesByUser a map of user IDs to array of deviceInfo
-     * @param {array} [noOlmDevices] an array to fill with devices that don't have
+     * @param devicesByUser - a map of user IDs to array of deviceInfo
+     * @param noOlmDevices - an array to fill with devices that don't have
      *     olm sessions
      *
-     * @return {array} an array of devices that don't have olm sessions.  If
+     * @returns an array of devices that don't have olm sessions.  If
      *     noOlmDevices is specified, then noOlmDevices will be returned.
      */
     private getDevicesWithoutSessions(
@@ -558,11 +540,11 @@ export class MegolmEncryption extends EncryptionAlgorithm {
      * Splits the user device map into multiple chunks to reduce the number of
      * devices we encrypt to per API call.
      *
-     * @private
+     * @internal
      *
-     * @param {object} devicesByUser map from userid to list of devices
+     * @param devicesByUser - map from userid to list of devices
      *
-     * @return {array<array<object>>} the blocked devices, split into chunks
+     * @returns the blocked devices, split into chunks
      */
     private splitDevices<T extends DeviceInfo | IBlockedDevice>(
         devicesByUser: Record<string, Record<string, { device: T }>>,
@@ -599,18 +581,16 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     }
 
     /**
-     * @private
+     * @internal
      *
-     * @param {module:crypto/algorithms/megolm.OutboundSessionInfo} session
      *
-     * @param {number} chainIndex current chain index
+     * @param chainIndex - current chain index
      *
-     * @param {object<userId, deviceInfo>} userDeviceMap
-     *   mapping from userId to deviceInfo
+     * @param userDeviceMap - mapping from userId to deviceInfo
      *
-     * @param {object} payload fields to include in the encrypted payload
+     * @param payload - fields to include in the encrypted payload
      *
-     * @return {Promise} Promise which resolves once the key sharing
+     * @returns Promise which resolves once the key sharing
      *     for the given userDeviceMap is generated and has been sent.
      */
     private encryptAndSendKeysToDevices(
@@ -639,15 +619,14 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     }
 
     /**
-     * @private
+     * @internal
      *
-     * @param {module:crypto/algorithms/megolm.OutboundSessionInfo} session
      *
-     * @param {array<object>} userDeviceMap list of blocked devices to notify
+     * @param userDeviceMap - list of blocked devices to notify
      *
-     * @param {object} payload fields to include in the notification payload
+     * @param payload - fields to include in the notification payload
      *
-     * @return {Promise} Promise which resolves once the notifications
+     * @returns Promise which resolves once the notifications
      *     for the given userDeviceMap is generated and has been sent.
      */
     private async sendBlockedNotificationsToDevices(
@@ -695,10 +674,10 @@ export class MegolmEncryption extends EncryptionAlgorithm {
      * Re-shares a megolm session key with devices if the key has already been
      * sent to them.
      *
-     * @param {string} senderKey The key of the originating device for the session
-     * @param {string} sessionId ID of the outbound session to share
-     * @param {string} userId ID of the user who owns the target device
-     * @param {module:crypto/deviceinfo} device The target device
+     * @param senderKey - The key of the originating device for the session
+     * @param sessionId - ID of the outbound session to share
+     * @param userId - ID of the user who owns the target device
+     * @param device - The target device
      */
     public async reshareKeyWithDevice(
         senderKey: string,
@@ -792,26 +771,23 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     }
 
     /**
-     * @private
+     * @internal
      *
-     * @param {module:crypto/algorithms/megolm.OutboundSessionInfo} session
      *
-     * @param {object} key the session key as returned by
+     * @param key - the session key as returned by
      *    OlmDevice.getOutboundGroupSessionKey
      *
-     * @param {object} payload the base to-device message payload for sharing keys
+     * @param payload - the base to-device message payload for sharing keys
      *
-     * @param {object<string, module:crypto/deviceinfo[]>} devicesByUser
-     *    map from userid to list of devices
+     * @param devicesByUser - map from userid to list of devices
      *
-     * @param {array<object>} errorDevices
-     *    array that will be populated with the devices that we can't get an
+     * @param errorDevices - array that will be populated with the devices that we can't get an
      *    olm session for
      *
-     * @param {Number} [otkTimeout] The timeout in milliseconds when requesting
+     * @param otkTimeout - The timeout in milliseconds when requesting
      *     one-time keys for establishing new olm sessions.
      *
-     * @param {Array} [failedServers] An array to fill with remote servers that
+     * @param failedServers - An array to fill with remote servers that
      *     failed to respond to one-time-key requests.
      */
     private async shareKeyWithDevices(
@@ -866,11 +842,9 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     /**
      * Notify devices that we weren't able to create olm sessions.
      *
-     * @param {module:crypto/algorithms/megolm.OutboundSessionInfo} session
      *
-     * @param {object} key
      *
-     * @param {Array<object>} failedDevices the devices that we were unable to
+     * @param failedDevices - the devices that we were unable to
      *     create olm sessions for, as returned by shareKeyWithDevices
      */
     private async notifyFailedOlmDevices(
@@ -927,10 +901,8 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     /**
      * Notify blocked devices that they have been blocked.
      *
-     * @param {module:crypto/algorithms/megolm.OutboundSessionInfo} session
      *
-     * @param {object<string, object>} devicesByUser
-     *    map from userid to device ID to blocked data
+     * @param devicesByUser - map from userid to device ID to blocked data
      */
     private async notifyBlockedDevices(
         session: OutboundSessionInfo,
@@ -963,7 +935,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
      * Perform any background tasks that can be done before a message is ready to
      * send, in order to speed up sending of the message.
      *
-     * @param {module:models/room} room the room the event is in
+     * @param room - the room the event is in
      */
     public prepareToEncrypt(room: Room): void {
         if (this.encryptionPreparation != null) {
@@ -1008,13 +980,9 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     }
 
     /**
-     * @inheritdoc
-     *
-     * @param {module:models/room} room
-     * @param {string} eventType
-     * @param {object} content plaintext event content
+     * @param content - plaintext event content
      *
-     * @return {Promise} Promise which resolves to the new event body
+     * @returns Promise which resolves to the new event body
      */
     public async encryptMessage(room: Room, eventType: string, content: IContent): Promise<IMegolmEncryptedContent> {
         logger.log(`Starting to encrypt event for ${this.roomId}`);
@@ -1103,7 +1071,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
      * unknown to the user.  If so, warn the user, and mark them as known to
      * give the user a chance to go verify them before re-sending this message.
      *
-     * @param {Object} devicesInRoom userId -> {deviceId -> object}
+     * @param devicesInRoom - `userId -> {deviceId -> object}`
      *   devices we should shared the session with.
      */
     private checkForUnknownDevices(devicesInRoom: DeviceInfoMap): void {
@@ -1133,7 +1101,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
      * Remove unknown devices from a set of devices.  The devicesInRoom parameter
      * will be modified.
      *
-     * @param {Object} devicesInRoom userId -> {deviceId -> object}
+     * @param devicesInRoom - `userId -> {deviceId -> object}`
      *   devices we should shared the session with.
      */
     private removeUnknownDevices(devicesInRoom: DeviceInfoMap): void {
@@ -1153,11 +1121,10 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     /**
      * Get the list of unblocked devices for all users in the room
      *
-     * @param {module:models/room} room
-     * @param forceDistributeToUnverified if set to true will include the unverified devices
+     * @param forceDistributeToUnverified - if set to true will include the unverified devices
      * even if setting is set to block them (useful for verification)
      *
-     * @return {Promise} Promise which resolves to an array whose
+     * @returns Promise which resolves to an array whose
      *     first element is a map from userId to deviceId to deviceInfo indicating
      *     the devices that messages should be encrypted to, and whose second
      *     element is a map from userId to deviceId to data indicating the devices
@@ -1225,11 +1192,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
 /**
  * Megolm decryption implementation
  *
- * @constructor
- * @extends {module:crypto/algorithms/DecryptionAlgorithm}
- *
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/DecryptionAlgorithm}
+ * @param params - parameters, as per {@link DecryptionAlgorithm}
  */
 export class MegolmDecryption extends DecryptionAlgorithm {
     // events which we couldn't decrypt due to unknown sessions /
@@ -1248,12 +1211,8 @@ export class MegolmDecryption extends DecryptionAlgorithm {
     }
 
     /**
-     * @inheritdoc
-     *
-     * @param {MatrixEvent} event
-     *
      * returns a promise which resolves to a
-     * {@link module:crypto~EventDecryptionResult} once we have finished
+     * {@link EventDecryptionResult} once we have finished
      * decrypting, or rejects with an `algorithms.DecryptionError` if there is a
      * problem decrypting the event.
      */
@@ -1394,9 +1353,8 @@ export class MegolmDecryption extends DecryptionAlgorithm {
     /**
      * Add an event to the list of those awaiting their session keys.
      *
-     * @private
+     * @internal
      *
-     * @param {module:models/event.MatrixEvent} event
      */
     private addEventToPendingList(event: MatrixEvent): void {
         const content = event.getWireContent();
@@ -1415,9 +1373,8 @@ export class MegolmDecryption extends DecryptionAlgorithm {
     /**
      * Remove an event from the list of those awaiting their session keys.
      *
-     * @private
+     * @internal
      *
-     * @param {module:models/event.MatrixEvent} event
      */
     private removeEventFromPendingList(event: MatrixEvent): void {
         const content = event.getWireContent();
@@ -1438,11 +1395,6 @@ export class MegolmDecryption extends DecryptionAlgorithm {
         }
     }
 
-    /**
-     * @inheritdoc
-     *
-     * @param {module:models/event.MatrixEvent} event key event
-     */
     public async onRoomKeyEvent(event: MatrixEvent): Promise<void> {
         const content = event.getContent<Partial<IMessage["content"]>>();
         let senderKey = event.getSenderKey()!;
@@ -1619,9 +1571,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
     }
 
     /**
-     * @inheritdoc
-     *
-     * @param {module:models/event.MatrixEvent} event key event
+     * @param event - key event
      */
     public async onRoomKeyWithheldEvent(event: MatrixEvent): Promise<void> {
         const content = event.getContent();
@@ -1706,9 +1656,6 @@ export class MegolmDecryption extends DecryptionAlgorithm {
         }
     }
 
-    /**
-     * @inheritdoc
-     */
     public hasKeysForKeyRequest(keyRequest: IncomingRoomKeyRequest): Promise<boolean> {
         const body = keyRequest.requestBody;
 
@@ -1720,9 +1667,6 @@ export class MegolmDecryption extends DecryptionAlgorithm {
         );
     }
 
-    /**
-     * @inheritdoc
-     */
     public shareKeysWithDevice(keyRequest: IncomingRoomKeyRequest): void {
         const userId = keyRequest.userId;
         const deviceId = keyRequest.deviceId;
@@ -1808,19 +1752,15 @@ export class MegolmDecryption extends DecryptionAlgorithm {
     }
 
     /**
-     * @inheritdoc
-     *
-     * @param {module:crypto/OlmDevice.MegolmSessionData} session
-     * @param {object} [opts={}] options for the import
-     * @param {boolean} [opts.untrusted] whether the key should be considered as untrusted
-     * @param {string} [opts.source] where the key came from
+     * @param untrusted - whether the key should be considered as untrusted
+     * @param source - where the key came from
      */
     public importRoomKey(
         session: IMegolmSessionData,
-        opts: { untrusted?: boolean, source?: string } = {},
+        { untrusted, source }: { untrusted?: boolean, source?: string } = {},
     ): Promise<void> {
         const extraSessionData: OlmGroupSessionExtraData = {};
-        if (opts.untrusted || session.untrusted) {
+        if (untrusted || session.untrusted) {
             extraSessionData.untrusted = true;
         }
         if (session["org.matrix.msc3061.shared_history"]) {
@@ -1836,7 +1776,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
             true,
             extraSessionData,
         ).then(() => {
-            if (opts.source !== "backup") {
+            if (source !== "backup") {
                 // don't wait for it to complete
                 this.crypto.backupManager.backupGroupSession(
                     session.sender_key, session.session_id,
@@ -1855,13 +1795,11 @@ export class MegolmDecryption extends DecryptionAlgorithm {
      * Have another go at decrypting events after we receive a key. Resolves once
      * decryption has been re-attempted on all events.
      *
-     * @private
-     * @param {String} senderKey
-     * @param {String} sessionId
-     * @param {Boolean} forceRedecryptIfUntrusted whether messages that were already
+     * @internal
+     * @param forceRedecryptIfUntrusted - whether messages that were already
      *     successfully decrypted using untrusted keys should be re-decrypted
      *
-     * @return {Boolean} whether all messages were successfully
+     * @returns whether all messages were successfully
      *     decrypted with trusted keys
      */
     private async retryDecryption(
diff --git a/src/crypto/algorithms/olm.ts b/src/crypto/algorithms/olm.ts
index 114368319b7..1feee6ba6cf 100644
--- a/src/crypto/algorithms/olm.ts
+++ b/src/crypto/algorithms/olm.ts
@@ -16,8 +16,6 @@ limitations under the License.
 
 /**
  * Defines m.olm encryption/decryption
- *
- * @module crypto/algorithms/olm
  */
 
 import { logger } from '../../logger';
@@ -44,21 +42,17 @@ export interface IMessage {
 /**
  * Olm encryption implementation
  *
- * @constructor
- * @extends {module:crypto/algorithms/EncryptionAlgorithm}
- *
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/EncryptionAlgorithm}
+ * @param params - parameters, as per {@link EncryptionAlgorithm}
  */
 class OlmEncryption extends EncryptionAlgorithm {
     private sessionPrepared = false;
     private prepPromise: Promise<void> | null = null;
 
     /**
-     * @private
+     * @internal
 
-     * @param {string[]} roomMembers list of currently-joined users in the room
-     * @return {Promise} Promise which resolves when setup is complete
+     * @param roomMembers - list of currently-joined users in the room
+     * @returns Promise which resolves when setup is complete
      */
     private ensureSession(roomMembers: string[]): Promise<void> {
         if (this.prepPromise) {
@@ -83,13 +77,9 @@ class OlmEncryption extends EncryptionAlgorithm {
     }
 
     /**
-     * @inheritdoc
-     *
-     * @param {module:models/room} room
-     * @param {string} eventType
-     * @param {object} content plaintext event content
+     * @param content - plaintext event content
      *
-     * @return {Promise} Promise which resolves to the new event body
+     * @returns Promise which resolves to the new event body
      */
     public async encryptMessage(room: Room, eventType: string, content: IContent): Promise<IOlmEncryptedContent> {
         // pick the list of recipients based on the membership list.
@@ -150,19 +140,12 @@ class OlmEncryption extends EncryptionAlgorithm {
 /**
  * Olm decryption implementation
  *
- * @constructor
- * @extends {module:crypto/algorithms/DecryptionAlgorithm}
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/DecryptionAlgorithm}
+ * @param params - parameters, as per {@link DecryptionAlgorithm}
  */
 class OlmDecryption extends DecryptionAlgorithm {
     /**
-     * @inheritdoc
-     *
-     * @param {MatrixEvent} event
-     *
      * returns a promise which resolves to a
-     * {@link module:crypto~EventDecryptionResult} once we have finished
+     * {@link EventDecryptionResult} once we have finished
      * decrypting. Rejects with an `algorithms.DecryptionError` if there is a
      * problem decrypting the event.
      */
@@ -275,10 +258,10 @@ class OlmDecryption extends DecryptionAlgorithm {
     /**
      * Attempt to decrypt an Olm message
      *
-     * @param {string} theirDeviceIdentityKey  Curve25519 identity key of the sender
-     * @param {object} message  message object, with 'type' and 'body' fields
+     * @param theirDeviceIdentityKey -  Curve25519 identity key of the sender
+     * @param message -  message object, with 'type' and 'body' fields
      *
-     * @return {string} payload, if decrypted successfully.
+     * @returns payload, if decrypted successfully.
      */
     private decryptMessage(theirDeviceIdentityKey: string, message: IMessage): Promise<string> {
         // This is a wrapper that serialises decryptions of prekey messages, because
diff --git a/src/crypto/api.ts b/src/crypto/api.ts
index f6487ca913d..468cc993383 100644
--- a/src/crypto/api.ts
+++ b/src/crypto/api.ts
@@ -66,8 +66,7 @@ export interface IRecoveryKey {
 export interface ICreateSecretStorageOpts {
     /**
      * Function called to await a secret storage key creation flow.
-     * Returns:
-     *     {Promise<Object>} Object with public key metadata, encoded private
+     * @returns Promise resolving to an object with public key metadata, encoded private
      *     recovery key which should be disposed of after displaying to the user,
      *     and raw private key to avoid round tripping if needed.
      */
@@ -131,6 +130,7 @@ export interface IImportOpts {
 }
 
 export interface IImportRoomKeysOpts {
+    /** called with an object that has a "stage" param */
     progressCallback?: (stage: IImportOpts) => void;
     untrusted?: boolean;
     source?: string; // TODO: Enum
diff --git a/src/crypto/backup.ts b/src/crypto/backup.ts
index 51912893605..fa90c6b7865 100644
--- a/src/crypto/backup.ts
+++ b/src/crypto/backup.ts
@@ -15,8 +15,6 @@ limitations under the License.
 */
 
 /**
- * @module crypto/backup
- *
  * Classes for dealing with key backup.
  */
 
@@ -134,7 +132,7 @@ export class BackupManager {
      *
      * Throws an error if a problem is detected.
      *
-     * @param {IKeyBackupInfo} info the key backup info
+     * @param info - the key backup info
      */
     public static checkBackupVersion(info: IKeyBackupInfo): void {
         const Algorithm = algorithmsByName[info.algorithm];
@@ -276,7 +274,7 @@ export class BackupManager {
      * Forces a re-check of the key backup and enables/disables it
      * as appropriate.
      *
-     * @return {Object} Object with backup info (as returned by
+     * @returns Object with backup info (as returned by
      *     getKeyBackupVersion) in backupInfo and
      *     trust information (as returned by isKeyBackupTrusted)
      *     in trustInfo.
@@ -309,15 +307,7 @@ export class BackupManager {
     /**
      * Check if the given backup info is trusted.
      *
-     * @param {IKeyBackupInfo} backupInfo key backup info dict from /room_keys/version
-     * @return {object} {
-     *     usable: [bool], // is the backup trusted, true iff there is a sig that is valid & from a trusted device
-     *     sigs: [
-     *         valid: [bool || null], // true: valid, false: invalid, null: cannot attempt validation
-     *         deviceId: [string],
-     *         device: [DeviceInfo || null],
-     *     ]
-     * }
+     * @param backupInfo - key backup info dict from /room_keys/version
      */
     public async isKeyBackupTrusted(backupInfo?: IKeyBackupInfo): Promise<TrustInfo> {
         const ret = {
@@ -432,7 +422,7 @@ export class BackupManager {
      * Schedules sending all keys waiting to be sent to the backup, if not already
      * scheduled. Retries if necessary.
      *
-     * @param maxDelay Maximum delay to wait in ms. 0 means no delay.
+     * @param maxDelay - Maximum delay to wait in ms. 0 means no delay.
      */
     public async scheduleKeyBackupSend(maxDelay = 10000): Promise<void> {
         if (this.sendingBackups) return;
@@ -490,8 +480,8 @@ export class BackupManager {
      * Take some e2e keys waiting to be backed up and send them
      * to the backup.
      *
-     * @param {number} limit Maximum number of keys to back up
-     * @returns {number} Number of sessions backed up
+     * @param limit - Maximum number of keys to back up
+     * @returns Number of sessions backed up
      */
     public async backupPendingKeys(limit: number): Promise<number> {
         const sessions = await this.baseApis.crypto!.cryptoStore.getSessionsNeedingBackup(limit);
@@ -573,7 +563,7 @@ export class BackupManager {
     /**
      * Marks all group sessions as needing to be backed up without scheduling
      * them to upload in the background.
-     * @returns {Promise<int>} Resolves to the number of sessions now requiring a backup
+     * @returns Promise which resolves to the number of sessions now requiring a backup
      *     (which will be equal to the number of sessions in the store).
      */
     public async flagAllGroupSessionsForBackup(): Promise<number> {
@@ -599,7 +589,7 @@ export class BackupManager {
 
     /**
      * Counts the number of end to end session keys that are waiting to be backed up
-     * @returns {Promise<int>} Resolves to the number of sessions requiring backup
+     * @returns Promise which resolves to the number of sessions requiring backup
      */
     public countSessionsNeedingBackup(): Promise<number> {
         return this.baseApis.crypto!.cryptoStore.countSessionsNeedingBackup();
diff --git a/src/crypto/deviceinfo.ts b/src/crypto/deviceinfo.ts
index a8fd9f0086b..1fbbd280044 100644
--- a/src/crypto/deviceinfo.ts
+++ b/src/crypto/deviceinfo.ts
@@ -16,10 +16,6 @@ limitations under the License.
 
 import { ISignatures } from "../@types/signed";
 
-/**
- * @module crypto/deviceinfo
- */
-
 export interface IDevice {
     keys: Record<string, string>;
     algorithms: string[];
@@ -37,36 +33,15 @@ enum DeviceVerification {
 
 /**
   * Information about a user's device
-  *
-  * @constructor
-  * @alias module:crypto/deviceinfo
-  *
-  * @property {string} deviceId the ID of this device
-  *
-  * @property {string[]} algorithms list of algorithms supported by this device
-  *
-  * @property {Object.<string,string>} keys a map from
-  *      &lt;key type&gt;:&lt;id&gt; -> &lt;base64-encoded key&gt;>
-  *
-  * @property {module:crypto/deviceinfo.DeviceVerification} verified
-  *     whether the device has been verified/blocked by the user
-  *
-  * @property {boolean} known
-  *     whether the user knows of this device's existence (useful when warning
-  *     the user that a user has added new devices)
-  *
-  * @property {Object} unsigned  additional data from the homeserver
-  *
-  * @param {string} deviceId id of the device
   */
 export class DeviceInfo {
     /**
      * rehydrate a DeviceInfo from the session store
      *
-     * @param {object} obj  raw object from session store
-     * @param {string} deviceId id of the device
+     * @param obj -  raw object from session store
+     * @param deviceId - id of the device
      *
-     * @return {module:crypto~DeviceInfo} new DeviceInfo
+     * @returns new DeviceInfo
      */
     public static fromStorage(obj: Partial<IDevice>, deviceId: string): DeviceInfo {
         const res = new DeviceInfo(deviceId);
@@ -79,28 +54,36 @@ export class DeviceInfo {
         return res;
     }
 
-    /**
-     * @enum
-     */
     public static DeviceVerification = {
         VERIFIED: DeviceVerification.Verified,
         UNVERIFIED: DeviceVerification.Unverified,
         BLOCKED: DeviceVerification.Blocked,
     };
 
+    /** list of algorithms supported by this device */
     public algorithms: string[] = [];
+    /** a map from `<key type>:<id> -> <base64-encoded key>` */
     public keys: Record<string, string> = {};
+    /** whether the device has been verified/blocked by the user */
     public verified = DeviceVerification.Unverified;
+    /**
+     * whether the user knows of this device's existence
+     * (useful when warning the user that a user has added new devices)
+     */
     public known = false;
+    /** additional data from the homeserver */
     public unsigned: Record<string, any> = {};
     public signatures: ISignatures = {};
 
+    /**
+     * @param deviceId - id of the device
+     */
     public constructor(public readonly deviceId: string) {}
 
     /**
      * Prepare a DeviceInfo for JSON serialisation in the session store
      *
-     * @return {object} deviceinfo with non-serialised members removed
+     * @returns deviceinfo with non-serialised members removed
      */
     public toStorage(): IDevice {
         return {
@@ -116,7 +99,7 @@ export class DeviceInfo {
     /**
      * Get the fingerprint for this device (ie, the Ed25519 key)
      *
-     * @return {string} base64-encoded fingerprint of this device
+     * @returns base64-encoded fingerprint of this device
      */
     public getFingerprint(): string {
         return this.keys["ed25519:" + this.deviceId];
@@ -125,7 +108,7 @@ export class DeviceInfo {
     /**
      * Get the identity key for this device (ie, the Curve25519 key)
      *
-     * @return {string} base64-encoded identity key of this device
+     * @returns base64-encoded identity key of this device
      */
     public getIdentityKey(): string {
         return this.keys["curve25519:" + this.deviceId];
@@ -134,7 +117,7 @@ export class DeviceInfo {
     /**
      * Get the configured display name for this device, if any
      *
-     * @return {string?} displayname
+     * @returns displayname
      */
     public getDisplayName(): string | null {
         return this.unsigned.device_display_name || null;
@@ -143,7 +126,7 @@ export class DeviceInfo {
     /**
      * Returns true if this device is blocked
      *
-     * @return {Boolean} true if blocked
+     * @returns true if blocked
      */
     public isBlocked(): boolean {
         return this.verified == DeviceVerification.Blocked;
@@ -152,7 +135,7 @@ export class DeviceInfo {
     /**
      * Returns true if this device is verified
      *
-     * @return {Boolean} true if verified
+     * @returns true if verified
      */
     public isVerified(): boolean {
         return this.verified == DeviceVerification.Verified;
@@ -161,7 +144,7 @@ export class DeviceInfo {
     /**
      * Returns true if this device is unverified
      *
-     * @return {Boolean} true if unverified
+     * @returns true if unverified
      */
     public isUnverified(): boolean {
         return this.verified == DeviceVerification.Unverified;
@@ -170,7 +153,7 @@ export class DeviceInfo {
     /**
      * Returns true if the user knows about this device's existence
      *
-     * @return {Boolean} true if known
+     * @returns true if known
      */
     public isKnown(): boolean {
         return this.known === true;
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 9163ace4f71..65b43a635a0 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -17,10 +17,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module crypto
- */
-
 import anotherjson from "another-json";
 import { v4 as uuidv4 } from "uuid";
 
@@ -128,7 +124,12 @@ interface IInitOpts {
 }
 
 export interface IBootstrapCrossSigningOpts {
+    /** Optional. Reset even if keys already exist. */
     setupNewCrossSigning?: boolean;
+    /**
+     * A function that makes the request requiring auth. Receives the auth data as an object.
+     * Can be called multiple times, first with an empty authDict, to obtain the flows.
+     */
     authUploadDeviceSigningKeys?(makeRequest: (authData: any) => Promise<{}>): Promise<void>;
 }
 
@@ -161,18 +162,32 @@ interface IRoomKey {
     algorithm: string;
 }
 
+/**
+ * The parameters of a room key request. The details of the request may
+ * vary with the crypto algorithm, but the management and storage layers for
+ * outgoing requests expect it to have 'room_id' and 'session_id' properties.
+ */
 export interface IRoomKeyRequestBody extends IRoomKey {
     session_id: string;
     sender_key: string;
 }
 
-export interface IMegolmSessionData {
-    [key: string]: any; // extensible
+interface Extensible {
+    [key: string]: any;
+}
+
+export interface IMegolmSessionData extends Extensible {
+    // Sender's Curve25519 device key
     sender_key: string;
+    // Devices which forwarded this session to us (normally empty).
     forwarding_curve25519_key_chain: string[];
+    // Other keys the sender claims.
     sender_claimed_keys: Record<string, string>;
+    // Room this session is used in
     room_id: string;
+    // Unique id for the session
     session_id: string;
+    // Base64'ed key data
     session_key: string;
     algorithm?: string;
     untrusted?: boolean;
@@ -188,13 +203,6 @@ export interface ICheckOwnCrossSigningTrustOpts {
     allowPrivateKeyRequests?: boolean;
 }
 
-/**
- * @typedef {Object} module:crypto~OlmSessionResult
- * @property {module:crypto/deviceinfo} device  device info
- * @property {string?} sessionId base64 olm session id; null if no session
- *    could be established
- */
-
 interface IUserOlmSession {
     deviceIdKey: string;
     sessions: {
@@ -213,10 +221,26 @@ interface ISignableObject {
     unsigned?: object;
 }
 
+/**
+ * The result of a (successful) call to decryptEvent.
+ */
 export interface IEventDecryptionResult {
+    /**
+     * The plaintext payload for the event (typically containing <tt>type</tt> and <tt>content</tt> fields).
+     */
     clearEvent: IClearEvent;
+    /**
+     * List of curve25519 keys involved in telling us about the senderCurve25519Key and claimedEd25519Key.
+     * See {@link MatrixEvent#getForwardingCurve25519KeyChain}.
+     */
     forwardingCurve25519KeyChain?: string[];
+    /**
+     * Key owned by the sender of this event.  See {@link MatrixEvent#getSenderKey}.
+     */
     senderCurve25519Key?: string;
+    /**
+     * ed25519 key claimed by the sender of this event. See {@link MatrixEvent#getClaimedEd25519Key}.
+     */
     claimedEd25519Key?: string;
     untrusted?: boolean;
 }
@@ -266,10 +290,50 @@ export enum CryptoEvent {
 }
 
 export type CryptoEventHandlerMap = {
+    /**
+     * Fires when a device is marked as verified/unverified/blocked/unblocked by
+     * {@link MatrixClient#setDeviceVerified|MatrixClient.setDeviceVerified} or
+     * {@link MatrixClient#setDeviceBlocked|MatrixClient.setDeviceBlocked}.
+     *
+     * @param userId - the owner of the verified device
+     * @param deviceId - the id of the verified device
+     * @param deviceInfo - updated device information
+     */
     [CryptoEvent.DeviceVerificationChanged]: (userId: string, deviceId: string, device: DeviceInfo) => void;
+    /**
+     * Fires when the trust status of a user changes
+     * If userId is the userId of the logged-in user, this indicated a change
+     * in the trust status of the cross-signing data on the account.
+     *
+     * The cross-signing API is currently UNSTABLE and may change without notice.
+     * @experimental
+     *
+     * @param userId - the userId of the user in question
+     * @param trustLevel - The new trust level of the user
+     */
     [CryptoEvent.UserTrustStatusChanged]: (userId: string, trustLevel: UserTrustLevel) => void;
+    /**
+     * Fires when we receive a room key request
+     *
+     * @param req - request details
+     */
     [CryptoEvent.RoomKeyRequest]: (request: IncomingRoomKeyRequest) => void;
+    /**
+     * Fires when we receive a room key request cancellation
+     */
     [CryptoEvent.RoomKeyRequestCancellation]: (request: IncomingRoomKeyRequestCancellation) => void;
+    /**
+     * Fires whenever the status of e2e key backup changes, as returned by getKeyBackupEnabled()
+     * @param enabled - true if key backup has been enabled, otherwise false
+     * @example
+     * ```
+     * matrixClient.on("crypto.keyBackupStatus", function(enabled){
+     *   if (enabled) {
+     *     [...]
+     *   }
+     * });
+     * ```
+     */
     [CryptoEvent.KeyBackupStatus]: (enabled: boolean) => void;
     [CryptoEvent.KeyBackupFailed]: (errcode: string) => void;
     [CryptoEvent.KeyBackupSessionsRemaining]: (remaining: number) => void;
@@ -277,18 +341,50 @@ export type CryptoEventHandlerMap = {
         failures: IUploadKeySignaturesResponse["failures"],
         source: "checkOwnCrossSigningTrust" | "afterCrossSigningLocalKeyChange" | "setDeviceVerification",
         upload: (opts: { shouldEmit: boolean }) => Promise<void>
-    ) => void;
+    ) => void;/**
+     * Fires when a key verification is requested.
+     */
     [CryptoEvent.VerificationRequest]: (request: VerificationRequest<any>) => void;
+    /**
+     * Fires when the app may wish to warn the user about something related
+     * the end-to-end crypto.
+     *
+     * @param type - One of the strings listed above
+     */
     [CryptoEvent.Warning]: (type: string) => void;
+    /**
+     * Fires when the user's cross-signing keys have changed or cross-signing
+     * has been enabled/disabled. The client can use getStoredCrossSigningForUser
+     * with the user ID of the logged in user to check if cross-signing is
+     * enabled on the account. If enabled, it can test whether the current key
+     * is trusted using with checkUserTrust with the user ID of the logged
+     * in user. The checkOwnCrossSigningTrust function may be used to reconcile
+     * the trust in the account key.
+     *
+     * The cross-signing API is currently UNSTABLE and may change without notice.
+     * @experimental
+     */
     [CryptoEvent.KeysChanged]: (data: {}) => void;
+    /**
+     * Fires whenever the stored devices for a user will be updated
+     * @param users - A list of user IDs that will be updated
+     * @param initialFetch - If true, the store is empty (apart
+     *     from our own device) and is being seeded.
+     */
     [CryptoEvent.WillUpdateDevices]: (users: string[], initialFetch: boolean) => void;
+    /**
+     * Fires whenever the stored devices for a user have changed
+     * @param users - A list of user IDs that were updated
+     * @param initialFetch - If true, the store was empty (apart
+     *     from our own device) and has been seeded.
+     */
     [CryptoEvent.DevicesUpdated]: (users: string[], initialFetch: boolean) => void;
     [CryptoEvent.UserCrossSigningUpdated]: (userId: string) => void;
 };
 
 export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap> {
     /**
-     * @return {string} The version of Olm.
+     * @returns The version of Olm.
      */
     public static getOlmVersion(): [number, number, number] {
         return OlmDevice.getOlmVersion();
@@ -362,25 +458,21 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * This module is internal to the js-sdk; the public API is via MatrixClient.
      *
-     * @constructor
-     * @alias module:crypto
-     *
      * @internal
      *
-     * @param {MatrixClient} baseApis base matrix api interface
+     * @param baseApis - base matrix api interface
      *
-     * @param {string} userId The user ID for the local user
+     * @param userId - The user ID for the local user
      *
-     * @param {string} deviceId The identifier for this device.
+     * @param deviceId - The identifier for this device.
      *
-     * @param {Object} clientStore the MatrixClient data store.
+     * @param clientStore - the MatrixClient data store.
      *
-     * @param {module:crypto/store/base~CryptoStore} cryptoStore
-     *    storage for the crypto layer.
+     * @param cryptoStore - storage for the crypto layer.
      *
-     * @param {RoomList} roomList An initialised RoomList object
+     * @param roomList - An initialised RoomList object
      *
-     * @param {Array} verificationMethods Array of verification methods to use.
+     * @param verificationMethods - Array of verification methods to use.
      *    Each element can either be a string from MatrixClient.verificationMethods
      *    or a class that implements a verification method.
      */
@@ -488,8 +580,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * Returns a promise which resolves once the crypto module is ready for use.
      *
-     * @param {Object} opts keyword arguments.
-     * @param {string} opts.exportedOlmDevice (Optional) data from exported device
+     * @param exportedOlmDevice - (Optional) data from exported device
      *     that must be re-created.
      */
     public async init({ exportedOlmDevice, pickleKey }: IInitOpts = {}): Promise<void> {
@@ -556,7 +647,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * Default: true
      *
-     * @return {boolean} True if trusting cross-signed devices
+     * @returns True if trusting cross-signed devices
      */
     public getCryptoTrustCrossSignedDevices(): boolean {
         return this.trustCrossSignedDevices;
@@ -567,7 +658,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
      * This may be set before initCrypto() is called to ensure no races occur.
      *
-     * @param {boolean} val True to trust cross-signed devices
+     * @param val - True to trust cross-signed devices
      */
     public setCryptoTrustCrossSignedDevices(val: boolean): void {
         this.trustCrossSignedDevices = val;
@@ -593,10 +684,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Create a recovery key from a user-supplied passphrase.
      *
-     * @param {string} password Passphrase string that can be entered by the user
+     * @param password - Passphrase string that can be entered by the user
      *     when restoring the backup as an alternative to entering the recovery key.
      *     Optional.
-     * @returns {Promise<Object>} Object with public key metadata, encoded private
+     * @returns Object with public key metadata, encoded private
      *     recovery key which should be disposed of after displaying to the user,
      *     and raw private key to avoid round tripping if needed.
      */
@@ -639,7 +730,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @return {boolean} True if cross-signing is ready to be used on this device
+     * @returns True if cross-signing is ready to be used on this device
      */
     public async isCrossSigningReady(): Promise<boolean> {
         const publicKeysOnDevice = this.crossSigningInfo.getId();
@@ -664,7 +755,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @return {boolean} True if secret storage is ready to be used on this device
+     * @returns True if secret storage is ready to be used on this device
      */
     public async isSecretStorageReady(): Promise<boolean> {
         const secretStorageKeyInAccount = await this.secretStorage.hasKey();
@@ -694,12 +785,12 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * The cross-signing API is currently UNSTABLE and may change without notice.
      *
-     * @param {function} opts.authUploadDeviceSigningKeys Function
+     * @param authUploadDeviceSigningKeys - Function
      * called to await an interactive auth flow when uploading device signing keys.
-     * @param {boolean} [opts.setupNewCrossSigning] Optional. Reset even if keys
+     * @param setupNewCrossSigning - Optional. Reset even if keys
      * already exist.
      * Args:
-     *     {function} A function that makes the request requiring auth. Receives the
+     *     A function that makes the request requiring auth. Receives the
      *     auth data as an object. Can be called multiple times, first with an empty
      *     authDict, to obtain the flows.
      */
@@ -837,23 +928,22 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *
      * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
      *
-     * @param {function} [opts.createSecretStorageKey] Optional. Function
+     * @param createSecretStorageKey - Optional. Function
      * called to await a secret storage key creation flow.
-     * Returns:
-     *     {Promise<Object>} Object with public key metadata, encoded private
+     *     Returns a Promise which resolves to an object with public key metadata, encoded private
      *     recovery key which should be disposed of after displaying to the user,
      *     and raw private key to avoid round tripping if needed.
-     * @param {object} [opts.keyBackupInfo] The current key backup object. If passed,
+     * @param keyBackupInfo - The current key backup object. If passed,
      * the passphrase and recovery key from this backup will be used.
-     * @param {boolean} [opts.setupNewKeyBackup] If true, a new key backup version will be
+     * @param setupNewKeyBackup - If true, a new key backup version will be
      * created and the private key stored in the new SSSS store. Ignored if keyBackupInfo
      * is supplied.
-     * @param {boolean} [opts.setupNewSecretStorage] Optional. Reset even if keys already exist.
-     * @param {func} [opts.getKeyBackupPassphrase] Optional. Function called to get the user's
+     * @param setupNewSecretStorage - Optional. Reset even if keys already exist.
+     * @param getKeyBackupPassphrase - Optional. Function called to get the user's
      *     current key backup passphrase. Should return a promise that resolves with a Buffer
      *     containing the key, or rejects if the key cannot be obtained.
      * Returns:
-     *     {Promise} A promise which resolves to key creation data for
+     *     A promise which resolves to key creation data for
      *     SecretStorage#addKey: an object with `passphrase` etc fields.
      */
     // TODO this does not resolve with what it says it does
@@ -1150,9 +1240,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * This can be used by the getSecretStorageKey callback to verify that the
      * private key it is about to supply is the one that was requested.
      *
-     * @param {Uint8Array} privateKey The private key
-     * @param {string} expectedPublicKey The public key
-     * @returns {boolean} true if the key matches, otherwise false
+     * @param privateKey - The private key
+     * @param expectedPublicKey - The public key
+     * @returns true if the key matches, otherwise false
      */
     public checkSecretStoragePrivateKey(privateKey: Uint8Array, expectedPublicKey: string): boolean {
         let decryption: PkDecryption | null = null;
@@ -1168,7 +1258,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
     /**
      * Fetches the backup private key, if cached
-     * @returns {Promise} the key, if any, or null
+     * @returns the key, if any, or null
      */
     public async getSessionBackupPrivateKey(): Promise<Uint8Array | null> {
         let key = await new Promise<any>((resolve) => { // TODO types
@@ -1200,8 +1290,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
     /**
      * Stores the session backup key to the cache
-     * @param {Uint8Array} key the private key
-     * @returns {Promise} so you can catch failures
+     * @param key - the private key
+     * @returns a promise so you can catch failures
      */
     public async storeSessionBackupPrivateKey(key: ArrayLike<number>): Promise<void> {
         if (!(key instanceof Uint8Array)) {
@@ -1223,9 +1313,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * This can be used by the getCrossSigningKey callback to verify that the
      * private key it is about to supply is the one that was requested.
      *
-     * @param {Uint8Array} privateKey The private key
-     * @param {string} expectedPublicKey The public key
-     * @returns {boolean} true if the key matches, otherwise false
+     * @param privateKey - The private key
+     * @param expectedPublicKey - The public key
+     * @returns true if the key matches, otherwise false
      */
     public checkCrossSigningPrivateKey(privateKey: Uint8Array, expectedPublicKey: string): boolean {
         let signing: PkSigning | null = null;
@@ -1328,8 +1418,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Check if a user's cross-signing key is a candidate for upgrading from device
      * verification.
      *
-     * @param {string} userId the user whose cross-signing information is to be checked
-     * @param {object} crossSigningInfo the cross-signing information to check
+     * @param userId - the user whose cross-signing information is to be checked
+     * @param crossSigningInfo - the cross-signing information to check
      */
     private async checkForDeviceVerificationUpgrade(
         userId: string,
@@ -1357,9 +1447,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Check if the cross-signing key is signed by a verified device.
      *
-     * @param {string} userId the user ID whose key is being checked
-     * @param {object} key the key that is being checked
-     * @param {object} devices the user's devices.  Should be a map from device ID
+     * @param userId - the user ID whose key is being checked
+     * @param key - the key that is being checked
+     * @param devices - the user's devices.  Should be a map from device ID
      *     to device info
      */
     private async checkForValidDeviceSignature(
@@ -1392,10 +1482,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get the user's cross-signing key ID.
      *
-     * @param {string} [type=master] The type of key to get the ID of.  One of
+     * @param type - The type of key to get the ID of.  One of
      *     "master", "self_signing", or "user_signing".  Defaults to "master".
      *
-     * @returns {string} the key ID
+     * @returns the key ID
      */
     public getCrossSigningId(type: string): string | null {
         return this.crossSigningInfo.getId(type);
@@ -1404,9 +1494,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get the cross signing information for a given user.
      *
-     * @param {string} userId the user ID to get the cross-signing info for.
+     * @param userId - the user ID to get the cross-signing info for.
      *
-     * @returns {CrossSigningInfo} the cross signing information for the user.
+     * @returns the cross signing information for the user.
      */
     public getStoredCrossSigningForUser(userId: string): CrossSigningInfo | null {
         return this.deviceList.getStoredCrossSigningForUser(userId);
@@ -1415,9 +1505,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Check whether a given user is trusted.
      *
-     * @param {string} userId The ID of the user to check.
+     * @param userId - The ID of the user to check.
      *
-     * @returns {UserTrustLevel}
+     * @returns
      */
     public checkUserTrust(userId: string): UserTrustLevel {
         const userCrossSigning = this.deviceList.getStoredCrossSigningForUser(userId);
@@ -1430,10 +1520,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Check whether a given device is trusted.
      *
-     * @param {string} userId The ID of the user whose devices is to be checked.
-     * @param {string} deviceId The ID of the device to check
+     * @param userId - The ID of the user whose devices is to be checked.
+     * @param deviceId - The ID of the device to check
      *
-     * @returns {DeviceTrustLevel}
+     * @returns
      */
     public checkDeviceTrust(userId: string, deviceId: string): DeviceTrustLevel {
         const device = this.deviceList.getStoredDevice(userId, deviceId);
@@ -1443,10 +1533,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Check whether a given deviceinfo is trusted.
      *
-     * @param {string} userId The ID of the user whose devices is to be checked.
-     * @param {module:crypto/deviceinfo?} device The device info object to check
+     * @param userId - The ID of the user whose devices is to be checked.
+     * @param device - The device info object to check
      *
-     * @returns {DeviceTrustLevel}
+     * @returns
      */
     public checkDeviceInfoTrust(userId: string, device?: DeviceInfo): DeviceTrustLevel {
         const trustedLocally = !!device?.isVerified();
@@ -1468,9 +1558,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Check whether one of our own devices is cross-signed by our
      * user's stored keys, regardless of whether we trust those keys yet.
      *
-     * @param {string} deviceId The ID of the device to check
+     * @param deviceId - The ID of the device to check
      *
-     * @returns {boolean} true if the device is cross-signed
+     * @returns true if the device is cross-signed
      */
     public checkIfOwnDeviceCrossSigned(deviceId: string): boolean {
         const device = this.deviceList.getStoredDevice(this.userId, deviceId);
@@ -1712,7 +1802,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Store a set of keys as our own, trusted, cross-signing keys.
      *
-     * @param {object} keys The new trusted set of keys
+     * @param keys - The new trusted set of keys
      */
     private async storeTrustedSelfKeys(keys: Record<string, ICrossSigningKey> | null): Promise<void> {
         if (keys) {
@@ -1732,7 +1822,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Check if the master key is signed by a verified device, and if so, prompt
      * the application to mark it as verified.
      *
-     * @param {string} userId the user ID whose key should be checked
+     * @param userId - the user ID whose key should be checked
      */
     private async checkDeviceVerifications(userId: string): Promise<void> {
         const shouldUpgradeCb = (
@@ -1774,7 +1864,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Tell the crypto module to register for MatrixClient events which it needs to
      * listen for
      *
-     * @param {external:EventEmitter} eventEmitter event source where we can register
+     * @param eventEmitter - event source where we can register
      *    for event notifications
      */
     public registerEventHandlers(eventEmitter: TypedEventEmitter<
@@ -1804,7 +1894,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get the Ed25519 key for this device
      *
-     * @return {string} base64-encoded ed25519 key.
+     * @returns base64-encoded ed25519 key.
      */
     public getDeviceEd25519Key(): string | null {
         return this.olmDevice.deviceEd25519Key;
@@ -1813,7 +1903,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get the Curve25519 key for this device
      *
-     * @return {string} base64-encoded curve25519 key.
+     * @returns base64-encoded curve25519 key.
      */
     public getDeviceCurve25519Key(): string | null {
         return this.olmDevice.deviceCurve25519Key;
@@ -1824,20 +1914,20 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * messages to unverified devices.  This provides the default for rooms which
      * do not specify a value.
      *
-     * @param {boolean} value whether to blacklist all unverified devices by default
+     * @param value - whether to blacklist all unverified devices by default
      *
      * @deprecated For external code, use {@link MatrixClient#setGlobalBlacklistUnverifiedDevices}. For
-     *   internal code, set {@link #globalBlacklistUnverifiedDevices} directly.
+     *   internal code, set {@link MatrixClient#globalBlacklistUnverifiedDevices} directly.
      */
     public setGlobalBlacklistUnverifiedDevices(value: boolean): void {
         this.globalBlacklistUnverifiedDevices = value;
     }
 
     /**
-     * @return {boolean} whether to blacklist all unverified devices by default
+     * @returns whether to blacklist all unverified devices by default
      *
      * @deprecated For external code, use {@link MatrixClient#getGlobalBlacklistUnverifiedDevices}. For
-     *   internal code, reference {@link #globalBlacklistUnverifiedDevices} directly.
+     *   internal code, reference {@link MatrixClient#globalBlacklistUnverifiedDevices} directly.
      */
     public getGlobalBlacklistUnverifiedDevices(): boolean {
         return this.globalBlacklistUnverifiedDevices;
@@ -1845,7 +1935,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
     /**
      * Upload the device keys to the homeserver.
-     * @return {object} A promise that will resolve when the keys are uploaded.
+     * @returns A promise that will resolve when the keys are uploaded.
      */
     public uploadDeviceKeys(): Promise<IKeysUploadResponse> {
         const deviceKeys = {
@@ -1866,7 +1956,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Stores the current one_time_key count which will be handled later (in a call of
      * onSyncCompleted). The count is e.g. coming from a /sync response.
      *
-     * @param {Number} currentCount The current count of one_time_keys to be stored
+     * @param currentCount - The current count of one_time_keys to be stored
      */
     public updateOneTimeKeyCount(currentCount: number): void {
         if (isFinite(currentCount)) {
@@ -2056,11 +2146,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Download the keys for a list of users and stores the keys in the session
      * store.
-     * @param {Array} userIds The users to fetch.
-     * @param {boolean} forceDownload Always download the keys even if cached.
+     * @param userIds - The users to fetch.
+     * @param forceDownload - Always download the keys even if cached.
      *
-     * @return {Promise} A promise which resolves to a map userId->deviceId->{@link
-        * module:crypto/deviceinfo|DeviceInfo}.
+     * @returns A promise which resolves to a map `userId->deviceId->{@link DeviceInfo}`.
      */
     public downloadKeys(userIds: string[], forceDownload?: boolean): Promise<DeviceInfoMap> {
         return this.deviceList.downloadKeys(userIds, !!forceDownload);
@@ -2069,9 +2158,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get the stored device keys for a user id
      *
-     * @param {string} userId the user to list keys for.
+     * @param userId - the user to list keys for.
      *
-     * @return {module:crypto/deviceinfo[]|null} list of devices, or null if we haven't
+     * @returns list of devices, or null if we haven't
      * managed to get a list of devices for this user yet.
      */
     public getStoredDevicesForUser(userId: string): Array<DeviceInfo> | null {
@@ -2081,10 +2170,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get the stored keys for a single device
      *
-     * @param {string} userId
-     * @param {string} deviceId
      *
-     * @return {module:crypto/deviceinfo?} device, or undefined
+     * @returns device, or undefined
      * if we don't know about this device
      */
     public getStoredDevice(userId: string, deviceId: string): DeviceInfo | undefined {
@@ -2094,11 +2181,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Save the device list, if necessary
      *
-     * @param {number} delay Time in ms before which the save actually happens.
+     * @param delay - Time in ms before which the save actually happens.
      *     By default, the save is delayed for a short period in order to batch
      *     multiple writes, but this behaviour can be disabled by passing 0.
      *
-     * @return {Promise<boolean>} true if the data was saved, false if
+     * @returns true if the data was saved, false if
      *     it was not (eg. because no changes were pending). The promise
      *     will only resolve once the data is saved, so may take some time
      *     to resolve.
@@ -2110,24 +2197,24 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Update the blocked/verified state of the given device
      *
-     * @param {string} userId owner of the device
-     * @param {string} deviceId unique identifier for the device or user's
+     * @param userId - owner of the device
+     * @param deviceId - unique identifier for the device or user's
      * cross-signing public key ID.
      *
-     * @param {?boolean} verified whether to mark the device as verified. Null to
+     * @param verified - whether to mark the device as verified. Null to
      *     leave unchanged.
      *
-     * @param {?boolean} blocked whether to mark the device as blocked. Null to
+     * @param blocked - whether to mark the device as blocked. Null to
      *      leave unchanged.
      *
-     * @param {?boolean} known whether to mark that the user has been made aware of
+     * @param known - whether to mark that the user has been made aware of
      *      the existence of this device. Null to leave unchanged
      *
-     * @param {?Record<string, any>} keys The list of keys that was present
+     * @param keys - The list of keys that was present
      * during the device verification. This will be double checked with the list
      * of keys the given device has currently.
      *
-     * @return {Promise<module:crypto/deviceinfo>} updated DeviceInfo
+     * @returns updated DeviceInfo
      */
     public async setDeviceVerification(
         userId: string,
@@ -2392,13 +2479,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Returns a map from device id to an object with keys 'deviceIdKey' (the
      * device's curve25519 identity key) and 'sessions' (an array of objects in the
      * same format as that returned by
-     * {@link module:crypto/OlmDevice#getSessionInfoForDevice}).
+     * {@link OlmDevice#getSessionInfoForDevice}).
      * <p>
      * This method is provided for debugging purposes.
      *
-     * @param {string} userId id of user to inspect
-     *
-     * @return {Promise<Object.<string, {deviceIdKey: string, sessions: object[]}>>}
+     * @param userId - id of user to inspect
      */
     public async getOlmSessionsForUser(userId: string): Promise<Record<string, IUserOlmSession>> {
         const devices = this.getStoredDevicesForUser(userId) || [];
@@ -2418,9 +2503,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get the device which sent an event
      *
-     * @param {module:models/event.MatrixEvent} event event to be checked
-     *
-     * @return {module:crypto/deviceinfo?}
+     * @param event - event to be checked
      */
     public getEventSenderDeviceInfo(event: MatrixEvent): DeviceInfo | null {
         const senderKey = event.getSenderKey();
@@ -2476,9 +2559,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get information about the encryption of an event
      *
-     * @param {module:models/event.MatrixEvent} event event to be checked
+     * @param event - event to be checked
      *
-     * @return {object} An object with the fields:
+     * @returns An object with the fields:
      *    - encrypted: whether the event is encrypted (if not encrypted, some of the
      *      other properties may not be set)
      *    - senderKey: the sender's key
@@ -2544,7 +2627,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Forces the current outbound group session to be discarded such
      * that another one will be created next time an event is sent.
      *
-     * @param {string} roomId The ID of the room to discard the session for
+     * @param roomId - The ID of the room to discard the session for
      *
      * This should not normally be necessary.
      */
@@ -2560,11 +2643,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Configure a room to use encryption (ie, save a flag in the cryptoStore).
      *
-     * @param {string} roomId The room ID to enable encryption in.
+     * @param roomId - The room ID to enable encryption in.
      *
-     * @param {object} config The encryption config for the room.
+     * @param config - The encryption config for the room.
      *
-     * @param {boolean=} inhibitDeviceQuery true to suppress device list query for
+     * @param inhibitDeviceQuery - true to suppress device list query for
      *   users in the room (for now). In case lazy loading is enabled,
      *   the device query is always inhibited as the members are not tracked.
      *
@@ -2597,8 +2680,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * It does <em>not</em> initiate a device list query for the room. That is normally
      * done once we finish processing the sync, in onSyncCompleted.
      *
-     * @param room The room to enable encryption in.
-     * @param config The encryption config for the room.
+     * @param room - The room to enable encryption in.
+     * @param config - The encryption config for the room.
      */
     private async setRoomEncryptionImpl(
         room: Room,
@@ -2682,8 +2765,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Make sure we are tracking the device lists for all users in this room.
      *
-     * @param {string} roomId The room ID to start tracking devices in.
-     * @returns {Promise} when all devices for the room have been fetched and marked to track
+     * @param roomId - The room ID to start tracking devices in.
+     * @returns when all devices for the room have been fetched and marked to track
      */
     public trackRoomDevices(roomId: string): Promise<void> {
         const room = this.clientStore.getRoom(roomId);
@@ -2701,7 +2784,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * m.room.encryption state event (if lazy-loading is disabled), or when members are
      * loaded (if lazy-loading is enabled), to prepare the device list.
      *
-     * @param room Room to enable device-list tracking in
+     * @param room - Room to enable device-list tracking in
      */
     private trackRoomDevicesImpl(room: Room): Promise<void> {
         const roomId = room.roomId;
@@ -2732,12 +2815,12 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Try to make sure we have established olm sessions for all known devices for
      * the given users.
      *
-     * @param {string[]} users list of user ids
-     * @param {boolean} force If true, force a new Olm session to be created. Default false.
+     * @param users - list of user ids
+     * @param force - If true, force a new Olm session to be created. Default false.
      *
-     * @return {Promise} resolves once the sessions are complete, to
+     * @returns resolves once the sessions are complete, to
      *    an Object mapping from userId to deviceId to
-     *    {@link module:crypto~OlmSessionResult}
+     *    {@link OlmSessionResult}
      */
     public ensureOlmSessionsForUsers(
         users: string[],
@@ -2770,7 +2853,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get a list containing all of the room keys
      *
-     * @return {module:crypto/OlmDevice.MegolmSessionData[]} a list of session export objects
+     * @returns a list of session export objects
      */
     public async exportRoomKeys(): Promise<IMegolmSessionData[]> {
         const exportedSessions: IMegolmSessionData[] = [];
@@ -2793,10 +2876,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Import a list of room keys previously exported by exportRoomKeys
      *
-     * @param {Object[]} keys a list of session export objects
-     * @param {Object} opts
-     * @param {Function} opts.progressCallback called with an object which has a stage param
-     * @return {Promise} a promise which resolves once the keys have been imported
+     * @param keys - a list of session export objects
+     * @returns a promise which resolves once the keys have been imported
      */
     public importRoomKeys(keys: IMegolmSessionData[], opts: IImportRoomKeysOpts = {}): Promise<void> {
         let successes = 0;
@@ -2830,7 +2911,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
     /**
      * Counts the number of end to end session keys that are waiting to be backed up
-     * @returns {Promise<number>} Resolves to the number of sessions requiring backup
+     * @returns Promise which resolves to the number of sessions requiring backup
      */
     public countSessionsNeedingBackup(): Promise<number> {
         return this.backupManager.countSessionsNeedingBackup();
@@ -2840,7 +2921,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Perform any background tasks that can be done before a message is ready to
      * send, in order to speed up sending of the message.
      *
-     * @param {module:models/room} room the room the event is in
+     * @param room - the room the event is in
      */
     public prepareToEncrypt(room: Room): void {
         const alg = this.roomEncryptors.get(room.roomId);
@@ -2852,11 +2933,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Encrypt an event according to the configuration of the room.
      *
-     * @param {module:models/event.MatrixEvent} event  event to be sent
+     * @param event -  event to be sent
      *
-     * @param {module:models/room} room destination room.
+     * @param room - destination room.
      *
-     * @return {Promise?} Promise which resolves when the event has been
+     * @returns Promise which resolves when the event has been
      *     encrypted, or null if nothing was needed
      */
     public async encryptEvent(event: MatrixEvent, room?: Room): Promise<void> {
@@ -2917,9 +2998,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Decrypt a received event
      *
-     * @param {MatrixEvent} event
      *
-     * @return {Promise<module:crypto~EventDecryptionResult>} resolves once we have
+     * @returns resolves once we have
      *  finished decrypting. Rejects with an `algorithms.DecryptionError` if there
      *  is a problem decrypting the event.
      */
@@ -2952,8 +3032,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Handle the notification from /sync or /keys/changes that device lists have
      * been changed.
      *
-     * @param {Object} syncData Object containing sync tokens associated with this sync
-     * @param {Object} syncDeviceLists device_lists field from /sync, or response from
+     * @param syncData - Object containing sync tokens associated with this sync
+     * @param syncDeviceLists - device_lists field from /sync, or response from
      * /keys/changes
      */
     public async handleDeviceListChanges(
@@ -2978,12 +3058,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Send a request for some room keys, if we have not already done so
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     * @param {Array<{userId: string, deviceId: string}>} recipients
-     * @param {boolean} resend whether to resend the key request if there is
+     * @param resend - whether to resend the key request if there is
      *    already one
      *
-     * @return {Promise} a promise that resolves when the key request is queued
+     * @returns a promise that resolves when the key request is queued
      */
     public requestRoomKey(
         requestBody: IRoomKeyRequestBody,
@@ -3007,8 +3085,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Cancel any earlier room key request
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     *    parameters to match for cancellation
+     * @param requestBody - parameters to match for cancellation
      */
     public cancelRoomKeyRequest(requestBody: IRoomKeyRequestBody): void {
         this.outgoingRoomKeyRequestManager.cancelRoomKeyRequest(requestBody)
@@ -3019,7 +3096,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
     /**
      * Re-send any outgoing key requests, eg after verification
-     * @returns {Promise}
+     * @returns
      */
     public async cancelAndResendAllOutgoingKeyRequests(): Promise<void> {
         await this.outgoingRoomKeyRequestManager.cancelAndResendAllOutgoingRequests();
@@ -3028,8 +3105,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * handle an m.room.encryption event
      *
-     * @param room in which the event was received
-     * @param event encryption event to be processed
+     * @param room - in which the event was received
+     * @param event - encryption event to be processed
      */
     public async onCryptoEvent(room: Room, event: MatrixEvent): Promise<void> {
         const content = event.getContent<IRoomEncryption>();
@@ -3039,7 +3116,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Called before the result of a sync is processed
      *
-     * @param {Object} syncData  the data from the 'MatrixClient.sync' event
+     * @param syncData -  the data from the 'MatrixClient.sync' event
      */
     public async onSyncWillProcess(syncData: ISyncStateData): Promise<void> {
         if (!syncData.oldSyncToken) {
@@ -3063,7 +3140,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * This is called after the processing of each successful /sync response.
      * It is an opportunity to do a batch process on the information received.
      *
-     * @param {Object} syncData  the data from the 'MatrixClient.sync' event
+     * @param syncData -  the data from the 'MatrixClient.sync' event
      */
     public async onSyncCompleted(syncData: ISyncStateData): Promise<void> {
         this.deviceList.setSyncToken(syncData.nextSyncToken ?? null);
@@ -3096,7 +3173,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Trigger the appropriate invalidations and removes for a given
      * device list
      *
-     * @param {Object} deviceLists device_lists field from /sync, or response from
+     * @param deviceLists - device_lists field from /sync, or response from
      * /keys/changes
      */
     private async evalDeviceListChanges(deviceLists: Required<ISyncResponse>["device_lists"]): Promise<void> {
@@ -3124,7 +3201,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Get a list of all the IDs of users we share an e2e room with
      * for which we are tracking devices already
      *
-     * @returns {string[]} List of user IDs
+     * @returns List of user IDs
      */
     private async getTrackedE2eUsers(): Promise<string[]> {
         const e2eUserIds: string[] = [];
@@ -3141,7 +3218,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Get a list of the e2e-enabled rooms we are members of,
      * and for which we are already tracking the devices
      *
-     * @returns {module:models.Room[]}
+     * @returns
      */
     private getTrackedE2eRooms(): Room[] {
         return this.clientStore.getRooms().filter((room) => {
@@ -3163,11 +3240,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Encrypts and sends a given object via Olm to-device messages to a given
      * set of devices.
-     * @param {object[]} userDeviceInfoArr the devices to send to
-     * @param {object} payload fields to include in the encrypted payload
-     * @return {Promise<{contentMap, deviceInfoByDeviceId}>} Promise which
+     * @param userDeviceInfoArr - the devices to send to
+     * @param payload - fields to include in the encrypted payload
+     * @returns Promise which
      *     resolves once the message has been encrypted and sent to the given
-     *     userDeviceMap, and returns the { contentMap, deviceInfoByDeviceId }
+     *     userDeviceMap, and returns the `{ contentMap, deviceInfoByDeviceId }`
      *     of the successfully sent messages.
      */
     public async encryptAndSendToDevices(
@@ -3281,8 +3358,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Handle a key event
      *
-     * @private
-     * @param {module:models/event.MatrixEvent} event key event
+     * @internal
+     * @param event - key event
      */
     private onRoomKeyEvent(event: MatrixEvent): void {
         const content = event.getContent();
@@ -3305,8 +3382,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Handle a key withheld event
      *
-     * @private
-     * @param {module:models/event.MatrixEvent} event key withheld event
+     * @internal
+     * @param event - key withheld event
      */
     private onRoomKeyWithheldEvent(event: MatrixEvent): void {
         const content = event.getContent();
@@ -3341,8 +3418,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Handle a general key verification event.
      *
-     * @private
-     * @param {module:models/event.MatrixEvent} event verification start event
+     * @internal
+     * @param event - verification start event
      */
     private onKeyVerificationMessage(event: MatrixEvent): void {
         if (!ToDeviceChannel.validateEvent(event, this.baseApis)) {
@@ -3372,12 +3449,12 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Handle key verification requests sent as timeline events
      *
-     * @private
-     * @param {module:models/event.MatrixEvent} event the timeline event
-     * @param {module:models/Room} room not used
-     * @param {boolean} atStart not used
-     * @param {boolean} removed not used
-     * @param {boolean} { liveEvent } whether this is a live event
+     * @internal
+     * @param event - the timeline event
+     * @param room - not used
+     * @param atStart - not used
+     * @param removed - not used
+     * @param whether - this is a live event
      */
     private onTimelineEvent = (
         event: MatrixEvent,
@@ -3457,8 +3534,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Handle a toDevice event that couldn't be decrypted
      *
-     * @private
-     * @param {module:models/event.MatrixEvent} event undecryptable event
+     * @internal
+     * @param event - undecryptable event
      */
     private async onToDeviceBadEncrypted(event: MatrixEvent): Promise<void> {
         const content = event.getWireContent();
@@ -3565,10 +3642,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Handle a change in the membership state of a member of a room
      *
-     * @private
-     * @param {module:models/event.MatrixEvent} event  event causing the change
-     * @param {module:models/room-member} member  user whose membership changed
-     * @param {string=} oldMembership  previous membership
+     * @internal
+     * @param event -  event causing the change
+     * @param member -  user whose membership changed
+     * @param oldMembership -  previous membership
      */
     private onRoomMembership(event: MatrixEvent, member: RoomMember, oldMembership?: string): void {
         // this event handler is registered on the *client* (as opposed to the room
@@ -3609,8 +3686,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Called when we get an m.room_key_request event.
      *
-     * @private
-     * @param {module:models/event.MatrixEvent} event key request event
+     * @internal
+     * @param event - key request event
      */
     private onRoomKeyRequestEvent(event: MatrixEvent): void {
         const content = event.getContent();
@@ -3630,7 +3707,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * Process any m.room_key_request events which were queued up during the
      * current sync.
      *
-     * @private
+     * @internal
      */
     private async processReceivedRoomKeyRequests(): Promise<void> {
         if (this.processingRoomKeyRequests) {
@@ -3669,7 +3746,6 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Helper for processReceivedRoomKeyRequests
      *
-     * @param {IncomingRoomKeyRequest} req
      */
     private async processReceivedRoomKeyRequest(req: IncomingRoomKeyRequest): Promise<void> {
         const userId = req.userId;
@@ -3759,7 +3835,6 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Helper for processReceivedRoomKeyRequests
      *
-     * @param {IncomingRoomKeyRequestCancellation} cancellation
      */
     private async processReceivedRoomKeyRequestCancellation(
         cancellation: IncomingRoomKeyRequestCancellation,
@@ -3781,17 +3856,14 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * If we already have a decryptor for the given room and algorithm, return
      * it. Otherwise try to instantiate it.
      *
-     * @private
+     * @internal
      *
-     * @param {string?} roomId   room id for decryptor. If undefined, a temporary
+     * @param roomId -   room id for decryptor. If undefined, a temporary
      * decryptor is instantiated.
      *
-     * @param {string} algorithm  crypto algorithm
-     *
-     * @return {module:crypto.algorithms.base.DecryptionAlgorithm}
+     * @param algorithm -  crypto algorithm
      *
-     * @raises {module:crypto.algorithms.DecryptionError} if the algorithm is
-     * unknown
+     * @throws {@link DecryptionError} if the algorithm is unknown
      */
     public getRoomDecryptor(roomId: string | null, algorithm: string): DecryptionAlgorithm {
         let decryptors: Map<string, DecryptionAlgorithm> | undefined;
@@ -3834,9 +3906,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * Get all the room decryptors for a given encryption algorithm.
      *
-     * @param {string} algorithm The encryption algorithm
+     * @param algorithm - The encryption algorithm
      *
-     * @return {array} An array of room decryptors
+     * @returns An array of room decryptors
      */
     private getRoomDecryptors(algorithm: string): DecryptionAlgorithm[] {
         const decryptors: DecryptionAlgorithm[] = [];
@@ -3851,7 +3923,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     /**
      * sign the given object with our ed25519 key
      *
-     * @param {Object} obj  Object to which we will add a 'signatures' property
+     * @param obj -  Object to which we will add a 'signatures' property
      */
     public async signObject<T extends ISignableObject & object>(obj: T): Promise<void> {
         const sigs = obj.signatures || {};
@@ -3874,8 +3946,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
  * passed a string that looks like a list of integers rather than a base64
  * string, it will attempt to convert it to the right format.
  *
- * @param {string} key the key to check
- * @returns {null | string} If the key is in the wrong format, then the fixed
+ * @param key - the key to check
+ * @returns If the key is in the wrong format, then the fixed
  * key will be returned. Otherwise null will be returned.
  *
  */
@@ -3887,30 +3959,22 @@ export function fixBackupKey(key?: string): string | null {
     return olmlib.encodeBase64(fixedKey);
 }
 
-/**
- * The parameters of a room key request. The details of the request may
- * vary with the crypto algorithm, but the management and storage layers for
- * outgoing requests expect it to have 'room_id' and 'session_id' properties.
- *
- * @typedef {Object} RoomKeyRequestBody
- */
-
 /**
  * Represents a received m.room_key_request event
- *
- * @property {string} userId    user requesting the key
- * @property {string} deviceId  device requesting the key
- * @property {string} requestId unique id for the request
- * @property {module:crypto~RoomKeyRequestBody} requestBody
- * @property {function()} share  callback which, when called, will ask
- *    the relevant crypto algorithm implementation to share the keys for
- *    this request.
  */
 export class IncomingRoomKeyRequest {
+    /** user requesting the key */
     public readonly userId: string;
+    /** device requesting the key */
     public readonly deviceId: string;
+    /** unique id for the request */
     public readonly requestId: string;
     public readonly requestBody: IRoomKeyRequestBody;
+    /**
+     * callback which, when called, will ask
+     *    the relevant crypto algorithm implementation to share the keys for
+     *    this request.
+     */
     public share: () => void;
 
     public constructor(event: MatrixEvent) {
@@ -3928,14 +3992,13 @@ export class IncomingRoomKeyRequest {
 
 /**
  * Represents a received m.room_key_request cancellation
- *
- * @property {string} userId    user requesting the cancellation
- * @property {string} deviceId  device requesting the cancellation
- * @property {string} requestId unique id for the request to be cancelled
  */
 class IncomingRoomKeyRequestCancellation {
+    /** user requesting the cancellation */
     public readonly userId: string;
+    /** device requesting the cancellation */
     public readonly deviceId: string;
+    /** unique id for the request to be cancelled */
     public readonly requestId: string;
 
     public constructor(event: MatrixEvent) {
@@ -3946,46 +4009,3 @@ class IncomingRoomKeyRequestCancellation {
         this.requestId = content.request_id;
     }
 }
-
-/**
- * The result of a (successful) call to decryptEvent.
- *
- * @typedef {Object} EventDecryptionResult
- *
- * @property {Object} clearEvent The plaintext payload for the event
- *     (typically containing <tt>type</tt> and <tt>content</tt> fields).
- *
- * @property {?string} senderCurve25519Key Key owned by the sender of this
- *    event.  See {@link module:models/event.MatrixEvent#getSenderKey}.
- *
- * @property {?string} claimedEd25519Key ed25519 key claimed by the sender of
- *    this event. See
- *    {@link module:models/event.MatrixEvent#getClaimedEd25519Key}.
- *
- * @property {?Array<string>} forwardingCurve25519KeyChain list of curve25519
- *     keys involved in telling us about the senderCurve25519Key and
- *     claimedEd25519Key. See
- *     {@link module:models/event.MatrixEvent#getForwardingCurve25519KeyChain}.
- */
-
-/**
- * Fires when we receive a room key request
- *
- * @event module:client~MatrixClient#"crypto.roomKeyRequest"
- * @param {module:crypto~IncomingRoomKeyRequest} req  request details
- */
-
-/**
- * Fires when we receive a room key request cancellation
- *
- * @event module:client~MatrixClient#"crypto.roomKeyRequestCancellation"
- * @param {module:crypto~IncomingRoomKeyRequestCancellation} req
- */
-
-/**
- * Fires when the app may wish to warn the user about something related
- * the end-to-end crypto.
- *
- * @event module:client~MatrixClient#"crypto.warning"
- * @param {string} type One of the strings listed above
- */
diff --git a/src/crypto/keybackup.ts b/src/crypto/keybackup.ts
index 919266a3ef8..67e213c4a92 100644
--- a/src/crypto/keybackup.ts
+++ b/src/crypto/keybackup.ts
@@ -59,6 +59,10 @@ export interface IKeyBackupInfo {
 /* eslint-enable camelcase */
 
 export interface IKeyBackupPrepareOpts {
+    /**
+     * Whether to use Secure Secret Storage to store the key encrypting key backups.
+     * Optional, defaults to false.
+     */
     secureSecretStorage: boolean;
 }
 
diff --git a/src/crypto/olmlib.ts b/src/crypto/olmlib.ts
index 862691353c9..4a228e2814a 100644
--- a/src/crypto/olmlib.ts
+++ b/src/crypto/olmlib.ts
@@ -15,8 +15,6 @@ limitations under the License.
 */
 
 /**
- * @module olmlib
- *
  * Utilities common to olm encryption algorithms
  */
 
@@ -55,22 +53,20 @@ export const MEGOLM_ALGORITHM = Algorithm.Megolm;
 export const MEGOLM_BACKUP_ALGORITHM = Algorithm.MegolmBackup;
 
 export interface IOlmSessionResult {
+    /** device info */
     device: DeviceInfo;
+    /** base64 olm session id; null if no session could be established */
     sessionId: string | null;
 }
 
 /**
  * Encrypt an event payload for an Olm device
  *
- * @param {Object<string, string>} resultsObject  The `ciphertext` property
+ * @param resultsObject -  The `ciphertext` property
  *   of the m.room.encrypted event to which to add our result
  *
- * @param {string} ourUserId
- * @param {string} ourDeviceId
- * @param {module:crypto/OlmDevice} olmDevice olm.js wrapper
- * @param {string} recipientUserId
- * @param {module:crypto/deviceinfo} recipientDevice
- * @param {object} payloadFields fields to include in the encrypted payload
+ * @param olmDevice - olm.js wrapper
+ * @param payloadFields - fields to include in the encrypted payload
  *
  * Returns a promise which resolves (to undefined) when the payload
  *    has been encrypted into `resultsObject`
@@ -145,17 +141,14 @@ interface IExistingOlmSession {
  * Get the existing olm sessions for the given devices, and the devices that
  * don't have olm sessions.
  *
- * @param {module:crypto/OlmDevice} olmDevice
  *
- * @param {MatrixClient} baseApis
  *
- * @param {object<string, module:crypto/deviceinfo[]>} devicesByUser
- *    map from userid to list of devices to ensure sessions for
+ * @param devicesByUser - map from userid to list of devices to ensure sessions for
  *
- * @return {Promise} resolves to an array.  The first element of the array is a
+ * @returns resolves to an array.  The first element of the array is a
  *    a map of user IDs to arrays of deviceInfo, representing the devices that
  *    don't have established olm sessions.  The second element of the array is
- *    a map from userId to deviceId to {@link module:crypto~OlmSessionResult}
+ *    a map from userId to deviceId to {@link OlmSessionResult}
  */
 export async function getExistingOlmSessions(
     olmDevice: OlmDevice,
@@ -197,27 +190,22 @@ export async function getExistingOlmSessions(
 /**
  * Try to make sure we have established olm sessions for the given devices.
  *
- * @param {module:crypto/OlmDevice} olmDevice
- *
- * @param {MatrixClient} baseApis
- *
- * @param {object<string, module:crypto/deviceinfo[]>} devicesByUser
- *    map from userid to list of devices to ensure sessions for
+ * @param devicesByUser - map from userid to list of devices to ensure sessions for
  *
- * @param {boolean} [force=false] If true, establish a new session even if one
+ * @param force - If true, establish a new session even if one
  *     already exists.
  *
- * @param {Number} [otkTimeout] The timeout in milliseconds when requesting
+ * @param otkTimeout - The timeout in milliseconds when requesting
  *     one-time keys for establishing new olm sessions.
  *
- * @param {Array} [failedServers] An array to fill with remote servers that
+ * @param failedServers - An array to fill with remote servers that
  *     failed to respond to one-time-key requests.
  *
- * @param {Logger} [log] A possibly customised log
+ * @param log - A possibly customised log
  *
- * @return {Promise} resolves once the sessions are complete, to
+ * @returns resolves once the sessions are complete, to
  *    an Object mapping from userId to deviceId to
- *    {@link module:crypto~OlmSessionResult}
+ *    {@link OlmSessionResult}
  */
 export async function ensureOlmSessionsForDevices(
     olmDevice: OlmDevice,
@@ -442,15 +430,15 @@ export interface IObject {
 /**
  * Verify the signature on an object
  *
- * @param {module:crypto/OlmDevice} olmDevice olm wrapper to use for verify op
+ * @param olmDevice - olm wrapper to use for verify op
  *
- * @param {Object} obj object to check signature on.
+ * @param obj - object to check signature on.
  *
- * @param {string} signingUserId  ID of the user whose signature should be checked
+ * @param signingUserId -  ID of the user whose signature should be checked
  *
- * @param {string} signingDeviceId  ID of the device whose signature should be checked
+ * @param signingDeviceId -  ID of the device whose signature should be checked
  *
- * @param {string} signingKey   base64-ed ed25519 public key
+ * @param signingKey -   base64-ed ed25519 public key
  *
  * Returns a promise which resolves (to undefined) if the the signature is good,
  * or rejects with an Error if it is bad.
@@ -485,13 +473,13 @@ export async function verifySignature(
 
 /**
  * Sign a JSON object using public key cryptography
- * @param {Object} obj Object to sign.  The object will be modified to include
+ * @param obj - Object to sign.  The object will be modified to include
  *     the new signature
- * @param {Olm.PkSigning|Uint8Array} key the signing object or the private key
+ * @param key - the signing object or the private key
  * seed
- * @param {string} userId The user ID who owns the signing key
- * @param {string} pubKey The public key (ignored if key is a seed)
- * @returns {string} the signature for the object
+ * @param userId - The user ID who owns the signing key
+ * @param pubKey - The public key (ignored if key is a seed)
+ * @returns the signature for the object
  */
 export function pkSign(obj: object & IObject, key: Uint8Array | PkSigning, userId: string, pubKey: string): string {
     let createdKey = false;
@@ -521,9 +509,9 @@ export function pkSign(obj: object & IObject, key: Uint8Array | PkSigning, userI
 
 /**
  * Verify a signed JSON object
- * @param {Object} obj Object to verify
- * @param {string} pubKey The public key to use to verify
- * @param {string} userId The user ID who signed the object
+ * @param obj - Object to verify
+ * @param pubKey - The public key to use to verify
+ * @param userId - The user ID who signed the object
  */
 export function pkVerify(obj: IObject, pubKey: string, userId: string): void {
     const keyId = "ed25519:" + pubKey;
@@ -563,8 +551,8 @@ export function isOlmEncrypted(event: MatrixEvent): boolean {
 
 /**
  * Encode a typed array of uint8 as base64.
- * @param {Uint8Array} uint8Array The data to encode.
- * @return {string} The base64.
+ * @param uint8Array - The data to encode.
+ * @returns The base64.
  */
 export function encodeBase64(uint8Array: ArrayBuffer | Uint8Array): string {
     return Buffer.from(uint8Array).toString("base64");
@@ -572,8 +560,8 @@ export function encodeBase64(uint8Array: ArrayBuffer | Uint8Array): string {
 
 /**
  * Encode a typed array of uint8 as unpadded base64.
- * @param {Uint8Array} uint8Array The data to encode.
- * @return {string} The unpadded base64.
+ * @param uint8Array - The data to encode.
+ * @returns The unpadded base64.
  */
 export function encodeUnpaddedBase64(uint8Array: ArrayBuffer | Uint8Array): string {
     return encodeBase64(uint8Array).replace(/=+$/g, '');
@@ -581,8 +569,8 @@ export function encodeUnpaddedBase64(uint8Array: ArrayBuffer | Uint8Array): stri
 
 /**
  * Decode a base64 string to a typed array of uint8.
- * @param {string} base64 The base64 to decode.
- * @return {Uint8Array} The decoded data.
+ * @param base64 - The base64 to decode.
+ * @returns The decoded data.
  */
 export function decodeBase64(base64: string): Uint8Array {
     return Buffer.from(base64, "base64");
diff --git a/src/crypto/store/base.ts b/src/crypto/store/base.ts
index 72b02e0a1cb..31ece3b066f 100644
--- a/src/crypto/store/base.ts
+++ b/src/crypto/store/base.ts
@@ -30,8 +30,6 @@ import { IEncryptedPayload } from "../aes";
 
 /**
  * Internal module. Definitions for storage for the crypto module
- *
- * @module
  */
 
 export interface SecretStorePrivateKeys {
@@ -46,8 +44,6 @@ export interface SecretStorePrivateKeys {
 
 /**
  * Abstraction of things that can store data required for end-to-end encryption
- *
- * @interface CryptoStore
  */
 export interface CryptoStore {
     startup(): Promise<CryptoStore>;
@@ -197,32 +193,29 @@ export interface IWithheld {
 
 /**
  * Represents an outgoing room key request
- *
- * @typedef {Object} OutgoingRoomKeyRequest
- *
- * @property {string} requestId    unique id for this request. Used for both
- *    an id within the request for later pairing with a cancellation, and for
- *    the transaction id when sending the to_device messages to our local
- *    server.
- *
- * @property {string?} cancellationTxnId
- *    transaction id for the cancellation, if any
- *
- * @property {Array<{userId: string, deviceId: string}>} recipients
- *    list of recipients for the request
- *
- * @property {module:crypto~RoomKeyRequestBody} requestBody
- *    parameters for the request.
- *
- * @property {Number} state   current state of this request (states are defined
- *    in {@link module:crypto/OutgoingRoomKeyRequestManager~ROOM_KEY_REQUEST_STATES})
  */
 export interface OutgoingRoomKeyRequest {
+    /**
+     * Unique id for this request. Used for both an id within the request for later pairing with a cancellation,
+     * and for the transaction id when sending the to_device messages to our local server.
+     */
     requestId: string;
     requestTxnId?: string;
+    /**
+     * Transaction id for the cancellation, if any
+     */
     cancellationTxnId?: string;
+    /**
+     * List of recipients for the request
+     */
     recipients: IRoomKeyRequestRecipient[];
+    /**
+     * Parameters for the request
+     */
     requestBody: IRoomKeyRequestBody;
+    /**
+     * current state of this request (states are defined in {@link OutgoingRoomKeyRequestManager})
+     */
     state: RoomKeyRequestState;
 }
 
diff --git a/src/crypto/store/indexeddb-crypto-store-backend.ts b/src/crypto/store/indexeddb-crypto-store-backend.ts
index cdf35e787a5..3a0c7711a9a 100644
--- a/src/crypto/store/indexeddb-crypto-store-backend.ts
+++ b/src/crypto/store/indexeddb-crypto-store-backend.ts
@@ -39,14 +39,11 @@ const PROFILE_TRANSACTIONS = false;
  * Implementation of a CryptoStore which is backed by an existing
  * IndexedDB connection. Generally you want IndexedDBCryptoStore
  * which connects to the database and defers to one of these.
- *
- * @implements {module:crypto/store/base~CryptoStore}
  */
 export class Backend implements CryptoStore {
     private nextTxnId = 0;
 
     /**
-     * @param {IDBDatabase} db
      */
     public constructor(private db: IDBDatabase) {
         // make sure we close the db on `onversionchange` - otherwise
@@ -71,10 +68,9 @@ export class Backend implements CryptoStore {
      * Look for an existing outgoing room key request, and if none is found,
      * add a new one
      *
-     * @param {module:crypto/store/base~OutgoingRoomKeyRequest} request
      *
-     * @returns {Promise} resolves to
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}: either the
+     * @returns resolves to
+     *    {@link OutgoingRoomKeyRequest}: either the
      *    same instance as passed in, or the existing one.
      */
     public getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest> {
@@ -113,11 +109,10 @@ export class Backend implements CryptoStore {
     /**
      * Look for an existing room key request
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     *    existing request to look for
+     * @param requestBody - existing request to look for
      *
-     * @return {Promise} resolves to the matching
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
+     * @returns resolves to the matching
+     *    {@link OutgoingRoomKeyRequest}, or null if
      *    not found
      */
     public getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null> {
@@ -134,13 +129,12 @@ export class Backend implements CryptoStore {
     /**
      * look for an existing room key request in the db
      *
-     * @private
-     * @param {IDBTransaction} txn  database transaction
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     *    existing request to look for
-     * @param {Function} callback  function to call with the results of the
+     * @internal
+     * @param txn -  database transaction
+     * @param requestBody - existing request to look for
+     * @param callback -  function to call with the results of the
      *    search. Either passed a matching
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
+     *    {@link OutgoingRoomKeyRequest}, or null if
      *    not found.
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -181,10 +175,10 @@ export class Backend implements CryptoStore {
     /**
      * Look for room key requests by state
      *
-     * @param {Array<Number>} wantedStates list of acceptable states
+     * @param wantedStates - list of acceptable states
      *
-     * @return {Promise} resolves to the a
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
+     * @returns resolves to the a
+     *    {@link OutgoingRoomKeyRequest}, or null if
      *    there are no pending requests in those states. If there are multiple
      *    requests in those states, an arbitrary one is chosen.
      */
@@ -233,8 +227,7 @@ export class Backend implements CryptoStore {
 
     /**
      *
-     * @param {Number} wantedState
-     * @return {Promise<Array<*>>} All elements in a given state
+     * @returns All elements in a given state
      */
     public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
         return new Promise((resolve, reject) => {
@@ -294,12 +287,12 @@ export class Backend implements CryptoStore {
      * Look for an existing room key request by id and state, and update it if
      * found
      *
-     * @param {string} requestId      ID of request to update
-     * @param {number} expectedState  state we expect to find the request in
-     * @param {Object} updates        name/value map of updates to apply
+     * @param requestId -      ID of request to update
+     * @param expectedState -  state we expect to find the request in
+     * @param updates -        name/value map of updates to apply
      *
-     * @returns {Promise} resolves to
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
+     * @returns resolves to
+     *    {@link OutgoingRoomKeyRequest}
      *    updated request, or null if no matching row was found
      */
     public updateOutgoingRoomKeyRequest(
@@ -337,10 +330,10 @@ export class Backend implements CryptoStore {
      * Look for an existing room key request by id and state, and delete it if
      * found
      *
-     * @param {string} requestId      ID of request to update
-     * @param {number} expectedState  state we expect to find the request in
+     * @param requestId -      ID of request to update
+     * @param expectedState -  state we expect to find the request in
      *
-     * @returns {Promise} resolves once the operation is completed
+     * @returns resolves once the operation is completed
      */
     public deleteOutgoingRoomKeyRequest(
         requestId: string,
diff --git a/src/crypto/store/indexeddb-crypto-store.ts b/src/crypto/store/indexeddb-crypto-store.ts
index d743a95decc..ac2964d12af 100644
--- a/src/crypto/store/indexeddb-crypto-store.ts
+++ b/src/crypto/store/indexeddb-crypto-store.ts
@@ -39,15 +39,11 @@ import { InboundGroupSessionData } from "../OlmDevice";
 
 /**
  * Internal module. indexeddb storage for e2e.
- *
- * @module
  */
 
 /**
  * An implementation of CryptoStore, which is normally backed by an indexeddb,
  * but with fallback to MemoryCryptoStore.
- *
- * @implements {module:crypto/store/base~CryptoStore}
  */
 export class IndexedDBCryptoStore implements CryptoStore {
     public static STORE_ACCOUNT = 'account';
@@ -70,8 +66,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Create a new IndexedDBCryptoStore
      *
-     * @param {IDBFactory} indexedDB  global indexedDB instance
-     * @param {string} dbName   name of db to connect to
+     * @param indexedDB -  global indexedDB instance
+     * @param dbName -   name of db to connect to
      */
     public constructor(private readonly indexedDB: IDBFactory, private readonly dbName: string) {}
 
@@ -81,7 +77,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
      *
      * This must be called before the store can be used.
      *
-     * @return {Promise} resolves to either an IndexedDBCryptoStoreBackend.Backend,
+     * @returns resolves to either an IndexedDBCryptoStoreBackend.Backend,
      * or a MemoryCryptoStore
      */
     public startup(): Promise<CryptoStore> {
@@ -167,7 +163,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Delete all data from this store.
      *
-     * @returns {Promise} resolves when the store has been cleared.
+     * @returns resolves when the store has been cleared.
      */
     public deleteAllData(): Promise<void> {
         return new Promise<void>((resolve, reject) => {
@@ -206,10 +202,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Look for an existing outgoing room key request, and if none is found,
      * add a new one
      *
-     * @param {module:crypto/store/base~OutgoingRoomKeyRequest} request
      *
-     * @returns {Promise} resolves to
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}: either the
+     * @returns resolves to
+     *    {@link OutgoingRoomKeyRequest}: either the
      *    same instance as passed in, or the existing one.
      */
     public getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest> {
@@ -219,11 +214,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Look for an existing room key request
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     *    existing request to look for
+     * @param requestBody - existing request to look for
      *
-     * @return {Promise} resolves to the matching
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
+     * @returns resolves to the matching
+     *    {@link OutgoingRoomKeyRequest}, or null if
      *    not found
      */
     public getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null> {
@@ -233,10 +227,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Look for room key requests by state
      *
-     * @param {Array<Number>} wantedStates list of acceptable states
+     * @param wantedStates - list of acceptable states
      *
-     * @return {Promise} resolves to the a
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
+     * @returns resolves to the a
+     *    {@link OutgoingRoomKeyRequest}, or null if
      *    there are no pending requests in those states. If there are multiple
      *    requests in those states, an arbitrary one is chosen.
      */
@@ -248,8 +242,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Look for room key requests by state –
      * unlike above, return a list of all entries in one state.
      *
-     * @param {Number} wantedState
-     * @return {Promise<Array<*>>} Returns an array of requests in the given state
+     * @returns Returns an array of requests in the given state
      */
     public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
         return this.backend!.getAllOutgoingRoomKeyRequestsByState(wantedState);
@@ -258,12 +251,12 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Look for room key requests by target device and state
      *
-     * @param {string} userId Target user ID
-     * @param {string} deviceId Target device ID
-     * @param {Array<Number>} wantedStates list of acceptable states
+     * @param userId - Target user ID
+     * @param deviceId - Target device ID
+     * @param wantedStates - list of acceptable states
      *
-     * @return {Promise} resolves to a list of all the
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
+     * @returns resolves to a list of all the
+     *    {@link OutgoingRoomKeyRequest}
      */
     public getOutgoingRoomKeyRequestsByTarget(
         userId: string,
@@ -279,12 +272,12 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Look for an existing room key request by id and state, and update it if
      * found
      *
-     * @param {string} requestId      ID of request to update
-     * @param {number} expectedState  state we expect to find the request in
-     * @param {Object} updates        name/value map of updates to apply
+     * @param requestId -      ID of request to update
+     * @param expectedState -  state we expect to find the request in
+     * @param updates -        name/value map of updates to apply
      *
-     * @returns {Promise} resolves to
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
+     * @returns resolves to
+     *    {@link OutgoingRoomKeyRequest}
      *    updated request, or null if no matching row was found
      */
     public updateOutgoingRoomKeyRequest(
@@ -301,10 +294,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Look for an existing room key request by id and state, and delete it if
      * found
      *
-     * @param {string} requestId      ID of request to update
-     * @param {number} expectedState  state we expect to find the request in
+     * @param requestId -      ID of request to update
+     * @param expectedState -  state we expect to find the request in
      *
-     * @returns {Promise} resolves once the operation is completed
+     * @returns resolves once the operation is completed
      */
     public deleteOutgoingRoomKeyRequest(
         requestId: string,
@@ -319,8 +312,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Get the account pickle from the store.
      * This requires an active transaction. See doTxn().
      *
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(string)} func Called with the account pickle
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called with the account pickle
      */
     public getAccount(txn: IDBTransaction, func: (accountPickle: string | null) => void): void {
         this.backend!.getAccount(txn, func);
@@ -330,8 +323,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Write the account pickle to the store.
      * This requires an active transaction. See doTxn().
      *
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {string} accountPickle The new account pickle to store.
+     * @param txn - An active transaction. See doTxn().
+     * @param accountPickle - The new account pickle to store.
      */
     public storeAccount(txn: IDBTransaction, accountPickle: string): void {
         this.backend!.storeAccount(txn, accountPickle);
@@ -341,9 +334,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Get the public part of the cross-signing keys (eg. self-signing key,
      * user signing key).
      *
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(string)} func Called with the account keys object:
-     *        { key_type: base64 encoded seed } where key type = user_signing_key_seed or self_signing_key_seed
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called with the account keys object:
+     *        `{ key_type: base64 encoded seed }` where key type = user_signing_key_seed or self_signing_key_seed
      */
     public getCrossSigningKeys(
         txn: IDBTransaction,
@@ -353,9 +346,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
     }
 
     /**
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(string)} func Called with the private key
-     * @param {string} type A key type
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called with the private key
+     * @param type - A key type
      */
     public getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(
         txn: IDBTransaction,
@@ -368,8 +361,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Write the cross-signing keys back to the store
      *
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {string} keys keys object as getCrossSigningKeys()
+     * @param txn - An active transaction. See doTxn().
+     * @param keys - keys object as getCrossSigningKeys()
      */
     public storeCrossSigningKeys(txn: IDBTransaction, keys: Record<string, ICrossSigningKey>): void {
         this.backend!.storeCrossSigningKeys(txn, keys);
@@ -378,9 +371,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Write the cross-signing private keys back to the store
      *
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {string} type The type of cross-signing private key to store
-     * @param {string} key keys object as getCrossSigningKeys()
+     * @param txn - An active transaction. See doTxn().
+     * @param type - The type of cross-signing private key to store
+     * @param key - keys object as getCrossSigningKeys()
      */
     public storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(
         txn: IDBTransaction,
@@ -394,8 +387,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Returns the number of end-to-end sessions in the store
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(int)} func Called with the count of sessions
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called with the count of sessions
      */
     public countEndToEndSessions(txn: IDBTransaction, func: (count: number) => void): void {
         this.backend!.countEndToEndSessions(txn, func);
@@ -404,10 +397,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Retrieve a specific end-to-end session between the logged-in user
      * and another device.
-     * @param {string} deviceKey The public key of the other device.
-     * @param {string} sessionId The ID of the session to retrieve
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(object)} func Called with A map from sessionId
+     * @param deviceKey - The public key of the other device.
+     * @param sessionId - The ID of the session to retrieve
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called with A map from sessionId
      *     to session information object with 'session' key being the
      *     Base64 end-to-end session and lastReceivedMessageTs being the
      *     timestamp in milliseconds at which the session last received
@@ -425,9 +418,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Retrieve the end-to-end sessions between the logged-in user and another
      * device.
-     * @param {string} deviceKey The public key of the other device.
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(object)} func Called with A map from sessionId
+     * @param deviceKey - The public key of the other device.
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called with A map from sessionId
      *     to session information object with 'session' key being the
      *     Base64 end-to-end session and lastReceivedMessageTs being the
      *     timestamp in milliseconds at which the session last received
@@ -443,8 +436,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Retrieve all end-to-end sessions
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(object)} func Called one for each session with
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called one for each session with
      *     an object with, deviceKey, lastReceivedMessageTs, sessionId
      *     and session keys.
      */
@@ -454,10 +447,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Store a session between the logged-in user and another device
-     * @param {string} deviceKey The public key of the other device.
-     * @param {string} sessionId The ID for this end-to-end session.
-     * @param {string} sessionInfo Session information object
-     * @param {*} txn An active transaction. See doTxn().
+     * @param deviceKey - The public key of the other device.
+     * @param sessionId - The ID for this end-to-end session.
+     * @param sessionInfo - Session information object
+     * @param txn - An active transaction. See doTxn().
      */
     public storeEndToEndSession(
         deviceKey: string,
@@ -485,10 +478,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Retrieve the end-to-end inbound group session for a given
      * server key and session ID
-     * @param {string} senderCurve25519Key The sender's curve 25519 key
-     * @param {string} sessionId The ID of the session
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(object)} func Called with A map from sessionId
+     * @param senderCurve25519Key - The sender's curve 25519 key
+     * @param sessionId - The ID of the session
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called with A map from sessionId
      *     to Base64 end-to-end session.
      */
     public getEndToEndInboundGroupSession(
@@ -502,10 +495,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Fetches all inbound group sessions in the store
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(object)} func Called once for each group session
-     *     in the store with an object having keys {senderKey, sessionId,
-     *     sessionData}, then once with null to indicate the end of the list.
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Called once for each group session
+     *     in the store with an object having keys `{senderKey, sessionId, sessionData}`,
+     *     then once with null to indicate the end of the list.
      */
     public getAllEndToEndInboundGroupSessions(
         txn: IDBTransaction,
@@ -518,10 +511,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Adds an end-to-end inbound group session to the store.
      * If there already exists an inbound group session with the same
      * senderCurve25519Key and sessionID, the session will not be added.
-     * @param {string} senderCurve25519Key The sender's curve 25519 key
-     * @param {string} sessionId The ID of the session
-     * @param {object} sessionData The session data structure
-     * @param {*} txn An active transaction. See doTxn().
+     * @param senderCurve25519Key - The sender's curve 25519 key
+     * @param sessionId - The ID of the session
+     * @param sessionData - The session data structure
+     * @param txn - An active transaction. See doTxn().
      */
     public addEndToEndInboundGroupSession(
         senderCurve25519Key: string,
@@ -536,10 +529,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * Writes an end-to-end inbound group session to the store.
      * If there already exists an inbound group session with the same
      * senderCurve25519Key and sessionID, it will be overwritten.
-     * @param {string} senderCurve25519Key The sender's curve 25519 key
-     * @param {string} sessionId The ID of the session
-     * @param {object} sessionData The session data structure
-     * @param {*} txn An active transaction. See doTxn().
+     * @param senderCurve25519Key - The sender's curve 25519 key
+     * @param sessionId - The ID of the session
+     * @param sessionData - The session data structure
+     * @param txn - An active transaction. See doTxn().
      */
     public storeEndToEndInboundGroupSession(
         senderCurve25519Key: string,
@@ -568,8 +561,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * These all need to be written out in full each time such that the snapshot
      * is always consistent, so they are stored in one object.
      *
-     * @param {Object} deviceData
-     * @param {*} txn An active transaction. See doTxn().
+     * @param txn - An active transaction. See doTxn().
      */
     public storeEndToEndDeviceData(deviceData: IDeviceData, txn: IDBTransaction): void {
         this.backend!.storeEndToEndDeviceData(deviceData, txn);
@@ -578,8 +570,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Get the state of all tracked devices
      *
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(Object)} func Function called with the
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Function called with the
      *     device data
      */
     public getEndToEndDeviceData(txn: IDBTransaction, func: (deviceData: IDeviceData | null) => void): void {
@@ -590,18 +582,18 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Store the end-to-end state for a room.
-     * @param {string} roomId The room's ID.
-     * @param {object} roomInfo The end-to-end info for the room.
-     * @param {*} txn An active transaction. See doTxn().
+     * @param roomId - The room's ID.
+     * @param roomInfo - The end-to-end info for the room.
+     * @param txn - An active transaction. See doTxn().
      */
     public storeEndToEndRoom(roomId: string, roomInfo: IRoomEncryption, txn: IDBTransaction): void {
         this.backend!.storeEndToEndRoom(roomId, roomInfo, txn);
     }
 
     /**
-     * Get an object of roomId->roomInfo for all e2e rooms in the store
-     * @param {*} txn An active transaction. See doTxn().
-     * @param {function(Object)} func Function called with the end to end encrypted rooms
+     * Get an object of `roomId->roomInfo` for all e2e rooms in the store
+     * @param txn - An active transaction. See doTxn().
+     * @param func - Function called with the end-to-end encrypted rooms
      */
     public getEndToEndRooms(txn: IDBTransaction, func: (rooms: Record<string, IRoomEncryption>) => void): void {
         this.backend!.getEndToEndRooms(txn, func);
@@ -611,9 +603,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Get the inbound group sessions that need to be backed up.
-     * @param {number} limit The maximum number of sessions to retrieve.  0
+     * @param limit - The maximum number of sessions to retrieve.  0
      * for no limit.
-     * @returns {Promise} resolves to an array of inbound group sessions
+     * @returns resolves to an array of inbound group sessions
      */
     public getSessionsNeedingBackup(limit: number): Promise<ISession[]> {
         return this.backend!.getSessionsNeedingBackup(limit);
@@ -621,8 +613,8 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Count the inbound group sessions that need to be backed up.
-     * @param {*} txn An active transaction. See doTxn(). (optional)
-     * @returns {Promise} resolves to the number of sessions
+     * @param txn - An active transaction. See doTxn(). (optional)
+     * @returns resolves to the number of sessions
      */
     public countSessionsNeedingBackup(txn?: IDBTransaction): Promise<number> {
         return this.backend!.countSessionsNeedingBackup(txn);
@@ -630,9 +622,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Unmark sessions as needing to be backed up.
-     * @param {Array<object>} sessions The sessions that need to be backed up.
-     * @param {*} txn An active transaction. See doTxn(). (optional)
-     * @returns {Promise} resolves when the sessions are unmarked
+     * @param sessions - The sessions that need to be backed up.
+     * @param txn - An active transaction. See doTxn(). (optional)
+     * @returns resolves when the sessions are unmarked
      */
     public unmarkSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {
         return this.backend!.unmarkSessionsNeedingBackup(sessions, txn);
@@ -640,9 +632,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Mark sessions as needing to be backed up.
-     * @param {Array<object>} sessions The sessions that need to be backed up.
-     * @param {*} txn An active transaction. See doTxn(). (optional)
-     * @returns {Promise} resolves when the sessions are marked
+     * @param sessions - The sessions that need to be backed up.
+     * @param txn - An active transaction. See doTxn(). (optional)
+     * @returns resolves when the sessions are marked
      */
     public markSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {
         return this.backend!.markSessionsNeedingBackup(sessions, txn);
@@ -650,10 +642,10 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Add a shared-history group session for a room.
-     * @param {string} roomId The room that the key belongs to
-     * @param {string} senderKey The sender's curve 25519 key
-     * @param {string} sessionId The ID of the session
-     * @param {*} txn An active transaction. See doTxn(). (optional)
+     * @param roomId - The room that the key belongs to
+     * @param senderKey - The sender's curve 25519 key
+     * @param sessionId - The ID of the session
+     * @param txn - An active transaction. See doTxn(). (optional)
      */
     public addSharedHistoryInboundGroupSession(
         roomId: string,
@@ -666,9 +658,9 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
     /**
      * Get the shared-history group session for a room.
-     * @param {string} roomId The room that the key belongs to
-     * @param {*} txn An active transaction. See doTxn(). (optional)
-     * @returns {Promise} Resolves to an array of [senderKey, sessionId]
+     * @param roomId - The room that the key belongs to
+     * @param txn - An active transaction. See doTxn(). (optional)
+     * @returns Promise which resolves to an array of [senderKey, sessionId]
      */
     public getSharedHistoryInboundGroupSessions(
         roomId: string,
@@ -704,16 +696,16 @@ export class IndexedDBCryptoStore implements CryptoStore {
      * only be called within a callback of either this function or
      * one of the store functions operating on the same transaction.
      *
-     * @param {string} mode 'readwrite' if you need to call setter
+     * @param mode - 'readwrite' if you need to call setter
      *     functions with this transaction. Otherwise, 'readonly'.
-     * @param {string[]} stores List IndexedDBCryptoStore.STORE_*
+     * @param stores - List IndexedDBCryptoStore.STORE_*
      *     options representing all types of object that will be
      *     accessed or written to with this transaction.
-     * @param {function(*)} func Function called with the
+     * @param func - Function called with the
      *     transaction object: an opaque object that should be passed
      *     to store functions.
-     * @param {Logger} [log] A possibly customised log
-     * @return {Promise} Promise that resolves with the result of the `func`
+     * @param log - A possibly customised log
+     * @returns Promise that resolves with the result of the `func`
      *     when the transaction is complete. If the backend is
      *     async (ie. the indexeddb backend) any of the callback
      *     functions throwing an exception will cause this promise to
diff --git a/src/crypto/store/localStorage-crypto-store.ts b/src/crypto/store/localStorage-crypto-store.ts
index c6f9a02d6ae..04815cf1576 100644
--- a/src/crypto/store/localStorage-crypto-store.ts
+++ b/src/crypto/store/localStorage-crypto-store.ts
@@ -28,8 +28,6 @@ import { InboundGroupSessionData } from "../OlmDevice";
  * some things backed by localStorage. It exists because indexedDB
  * is broken in Firefox private mode or set to, "will not remember
  * history".
- *
- * @module
  */
 
 const E2E_PREFIX = "crypto.";
@@ -62,9 +60,6 @@ function keyEndToEndRoomsPrefix(roomId: string): string {
     return KEY_ROOMS_PREFIX + roomId;
 }
 
-/**
- * @implements {module:crypto/store/base~CryptoStore}
- */
 export class LocalStorageCryptoStore extends MemoryCryptoStore {
     public static exists(store: Storage): boolean {
         const length = store.length;
@@ -364,7 +359,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
     /**
      * Delete all data from this store.
      *
-     * @returns {Promise} Promise which resolves when the store has been cleared.
+     * @returns Promise which resolves when the store has been cleared.
      */
     public deleteAllData(): Promise<void> {
         this.store.removeItem(KEY_END_TO_END_ACCOUNT);
diff --git a/src/crypto/store/memory-crypto-store.ts b/src/crypto/store/memory-crypto-store.ts
index f22379ee81e..701f85fc30a 100644
--- a/src/crypto/store/memory-crypto-store.ts
+++ b/src/crypto/store/memory-crypto-store.ts
@@ -35,13 +35,8 @@ import { InboundGroupSessionData } from "../OlmDevice";
 
 /**
  * Internal module. in-memory storage for e2e.
- *
- * @module
  */
 
-/**
- * @implements {module:crypto/store/base~CryptoStore}
- */
 export class MemoryCryptoStore implements CryptoStore {
     private outgoingRoomKeyRequests: OutgoingRoomKeyRequest[] = [];
     private account: string | null = null;
@@ -65,7 +60,7 @@ export class MemoryCryptoStore implements CryptoStore {
      *
      * This must be called before the store can be used.
      *
-     * @return {Promise} resolves to the store.
+     * @returns resolves to the store.
      */
     public async startup(): Promise<CryptoStore> {
         // No startup work to do for the memory store.
@@ -75,7 +70,7 @@ export class MemoryCryptoStore implements CryptoStore {
     /**
      * Delete all data from this store.
      *
-     * @returns {Promise} Promise which resolves when the store has been cleared.
+     * @returns Promise which resolves when the store has been cleared.
      */
     public deleteAllData(): Promise<void> {
         return Promise.resolve();
@@ -85,10 +80,9 @@ export class MemoryCryptoStore implements CryptoStore {
      * Look for an existing outgoing room key request, and if none is found,
      * add a new one
      *
-     * @param {module:crypto/store/base~OutgoingRoomKeyRequest} request
      *
-     * @returns {Promise} resolves to
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}: either the
+     * @returns resolves to
+     *    {@link OutgoingRoomKeyRequest}: either the
      *    same instance as passed in, or the existing one.
      */
     public getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest> {
@@ -122,11 +116,10 @@ export class MemoryCryptoStore implements CryptoStore {
     /**
      * Look for an existing room key request
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     *    existing request to look for
+     * @param requestBody - existing request to look for
      *
-     * @return {Promise} resolves to the matching
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
+     * @returns resolves to the matching
+     *    {@link OutgoingRoomKeyRequest}, or null if
      *    not found
      */
     public getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null> {
@@ -138,10 +131,9 @@ export class MemoryCryptoStore implements CryptoStore {
      *
      * @internal
      *
-     * @param {module:crypto~RoomKeyRequestBody} requestBody
-     *    existing request to look for
+     * @param requestBody - existing request to look for
      *
-     * @return {module:crypto/store/base~OutgoingRoomKeyRequest?}
+     * @returns
      *    the matching request, or null if not found
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -157,10 +149,10 @@ export class MemoryCryptoStore implements CryptoStore {
     /**
      * Look for room key requests by state
      *
-     * @param {Array<Number>} wantedStates list of acceptable states
+     * @param wantedStates - list of acceptable states
      *
-     * @return {Promise} resolves to the a
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}, or null if
+     * @returns resolves to the a
+     *    {@link OutgoingRoomKeyRequest}, or null if
      *    there are no pending requests in those states
      */
     public getOutgoingRoomKeyRequestByState(wantedStates: number[]): Promise<OutgoingRoomKeyRequest | null> {
@@ -176,8 +168,7 @@ export class MemoryCryptoStore implements CryptoStore {
 
     /**
      *
-     * @param {Number} wantedState
-     * @return {Promise<Array<*>>} All OutgoingRoomKeyRequests in state
+     * @returns All OutgoingRoomKeyRequests in state
      */
     public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
         return Promise.resolve(
@@ -210,12 +201,12 @@ export class MemoryCryptoStore implements CryptoStore {
      * Look for an existing room key request by id and state, and update it if
      * found
      *
-     * @param {string} requestId      ID of request to update
-     * @param {number} expectedState  state we expect to find the request in
-     * @param {Object} updates        name/value map of updates to apply
+     * @param requestId -      ID of request to update
+     * @param expectedState -  state we expect to find the request in
+     * @param updates -        name/value map of updates to apply
      *
-     * @returns {Promise} resolves to
-     *    {@link module:crypto/store/base~OutgoingRoomKeyRequest}
+     * @returns resolves to
+     *    {@link OutgoingRoomKeyRequest}
      *    updated request, or null if no matching row was found
      */
     public updateOutgoingRoomKeyRequest(
@@ -246,10 +237,10 @@ export class MemoryCryptoStore implements CryptoStore {
      * Look for an existing room key request by id and state, and delete it if
      * found
      *
-     * @param {string} requestId      ID of request to update
-     * @param {number} expectedState  state we expect to find the request in
+     * @param requestId -      ID of request to update
+     * @param expectedState -  state we expect to find the request in
      *
-     * @returns {Promise} resolves once the operation is completed
+     * @returns resolves once the operation is completed
      */
     public deleteOutgoingRoomKeyRequest(
         requestId: string,
diff --git a/src/crypto/verification/Base.ts b/src/crypto/verification/Base.ts
index 55b349e99c9..f2644b55708 100644
--- a/src/crypto/verification/Base.ts
+++ b/src/crypto/verification/Base.ts
@@ -17,7 +17,6 @@ limitations under the License.
 
 /**
  * Base class for verification methods.
- * @module crypto/verification/Base
  */
 
 import { MatrixEvent } from '../../models/event';
@@ -74,21 +73,19 @@ export class VerificationBase<
      *
      * <p>Subclasses must have a NAME class property.</p>
      *
-     * @class
-     *
-     * @param {Object} channel the verification channel to send verification messages over.
+     * @param channel - the verification channel to send verification messages over.
      * TODO: Channel types
      *
-     * @param {MatrixClient} baseApis base matrix api interface
+     * @param baseApis - base matrix api interface
      *
-     * @param {string} userId the user ID that is being verified
+     * @param userId - the user ID that is being verified
      *
-     * @param {string} deviceId the device ID that is being verified
+     * @param deviceId - the device ID that is being verified
      *
-     * @param {object} [startEvent] the m.key.verification.start event that
+     * @param startEvent - the m.key.verification.start event that
      * initiated this verification, if any
      *
-     * @param {object} [request] the key verification request object related to
+     * @param request - the key verification request object related to
      * this verification, if any
      */
     public constructor(
@@ -279,7 +276,7 @@ export class VerificationBase<
     /**
      * Begin the key verification
      *
-     * @returns {Promise} Promise which resolves when the verification has
+     * @returns Promise which resolves when the verification has
      *     completed.
      */
     public verify(): Promise<void> {
diff --git a/src/crypto/verification/Error.ts b/src/crypto/verification/Error.ts
index ca0fb20b575..0ad50b2ff26 100644
--- a/src/crypto/verification/Error.ts
+++ b/src/crypto/verification/Error.ts
@@ -16,8 +16,6 @@ limitations under the License.
 
 /**
  * Error messages.
- *
- * @module crypto/verification/Error
  */
 
 import { MatrixEvent } from "../../models/event";
diff --git a/src/crypto/verification/IllegalMethod.ts b/src/crypto/verification/IllegalMethod.ts
index f01364a212f..c437e0cd2a9 100644
--- a/src/crypto/verification/IllegalMethod.ts
+++ b/src/crypto/verification/IllegalMethod.ts
@@ -17,7 +17,6 @@ limitations under the License.
 /**
  * Verification method that is illegal to have (cannot possibly
  * do verification with this method).
- * @module crypto/verification/IllegalMethod
  */
 
 import { VerificationBase as Base, VerificationEvent, VerificationEventHandlerMap } from "./Base";
@@ -26,10 +25,6 @@ import { MatrixClient } from "../../client";
 import { MatrixEvent } from "../../models/event";
 import { VerificationRequest } from "./request/VerificationRequest";
 
-/**
- * @class crypto/verification/IllegalMethod/IllegalMethod
- * @extends {module:crypto/verification/Base}
- */
 export class IllegalMethod extends Base<VerificationEvent, VerificationEventHandlerMap> {
     public static factory(
         channel: IVerificationChannel,
diff --git a/src/crypto/verification/QRCode.ts b/src/crypto/verification/QRCode.ts
index 13053280d8b..c5c2735bc58 100644
--- a/src/crypto/verification/QRCode.ts
+++ b/src/crypto/verification/QRCode.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * QR code key verification.
- * @module crypto/verification/QRCode
  */
 
 import { VerificationBase as Base, VerificationEventHandlerMap } from "./Base";
@@ -44,10 +43,6 @@ type EventHandlerMap = {
     [QrCodeEvent.ShowReciprocateQr]: (qr: IReciprocateQr) => void;
 } & VerificationEventHandlerMap;
 
-/**
- * @class crypto/verification/QRCode/ReciprocateQRCode
- * @extends {module:crypto/verification/Base}
- */
 export class ReciprocateQRCode extends Base<QrCodeEvent, EventHandlerMap> {
     public reciprocateQREvent?: IReciprocateQr;
 
diff --git a/src/crypto/verification/SAS.ts b/src/crypto/verification/SAS.ts
index 168a85d28fc..9d831f5c668 100644
--- a/src/crypto/verification/SAS.ts
+++ b/src/crypto/verification/SAS.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * Short Authentication String (SAS) verification.
- * @module crypto/verification/SAS
  */
 
 import anotherjson from 'another-json';
@@ -232,10 +231,6 @@ type EventHandlerMap = {
     [SasEvent.ShowSas]: (sas: ISasEvent) => void;
 } & VerificationEventHandlerMap;
 
-/**
- * @alias module:crypto/verification/SAS
- * @extends {module:crypto/verification/Base}
- */
 export class SAS extends Base<SasEvent, EventHandlerMap> {
     private waitingForAccept?: boolean;
     public ourSASPubKey?: string;
diff --git a/src/crypto/verification/SASDecimal.ts b/src/crypto/verification/SASDecimal.ts
index c8fa73100e6..26dc8d2a087 100644
--- a/src/crypto/verification/SASDecimal.ts
+++ b/src/crypto/verification/SASDecimal.ts
@@ -17,11 +17,11 @@ limitations under the License.
 /**
  * Implementation of decimal encoding of SAS as per:
  * https://spec.matrix.org/v1.4/client-server-api/#sas-method-decimal
- * @param sasBytes the five bytes generated by HKDF
+ * @param sasBytes - the five bytes generated by HKDF
  * @returns the derived three numbers between 1000 and 9191 inclusive
  */
 export function generateDecimalSas(sasBytes: number[]): [number, number, number] {
-    /**
+    /*
      *      +--------+--------+--------+--------+--------+
      *      | Byte 0 | Byte 1 | Byte 2 | Byte 3 | Byte 4 |
      *      +--------+--------+--------+--------+--------+
diff --git a/src/crypto/verification/request/InRoomChannel.ts b/src/crypto/verification/request/InRoomChannel.ts
index 664a2dad6a8..edbf31f635b 100644
--- a/src/crypto/verification/request/InRoomChannel.ts
+++ b/src/crypto/verification/request/InRoomChannel.ts
@@ -40,9 +40,9 @@ export class InRoomChannel implements IVerificationChannel {
     private requestEventId?: string;
 
     /**
-     * @param {MatrixClient} client the matrix client, to send messages with and get current user & device from.
-     * @param {string} roomId id of the room where verification events should be posted in, should be a DM with the given user.
-     * @param {string} userId id of user that the verification request is directed at, should be present in the room.
+     * @param client - the matrix client, to send messages with and get current user & device from.
+     * @param roomId - id of the room where verification events should be posted in, should be a DM with the given user.
+     * @param userId - id of user that the verification request is directed at, should be present in the room.
      */
     public constructor(
         private readonly client: MatrixClient,
@@ -78,8 +78,8 @@ export class InRoomChannel implements IVerificationChannel {
     }
 
     /**
-     * @param {MatrixEvent} event the event to get the timestamp of
-     * @return {number} the timestamp when the event was sent
+     * @param event - the event to get the timestamp of
+     * @returns the timestamp when the event was sent
      */
     public getTimestamp(event: MatrixEvent): number {
         return event.getTs();
@@ -87,8 +87,8 @@ export class InRoomChannel implements IVerificationChannel {
 
     /**
      * Checks whether the given event type should be allowed to initiate a new VerificationRequest over this channel
-     * @param {string} type the event type to check
-     * @returns {boolean} boolean flag
+     * @param type - the event type to check
+     * @returns boolean flag
      */
     public static canCreateRequest(type: string): boolean {
         return type === REQUEST_TYPE;
@@ -100,8 +100,8 @@ export class InRoomChannel implements IVerificationChannel {
 
     /**
      * Extract the transaction id used by a given key verification event, if any
-     * @param {MatrixEvent} event the event
-     * @returns {string} the transaction id
+     * @param event - the event
+     * @returns the transaction id
      */
     public static getTransactionId(event: MatrixEvent): string | undefined {
         if (InRoomChannel.getEventType(event) === REQUEST_TYPE) {
@@ -119,9 +119,9 @@ export class InRoomChannel implements IVerificationChannel {
      * This only does checks that don't rely on the current state of a potentially already channel
      * so we can prevent channels being created by invalid events.
      * `handleEvent` can do more checks and choose to ignore invalid events.
-     * @param {MatrixEvent} event the event to validate
-     * @param {MatrixClient} client the client to get the current user and device id from
-     * @returns {boolean} whether the event is valid and should be passed to handleEvent
+     * @param event - the event to validate
+     * @param client - the client to get the current user and device id from
+     * @returns whether the event is valid and should be passed to handleEvent
      */
     public static validateEvent(event: MatrixEvent, client: MatrixClient): boolean {
         const txnId = InRoomChannel.getTransactionId(event);
@@ -156,8 +156,8 @@ export class InRoomChannel implements IVerificationChannel {
      * As m.key.verification.request events are as m.room.message events with the InRoomChannel
      * to have a fallback message in non-supporting clients, we map the real event type
      * to the symbolic one to keep things in unison with ToDeviceChannel
-     * @param {MatrixEvent} event the event to get the type of
-     * @returns {string} the "symbolic" event type
+     * @param event - the event to get the type of
+     * @returns the "symbolic" event type
      */
     public static getEventType(event: MatrixEvent): string {
         const type = event.getType();
@@ -179,10 +179,10 @@ export class InRoomChannel implements IVerificationChannel {
 
     /**
      * Changes the state of the channel, request, and verifier in response to a key verification event.
-     * @param {MatrixEvent} event to handle
-     * @param {VerificationRequest} request the request to forward handling to
-     * @param {boolean} isLiveEvent whether this is an even received through sync or not
-     * @returns {Promise} a promise that resolves when any requests as an answer to the passed-in event are sent.
+     * @param event - to handle
+     * @param request - the request to forward handling to
+     * @param isLiveEvent - whether this is an even received through sync or not
+     * @returns a promise that resolves when any requests as an answer to the passed-in event are sent.
      */
     public async handleEvent(event: MatrixEvent, request: VerificationRequest, isLiveEvent = false): Promise<void> {
         // prevent processing the same event multiple times, as under
@@ -228,8 +228,8 @@ export class InRoomChannel implements IVerificationChannel {
      * so it has the same format as returned by `completeContent` before sending.
      * The relation can not appear on the event content because of encryption,
      * relations are excluded from encryption.
-     * @param {MatrixEvent} event the received event
-     * @returns {Object} the content object with the relation added again
+     * @param event - the received event
+     * @returns the content object with the relation added again
      */
     public completedContentFromEvent(event: MatrixEvent): Record<string, any> {
         // ensure m.related_to is included in e2ee rooms
@@ -244,9 +244,9 @@ export class InRoomChannel implements IVerificationChannel {
      * This is public so verification methods (SAS uses this) can get the exact
      * content that will be sent independent of the used channel,
      * as they need to calculate the hash of it.
-     * @param {string} type the event type
-     * @param {object} content the (incomplete) content
-     * @returns {object} the complete content, as it will be sent.
+     * @param type - the event type
+     * @param content - the (incomplete) content
+     * @returns the complete content, as it will be sent.
      */
     public completeContent(type: string, content: Record<string, any>): Record<string, any> {
         content = Object.assign({}, content);
@@ -276,9 +276,9 @@ export class InRoomChannel implements IVerificationChannel {
 
     /**
      * Send an event over the channel with the content not having gone through `completeContent`.
-     * @param {string} type the event type
-     * @param {object} uncompletedContent the (incomplete) content
-     * @returns {Promise} the promise of the request
+     * @param type - the event type
+     * @param uncompletedContent - the (incomplete) content
+     * @returns the promise of the request
      */
     public send(type: string, uncompletedContent: Record<string, any>): Promise<void> {
         const content = this.completeContent(type, uncompletedContent);
@@ -287,9 +287,8 @@ export class InRoomChannel implements IVerificationChannel {
 
     /**
      * Send an event over the channel with the content having gone through `completeContent` already.
-     * @param {string} type the event type
-     * @param {object} content
-     * @returns {Promise} the promise of the request
+     * @param type - the event type
+     * @returns the promise of the request
      */
     public async sendCompleted(type: string, content: Record<string, any>): Promise<void> {
         let sendType = type;
diff --git a/src/crypto/verification/request/ToDeviceChannel.ts b/src/crypto/verification/request/ToDeviceChannel.ts
index 30d61525139..5d92c3ed12c 100644
--- a/src/crypto/verification/request/ToDeviceChannel.ts
+++ b/src/crypto/verification/request/ToDeviceChannel.ts
@@ -69,8 +69,8 @@ export class ToDeviceChannel implements IVerificationChannel {
 
     /**
      * Extract the transaction id used by a given key verification event, if any
-     * @param {MatrixEvent} event the event
-     * @returns {string} the transaction id
+     * @param event - the event
+     * @returns the transaction id
      */
     public static getTransactionId(event: MatrixEvent): string {
         const content = event.getContent();
@@ -79,8 +79,8 @@ export class ToDeviceChannel implements IVerificationChannel {
 
     /**
      * Checks whether the given event type should be allowed to initiate a new VerificationRequest over this channel
-     * @param {string} type the event type to check
-     * @returns {boolean} boolean flag
+     * @param type - the event type to check
+     * @returns boolean flag
      */
     public static canCreateRequest(type: string): boolean {
         return type === REQUEST_TYPE || type === START_TYPE;
@@ -95,9 +95,9 @@ export class ToDeviceChannel implements IVerificationChannel {
      * This only does checks that don't rely on the current state of a potentially already channel
      * so we can prevent channels being created by invalid events.
      * `handleEvent` can do more checks and choose to ignore invalid events.
-     * @param {MatrixEvent} event the event to validate
-     * @param {MatrixClient} client the client to get the current user and device id from
-     * @returns {boolean} whether the event is valid and should be passed to handleEvent
+     * @param event - the event to validate
+     * @param client - the client to get the current user and device id from
+     * @returns whether the event is valid and should be passed to handleEvent
      */
     public static validateEvent(event: MatrixEvent, client: MatrixClient): boolean {
         if (event.isCancelled()) {
@@ -137,8 +137,8 @@ export class ToDeviceChannel implements IVerificationChannel {
     }
 
     /**
-     * @param {MatrixEvent} event the event to get the timestamp of
-     * @return {number} the timestamp when the event was sent
+     * @param event - the event to get the timestamp of
+     * @returns the timestamp when the event was sent
      */
     public getTimestamp(event: MatrixEvent): number {
         const content = event.getContent();
@@ -147,10 +147,10 @@ export class ToDeviceChannel implements IVerificationChannel {
 
     /**
      * Changes the state of the channel, request, and verifier in response to a key verification event.
-     * @param {MatrixEvent} event to handle
-     * @param {VerificationRequest} request the request to forward handling to
-     * @param {boolean} isLiveEvent whether this is an even received through sync or not
-     * @returns {Promise} a promise that resolves when any requests as an answer to the passed-in event are sent.
+     * @param event - to handle
+     * @param request - the request to forward handling to
+     * @param isLiveEvent - whether this is an even received through sync or not
+     * @returns a promise that resolves when any requests as an answer to the passed-in event are sent.
      */
     public async handleEvent(event: MatrixEvent, request: Request, isLiveEvent = false): Promise<void> {
         const type = event.getType();
@@ -196,9 +196,9 @@ export class ToDeviceChannel implements IVerificationChannel {
     }
 
     /**
-     * See {InRoomChannel.completedContentFromEvent} why this is needed.
-     * @param {MatrixEvent} event the received event
-     * @returns {Object} the content object
+     * See {@link InRoomChannel#completedContentFromEvent} for why this is needed.
+     * @param event - the received event
+     * @returns the content object
      */
     public completedContentFromEvent(event: MatrixEvent): Record<string, any> {
         return event.getContent();
@@ -209,9 +209,9 @@ export class ToDeviceChannel implements IVerificationChannel {
      * This is public so verification methods (SAS uses this) can get the exact
      * content that will be sent independent of the used channel,
      * as they need to calculate the hash of it.
-     * @param {string} type the event type
-     * @param {object} content the (incomplete) content
-     * @returns {object} the complete content, as it will be sent.
+     * @param type - the event type
+     * @param content - the (incomplete) content
+     * @returns the complete content, as it will be sent.
      */
     public completeContent(type: string, content: Record<string, any>): Record<string, any> {
         // make a copy
@@ -230,9 +230,9 @@ export class ToDeviceChannel implements IVerificationChannel {
 
     /**
      * Send an event over the channel with the content not having gone through `completeContent`.
-     * @param {string} type the event type
-     * @param {object} uncompletedContent the (incomplete) content
-     * @returns {Promise} the promise of the request
+     * @param type - the event type
+     * @param uncompletedContent - the (incomplete) content
+     * @returns the promise of the request
      */
     public send(type: string, uncompletedContent: Record<string, any> = {}): Promise<void> {
         // create transaction id when sending request
@@ -245,9 +245,8 @@ export class ToDeviceChannel implements IVerificationChannel {
 
     /**
      * Send an event over the channel with the content having gone through `completeContent` already.
-     * @param {string} type the event type
-     * @param {object} content
-     * @returns {Promise} the promise of the request
+     * @param type - the event type
+     * @returns the promise of the request
      */
     public async sendCompleted(type: string, content: Record<string, any>): Promise<void> {
         let result;
@@ -286,7 +285,7 @@ export class ToDeviceChannel implements IVerificationChannel {
 
     /**
      * Allow Crypto module to create and know the transaction id before the .start event gets sent.
-     * @returns {string} the transaction id
+     * @returns the transaction id
      */
     public static makeTransactionId(): string {
         return randomString(32);
diff --git a/src/crypto/verification/request/VerificationRequest.ts b/src/crypto/verification/request/VerificationRequest.ts
index 58de4b9a2b0..05f0cd75ca5 100644
--- a/src/crypto/verification/request/VerificationRequest.ts
+++ b/src/crypto/verification/request/VerificationRequest.ts
@@ -81,6 +81,9 @@ export enum VerificationRequestEvent {
 }
 
 type EventHandlerMap = {
+    /**
+     * Fires whenever the state of the request object has changed.
+     */
     [VerificationRequestEvent.Change]: () => void;
 };
 
@@ -88,7 +91,6 @@ type EventHandlerMap = {
  * State machine for verification requests.
  * Things that differ based on what channel is used to
  * send and receive verification events are put in `InRoomChannel` or `ToDeviceChannel`.
- * @event "change" whenever the state of the request object has changed.
  */
 export class VerificationRequest<
     C extends IVerificationChannel = IVerificationChannel,
@@ -129,10 +131,10 @@ export class VerificationRequest<
     /**
      * Stateless validation logic not specific to the channel.
      * Invoked by the same static method in either channel.
-     * @param {string} type the "symbolic" event type, as returned by the `getEventType` function on the channel.
-     * @param {MatrixEvent} event the event to validate. Don't call getType() on it but use the `type` parameter instead.
-     * @param {MatrixClient} client the client to get the current user and device id from
-     * @returns {boolean} whether the event is valid and should be passed to handleEvent
+     * @param type - the "symbolic" event type, as returned by the `getEventType` function on the channel.
+     * @param event - the event to validate. Don't call getType() on it but use the `type` parameter instead.
+     * @param client - the client to get the current user and device id from
+     * @returns whether the event is valid and should be passed to handleEvent
      */
     public static validateEvent(type: string, event: MatrixEvent, client: MatrixClient): boolean {
         const content = event.getContent();
@@ -234,7 +236,7 @@ export class VerificationRequest<
 
     /**
      * The key verification request event.
-     * @returns {MatrixEvent} The request event, or falsey if not found.
+     * @returns The request event, or falsey if not found.
      */
     public get requestEvent(): MatrixEvent | undefined {
         return this.getEventByEither(REQUEST_TYPE);
@@ -278,9 +280,9 @@ export class VerificationRequest<
      *  This is useful when setting up the QR code UI, as it is somewhat asymmetrical:
      *  if the other party supports SCAN_QR, we should show a QR code in the UI, and vice versa.
      *  For methods that need to be supported by both ends, use the `methods` property.
-     *  @param {string} method the method to check
-     *  @param {boolean} force to check even if the phase is not ready or started yet, internal usage
-     *  @return {boolean} whether or not the other party said the supported the method */
+     *  @param method - the method to check
+     *  @param force - to check even if the phase is not ready or started yet, internal usage
+     *  @returns whether or not the other party said the supported the method */
     public otherPartySupportsMethod(method: string, force = false): boolean {
         if (!force && !this.ready && !this.started) {
             return false;
@@ -398,7 +400,7 @@ export class VerificationRequest<
      * given the events sent so far in the verification. This is the
      * same algorithm used to determine which device to send the
      * verification to when no specific device is specified.
-     * @returns {{userId: *, deviceId: *}} The device information
+     * @returns The device information
      */
     public get targetDevice(): ITargetDevice {
         const theirFirstEvent =
@@ -415,10 +417,10 @@ export class VerificationRequest<
 
     /* Start the key verification, creating a verifier and sending a .start event.
      * If no previous events have been sent, pass in `targetDevice` to set who to direct this request to.
-     * @param {string} method the name of the verification method to use.
-     * @param {string?} targetDevice.userId the id of the user to direct this request to
-     * @param {string?} targetDevice.deviceId the id of the device to direct this request to
-     * @returns {VerifierBase} the verifier of the given method
+     * @param method - the name of the verification method to use.
+     * @param targetDevice.userId the id of the user to direct this request to
+     * @param targetDevice.deviceId the id of the device to direct this request to
+     * @returns the verifier of the given method
      */
     public beginKeyVerification(
         method: VerificationMethod,
@@ -448,7 +450,7 @@ export class VerificationRequest<
 
     /**
      * sends the initial .request event.
-     * @returns {Promise} resolves when the event has been sent.
+     * @returns resolves when the event has been sent.
      */
     public async sendRequest(): Promise<void> {
         if (!this.observeOnly && this._phase === PHASE_UNSENT) {
@@ -459,9 +461,9 @@ export class VerificationRequest<
 
     /**
      * Cancels the request, sending a cancellation to the other party
-     * @param {string?} error.reason the error reason to send the cancellation with
-     * @param {string?} error.code the error code to send the cancellation with
-     * @returns {Promise} resolves when the event has been sent.
+     * @param reason - the error reason to send the cancellation with
+     * @param code - the error code to send the cancellation with
+     * @returns resolves when the event has been sent.
      */
     public async cancel({ reason = "User declined", code = "m.user" } = {}): Promise<void> {
         if (!this.observeOnly && this._phase !== PHASE_CANCELLED) {
@@ -478,7 +480,7 @@ export class VerificationRequest<
 
     /**
      * Accepts the request, sending a .ready event to the other party
-     * @returns {Promise} resolves when the event has been sent.
+     * @returns resolves when the event has been sent.
      */
     public async accept(): Promise<void> {
         if (!this.observeOnly && this.phase === PHASE_REQUESTED && !this.initiatedByMe) {
@@ -491,10 +493,10 @@ export class VerificationRequest<
 
     /**
      * Can be used to listen for state changes until the callback returns true.
-     * @param {Function} fn callback to evaluate whether the request is in the desired state.
+     * @param fn - callback to evaluate whether the request is in the desired state.
      *                      Takes the request as an argument.
-     * @returns {Promise} that resolves once the callback returns true
-     * @throws {Error} when the request is cancelled
+     * @returns that resolves once the callback returns true
+     * @throws Error when the request is cancelled
      */
     public waitFor(fn: (request: VerificationRequest) => boolean): Promise<VerificationRequest> {
         return new Promise((resolve, reject) => {
@@ -701,13 +703,13 @@ export class VerificationRequest<
 
     /**
      * Changes the state of the request and verifier in response to a key verification event.
-     * @param {string} type the "symbolic" event type, as returned by the `getEventType` function on the channel.
-     * @param {MatrixEvent} event the event to handle. Don't call getType() on it but use the `type` parameter instead.
-     * @param {boolean} isLiveEvent whether this is an even received through sync or not
-     * @param {boolean} isRemoteEcho whether this is the remote echo of an event sent by the same device
-     * @param {boolean} isSentByUs whether this event is sent by a party that can accept and/or observe the request like one of our peers.
+     * @param type - the "symbolic" event type, as returned by the `getEventType` function on the channel.
+     * @param event - the event to handle. Don't call getType() on it but use the `type` parameter instead.
+     * @param isLiveEvent - whether this is an even received through sync or not
+     * @param isRemoteEcho - whether this is the remote echo of an event sent by the same device
+     * @param isSentByUs - whether this event is sent by a party that can accept and/or observe the request like one of our peers.
      *   For InRoomChannel this means any device for the syncing user. For ToDeviceChannel, just the syncing device.
-     * @returns {Promise} a promise that resolves when any requests as an answer to the passed-in event are sent.
+     * @returns a promise that resolves when any requests as an answer to the passed-in event are sent.
      */
     public async handleEvent(
         type: string,
diff --git a/src/embedded.ts b/src/embedded.ts
index 27cf564a670..c5cbab80d14 100644
--- a/src/embedded.ts
+++ b/src/embedded.ts
@@ -85,7 +85,7 @@ export interface ICapabilities {
 
     /**
      * Whether this client needs access to TURN servers.
-     * @default false
+     * @defaultValue false
      */
     turnServers?: boolean;
 }
diff --git a/src/event-mapper.ts b/src/event-mapper.ts
index 6f2e25c1bdd..d40f579b5d7 100644
--- a/src/event-mapper.ts
+++ b/src/event-mapper.ts
@@ -20,8 +20,11 @@ import { IEvent, MatrixEvent, MatrixEventEvent } from "./models/event";
 export type EventMapper = (obj: Partial<IEvent>) => MatrixEvent;
 
 export interface MapperOpts {
+    // don't re-emit events emitted on an event mapped by this mapper on the client
     preventReEmit?: boolean;
+    // decrypt event proactively
     decrypt?: boolean;
+    // the event is a to_device event
     toDevice?: boolean;
 }
 
diff --git a/src/filter-component.ts b/src/filter-component.ts
index 0bda7d3792d..5a4601258f2 100644
--- a/src/filter-component.ts
+++ b/src/filter-component.ts
@@ -22,16 +22,12 @@ import {
     THREAD_RELATION_TYPE,
 } from "./models/thread";
 
-/**
- * @module filter-component
- */
-
 /**
  * Checks if a value matches a given field value, which may be a * terminated
  * wildcard pattern.
- * @param {String} actualValue  The value to be compared
- * @param {String} filterValue  The filter pattern to be compared
- * @return {boolean} true if the actualValue matches the filterValue
+ * @param actualValue -  The value to be compared
+ * @param filterValue -  The filter pattern to be compared
+ * @returns true if the actualValue matches the filterValue
  */
 function matchesWildcard(actualValue: string, filterValue: string): boolean {
     if (filterValue.endsWith("*")) {
@@ -68,17 +64,14 @@ export interface IFilterComponent {
  *
  * N.B. that synapse refers to these as 'Filters', and what js-sdk refers to as
  * 'Filters' are referred to as 'FilterCollections'.
- *
- * @constructor
- * @param {Object} filterJson the definition of this filter JSON, e.g. { 'contains_url': true }
  */
 export class FilterComponent {
     public constructor(private filterJson: IFilterComponent, public readonly userId?: string | undefined | null) {}
 
     /**
      * Checks with the filter component matches the given event
-     * @param {MatrixEvent} event event to be checked against the filter
-     * @return {boolean} true if the event matches the filter
+     * @param event - event to be checked against the filter
+     * @returns true if the event matches the filter
      */
     public check(event: MatrixEvent): boolean {
         const bundledRelationships = event.getUnsigned()?.["m.relations"] || {};
@@ -122,13 +115,13 @@ export class FilterComponent {
 
     /**
      * Checks whether the filter component matches the given event fields.
-     * @param {String} roomId        the roomId for the event being checked
-     * @param {String} sender        the sender of the event being checked
-     * @param {String} eventType     the type of the event being checked
-     * @param {boolean} containsUrl  whether the event contains a content.url field
-     * @param {boolean} relationTypes  whether has aggregated relation of the given type
-     * @param {boolean} relationSenders whether one of the relation is sent by the user listed
-     * @return {boolean} true if the event fields match the filter
+     * @param roomId -        the roomId for the event being checked
+     * @param sender -        the sender of the event being checked
+     * @param eventType -     the type of the event being checked
+     * @param containsUrl -  whether the event contains a content.url field
+     * @param relationTypes -  whether has aggregated relation of the given type
+     * @param relationSenders - whether one of the relation is sent by the user listed
+     * @returns true if the event fields match the filter
      */
     private checkFields(
         roomId: string | undefined,
@@ -194,8 +187,8 @@ export class FilterComponent {
 
     /**
      * Filters a list of events down to those which match this filter component
-     * @param {MatrixEvent[]} events  Events to be checked against the filter component
-     * @return {MatrixEvent[]} events which matched the filter component
+     * @param events -  Events to be checked against the filter component
+     * @returns events which matched the filter component
      */
     public filter(events: MatrixEvent[]): MatrixEvent[] {
         return events.filter(this.check, this);
@@ -204,7 +197,7 @@ export class FilterComponent {
     /**
      * Returns the limit field for a given filter component, providing a default of
      * 10 if none is otherwise specified. Cargo-culted from Synapse.
-     * @return {Number} the limit for this filter component.
+     * @returns the limit for this filter component.
      */
     public limit(): number {
         return this.filterJson.limit !== undefined ? this.filterJson.limit : 10;
diff --git a/src/filter.ts b/src/filter.ts
index 66522701730..b5dc7140bdc 100644
--- a/src/filter.ts
+++ b/src/filter.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module filter
- */
-
 import {
     EventType,
     RelationType,
@@ -27,9 +23,6 @@ import { FilterComponent, IFilterComponent } from "./filter-component";
 import { MatrixEvent } from "./models/event";
 
 /**
- * @param {Object} obj
- * @param {string} keyNesting
- * @param {*} val
  */
 function setProp(obj: Record<string, any>, keyNesting: string, val: any): void {
     const nestedKeys = keyNesting.split(".") as [keyof typeof obj];
@@ -78,14 +71,6 @@ interface IRoomFilter {
 }
 /* eslint-enable camelcase */
 
-/**
- * Construct a new Filter.
- * @constructor
- * @param {string} userId The user ID for this filter.
- * @param {string=} filterId The filter ID if known.
- * @prop {string} userId The user ID of the filter
- * @prop {?string} filterId The filter ID
- */
 export class Filter {
     public static LAZY_LOADING_MESSAGES_FILTER = {
         lazy_load_members: true,
@@ -93,11 +78,6 @@ export class Filter {
 
     /**
      * Create a filter from existing data.
-     * @static
-     * @param {string} userId
-     * @param {string} filterId
-     * @param {Object} jsonObj
-     * @return {Filter}
      */
     public static fromJson(userId: string | undefined | null, filterId: string, jsonObj: IFilterDefinition): Filter {
         const filter = new Filter(userId, filterId);
@@ -109,11 +89,16 @@ export class Filter {
     private roomFilter?: FilterComponent;
     private roomTimelineFilter?: FilterComponent;
 
+    /**
+     * Construct a new Filter.
+     * @param userId - The user ID for this filter.
+     * @param filterId - The filter ID if known.
+     */
     public constructor(public readonly userId: string | undefined | null, public filterId?: string) {}
 
     /**
      * Get the ID of this filter on your homeserver (if known)
-     * @return {?string} The filter ID
+     * @returns The filter ID
      */
     public getFilterId(): string | undefined {
         return this.filterId;
@@ -121,7 +106,7 @@ export class Filter {
 
     /**
      * Get the JSON body of the filter.
-     * @return {Object} The filter definition
+     * @returns The filter definition
      */
     public getDefinition(): IFilterDefinition {
         return this.definition;
@@ -129,7 +114,7 @@ export class Filter {
 
     /**
      * Set the JSON body of the filter
-     * @param {Object} definition The filter definition
+     * @param definition - The filter definition
      */
     public setDefinition(definition: IFilterDefinition): void {
         this.definition = definition;
@@ -198,7 +183,7 @@ export class Filter {
 
     /**
      * Get the room.timeline filter component of the filter
-     * @return {FilterComponent} room timeline filter component
+     * @returns room timeline filter component
      */
     public getRoomTimelineFilterComponent(): FilterComponent | undefined {
         return this.roomTimelineFilter;
@@ -207,8 +192,8 @@ export class Filter {
     /**
      * Filter the list of events based on whether they are allowed in a timeline
      * based on this filter
-     * @param {MatrixEvent[]} events  the list of events being filtered
-     * @return {MatrixEvent[]} the list of events which match the filter
+     * @param events -  the list of events being filtered
+     * @returns the list of events which match the filter
      */
     public filterRoomTimeline(events: MatrixEvent[]): MatrixEvent[] {
         if (this.roomFilter) {
@@ -222,7 +207,7 @@ export class Filter {
 
     /**
      * Set the max number of events to return for each room's timeline.
-     * @param {Number} limit The max number of events to return for each room.
+     * @param limit - The max number of events to return for each room.
      */
     public setTimelineLimit(limit: number): void {
         setProp(this.definition, "room.timeline.limit", limit);
@@ -230,7 +215,6 @@ export class Filter {
 
     /**
      * Enable threads unread notification
-     * @param {boolean} enabled
      */
     public setUnreadThreadNotifications(enabled: boolean): void {
         this.definition = {
@@ -251,7 +235,7 @@ export class Filter {
 
     /**
      * Control whether left rooms should be included in responses.
-     * @param {boolean} includeLeave True to make rooms the user has left appear
+     * @param includeLeave - True to make rooms the user has left appear
      * in responses.
      */
     public setIncludeLeaveRooms(includeLeave: boolean): void {
diff --git a/src/http-api/errors.ts b/src/http-api/errors.ts
index 5ae0a0f5099..e48fc029c7d 100644
--- a/src/http-api/errors.ts
+++ b/src/http-api/errors.ts
@@ -26,9 +26,8 @@ interface IErrorJson extends Partial<IUsageLimit> {
 /**
  * Construct a generic HTTP error. This is a JavaScript Error with additional information
  * specific to HTTP responses.
- * @constructor
- * @param {string} msg The error message to include.
- * @param {number} httpStatus The HTTP response status code.
+ * @param msg - The error message to include.
+ * @param httpStatus - The HTTP response status code.
  */
 export class HTTPError extends Error {
     public constructor(msg: string, public readonly httpStatus?: number) {
@@ -36,21 +35,18 @@ export class HTTPError extends Error {
     }
 }
 
-/**
- * Construct a Matrix error. This is a JavaScript Error with additional
- * information specific to the standard Matrix error response.
- * @constructor
- * @param {Object} errorJson The Matrix error JSON returned from the homeserver.
- * @prop {string} errcode The Matrix 'errcode' value, e.g. "M_FORBIDDEN".
- * @prop {string} name Same as MatrixError.errcode but with a default unknown string.
- * @prop {string} message The Matrix 'error' value, e.g. "Missing token."
- * @prop {Object} data The raw Matrix error JSON used to construct this object.
- * @prop {number} httpStatus The numeric HTTP status code given
- */
 export class MatrixError extends HTTPError {
+    // The Matrix 'errcode' value, e.g. "M_FORBIDDEN".
     public readonly errcode?: string;
+    // The raw Matrix error JSON used to construct this object.
     public data: IErrorJson;
 
+    /**
+     * Construct a Matrix error. This is a JavaScript Error with additional
+     * information specific to the standard Matrix error response.
+     * @param errorJson - The Matrix error JSON returned from the homeserver.
+     * @param httpStatus - The numeric HTTP status code given
+     */
     public constructor(
         errorJson: IErrorJson = {},
         public readonly httpStatus?: number,
@@ -76,7 +72,6 @@ export class MatrixError extends HTTPError {
  * that a request failed because of some error with the connection, either
  * CORS was not correctly configured on the server, the server didn't response,
  * the request timed out, or the internet connection on the client side went down.
- * @constructor
  */
 export class ConnectionError extends Error {
     public constructor(message: string, cause?: Error) {
diff --git a/src/http-api/fetch.ts b/src/http-api/fetch.ts
index 71ba098e303..0c966d30d08 100644
--- a/src/http-api/fetch.ts
+++ b/src/http-api/fetch.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * This is an internal module. See {@link MatrixHttpApi} for the public class.
- * @module http-api
  */
 
 import * as utils from "../utils";
@@ -64,13 +63,13 @@ export class FetchHttpApi<O extends IHttpOpts> {
 
     /**
      * Sets the base URL for the identity server
-     * @param {string} url The new base url
+     * @param url - The new base url
      */
     public setIdBaseUrl(url: string): void {
         this.opts.idBaseUrl = url;
     }
 
-    public idServerRequest<T extends {}>(
+    public idServerRequest<T extends Record<string, unknown>>(
         method: Method,
         path: string,
         params: Record<string, string | string[]> | undefined,
@@ -104,35 +103,29 @@ export class FetchHttpApi<O extends IHttpOpts> {
 
     /**
      * Perform an authorised request to the homeserver.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
+     * @param method - The HTTP method e.g. "GET".
+     * @param path - The HTTP path <b>after</b> the supplied prefix e.g.
      * "/createRoom".
      *
-     * @param {Object=} queryParams A dict of query params (these will NOT be
+     * @param queryParams - A dict of query params (these will NOT be
      * urlencoded). If unspecified, there will be no query params.
      *
-     * @param {Object} [body] The HTTP JSON body.
+     * @param body - The HTTP JSON body.
      *
-     * @param {Object|Number=} opts additional options. If a number is specified,
+     * @param opts - additional options. If a number is specified,
      * this is treated as `opts.localTimeoutMs`.
      *
-     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
-     *
-     * @param {string=} opts.prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
-     *
-     * @param {string=} opts.baseUrl The alternative base url to use.
-     * If not specified, uses this.opts.baseUrl
-     *
-     * @param {Object=} opts.headers map of additional request headers
-     *
-     * @return {Promise} Resolves to <code>{data: {Object},
-     * headers: {Object}, code: {Number}}</code>.
-     * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
-     * object only.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
-     * occurred. This includes network problems and Matrix-specific error JSON.
+     * @returns Promise which resolves to
+     * ```
+     * {
+     *     data: {Object},
+     *     headers: {Object},
+     *     code: {Number},
+     * }
+     * ```
+     * If `onlyData` is set, this will resolve to the `data` object only.
+     * @returns Rejects with an error if a problem occurred.
+     * This includes network problems and Matrix-specific error JSON.
      */
     public authedRequest<T>(
         method: Method,
@@ -176,30 +169,28 @@ export class FetchHttpApi<O extends IHttpOpts> {
 
     /**
      * Perform a request to the homeserver without any credentials.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
+     * @param method - The HTTP method e.g. "GET".
+     * @param path - The HTTP path <b>after</b> the supplied prefix e.g.
      * "/createRoom".
      *
-     * @param {Object=} queryParams A dict of query params (these will NOT be
+     * @param queryParams - A dict of query params (these will NOT be
      * urlencoded). If unspecified, there will be no query params.
      *
-     * @param {Object} [body] The HTTP JSON body.
+     * @param body - The HTTP JSON body.
      *
-     * @param {Object=} opts additional options
+     * @param opts - additional options
      *
-     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
-     *
-     * @param {string=} opts.prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
-     *
-     * @param {Object=} opts.headers map of additional request headers
-     *
-     * @return {Promise} Resolves to <code>{data: {Object},
-     * headers: {Object}, code: {Number}}</code>.
-     * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
+     * @returns Promise which resolves to
+     * ```
+     * {
+     *  data: {Object},
+     *  headers: {Object},
+     *  code: {Number},
+     * }
+     * ```
+     * If `onlyData</code> is set, this will resolve to the <code>data`
      * object only.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
+     * @returns Rejects with an error if a problem
      * occurred. This includes network problems and Matrix-specific error JSON.
      */
     public request<T>(
@@ -215,21 +206,16 @@ export class FetchHttpApi<O extends IHttpOpts> {
 
     /**
      * Perform a request to an arbitrary URL.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} url The HTTP URL object.
-     *
-     * @param {Object} [body] The HTTP JSON body.
-     *
-     * @param {Object=} opts additional options
+     * @param method - The HTTP method e.g. "GET".
+     * @param url - The HTTP URL object.
      *
-     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
+     * @param body - The HTTP JSON body.
      *
-     * @param {Object=} opts.headers map of additional request headers
+     * @param opts - additional options
      *
-     * @return {Promise} Resolves to data unless `onlyData` is specified as false,
+     * @returns Promise which resolves to data unless `onlyData` is specified as false,
      * where the resolved value will be a fetch Response object.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
+     * @returns Rejects with an error if a problem
      * occurred. This includes network problems and Matrix-specific error JSON.
      */
     public async requestOtherUrl<T>(
@@ -310,11 +296,11 @@ export class FetchHttpApi<O extends IHttpOpts> {
 
     /**
      * Form and return a homeserver request URL based on the given path params and prefix.
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g. "/createRoom".
-     * @param {Object} queryParams A dict of query params (these will NOT be urlencoded).
-     * @param {string} prefix The full prefix to use e.g. "/_matrix/client/v2_alpha", defaulting to this.opts.prefix.
-     * @param {string} baseUrl The baseUrl to use e.g. "https://matrix.org/", defaulting to this.opts.baseUrl.
-     * @return {string} URL
+     * @param path - The HTTP path <b>after</b> the supplied prefix e.g. "/createRoom".
+     * @param queryParams - A dict of query params (these will NOT be urlencoded).
+     * @param prefix - The full prefix to use e.g. "/_matrix/client/v2_alpha", defaulting to this.opts.prefix.
+     * @param baseUrl - The baseUrl to use e.g. "https://matrix.org/", defaulting to this.opts.baseUrl.
+     * @returns URL
      */
     public getUrl(
         path: string,
diff --git a/src/http-api/index.ts b/src/http-api/index.ts
index c7f782d8972..3574f539e7f 100644
--- a/src/http-api/index.ts
+++ b/src/http-api/index.ts
@@ -35,27 +35,13 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
     /**
      * Upload content to the homeserver
      *
-     * @param {object} file The object to upload. On a browser, something that
+     * @param file - The object to upload. On a browser, something that
      *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,
      *   a Buffer, String or ReadStream.
      *
-     * @param {object} opts  options object
+     * @param opts - options object
      *
-     * @param {string=} opts.name   Name to give the file on the server. Defaults
-     *   to <tt>file.name</tt>.
-     *
-     * @param {boolean=} opts.includeFilename if false will not send the filename,
-     *   e.g for encrypted file uploads where filename leaks are undesirable.
-     *   Defaults to true.
-     *
-     * @param {string=} opts.type   Content-type for the upload. Defaults to
-     *   <tt>file.type</tt>, or <tt>application/octet-stream</tt>.
-     *
-     * @param {Function=} opts.progressHandler Optional. Called when a chunk of
-     *    data has been uploaded, with an object containing the fields `loaded`
-     *    (number of bytes transferred) and `total` (total size, if known).
-     *
-     * @return {Promise} Resolves to response object, as
+     * @returns Promise which resolves to response object, as
      *    determined by this.opts.onlyData, opts.rawResponse, and
      *    opts.onlyContentUri.  Rejects with an error (usually a MatrixError).
      */
@@ -190,7 +176,7 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
 
     /**
      * Get the content repository url with query parameters.
-     * @return {Object} An object with a 'base', 'path' and 'params' for base URL,
+     * @returns An object with a 'base', 'path' and 'params' for base URL,
      *          path and query parameters respectively.
      */
     public getContentUri(): IContentUri {
diff --git a/src/http-api/interface.ts b/src/http-api/interface.ts
index 37217947027..9946aa37bf2 100644
--- a/src/http-api/interface.ts
+++ b/src/http-api/interface.ts
@@ -32,11 +32,25 @@ export interface IHttpOpts {
 }
 
 export interface IRequestOpts {
+    /**
+     * The alternative base url to use.
+     * If not specified, uses this.opts.baseUrl
+     */
     baseUrl?: string;
+    /**
+     * The full prefix to use e.g.
+     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
+     */
     prefix?: string;
-
+    /**
+     * map of additional request headers
+     */
     headers?: Record<string, string>;
     abortSignal?: AbortSignal;
+    /**
+     * The maximum amount of time to wait before
+     * timing out the request. If not specified, there is no timeout.
+     */
     localTimeoutMs?: number;
     keepAlive?: boolean; // defaults to false
     json?: boolean; // defaults to true
@@ -62,7 +76,29 @@ export enum HttpApiEvent {
 }
 
 export type HttpApiEventHandlerMap = {
+    /**
+     * Fires whenever the login session the JS SDK is using is no
+     * longer valid and the user must log in again.
+     * NB. This only fires when action is required from the user, not
+     * when then login session can be renewed by using a refresh token.
+     * @example
+     * ```
+     * matrixClient.on("Session.logged_out", function(errorObj){
+     *   // show the login screen
+     * });
+     * ```
+     */
     [HttpApiEvent.SessionLoggedOut]: (err: MatrixError) => void;
+    /**
+     * Fires when the JS SDK receives a M_CONSENT_NOT_GIVEN error in response
+     * to a HTTP request.
+     * @example
+     * ```
+     * matrixClient.on("no_consent", function(message, contentUri) {
+     *     console.info(message + ' Go to ' + contentUri);
+     * });
+     * ```
+     */
     [HttpApiEvent.NoConsent]: (message: string, consentUri: string) => void;
 };
 
@@ -72,9 +108,26 @@ export interface UploadProgress {
 }
 
 export interface UploadOpts {
+    /**
+     * Name to give the file on the server. Defaults to <tt>file.name</tt>.
+     */
     name?: string;
+    /**
+     * Content-type for the upload. Defaults to
+     *   <tt>file.type</tt>, or <tt>applicaton/octet-stream</tt>.
+     */
     type?: string;
+    /**
+     * if false will not send the filename,
+     *   e.g for encrypted file uploads where filename leaks are undesirable.
+     *   Defaults to true.
+     */
     includeFilename?: boolean;
+    /**
+     * Optional. Called when a chunk of
+     *    data has been uploaded, with an object containing the fields `loaded`
+     *    (number of bytes transferred) and `total` (total size, if known).
+     */
     progressHandler?(progress: UploadProgress): void;
     abortController?: AbortController;
 }
diff --git a/src/http-api/utils.ts b/src/http-api/utils.ts
index 50466095002..c49be740ef6 100644
--- a/src/http-api/utils.ts
+++ b/src/http-api/utils.ts
@@ -67,9 +67,9 @@ export function anySignal(signals: AbortSignal[]): {
  * If it is a JSON response, we will parse it into a MatrixError. Otherwise
  * we return a generic Error.
  *
- * @param {XMLHttpRequest|Response} response response object
- * @param {String} body raw body of the response
- * @returns {Error}
+ * @param response - response object
+ * @param body - raw body of the response
+ * @returns
  */
 export function parseErrorResponse(response: XMLHttpRequest | Response, body?: string): Error {
     let contentType: ParsedMediaType | null;
@@ -102,8 +102,8 @@ function isXhr(response: XMLHttpRequest | Response): response is XMLHttpRequest
  *
  * returns null if no content-type header could be found.
  *
- * @param {XMLHttpRequest|Response} response response object
- * @returns {{type: String, parameters: Object}?} parsed content-type header, or null if not found
+ * @param response - response object
+ * @returns parsed content-type header, or null if not found
  */
 function getResponseContentType(response: XMLHttpRequest | Response): ParsedMediaType | null {
     let contentType: string | null;
@@ -124,10 +124,10 @@ function getResponseContentType(response: XMLHttpRequest | Response): ParsedMedi
 
 /**
  * Retries a network operation run in a callback.
- * @param  {number}   maxAttempts maximum attempts to try
- * @param  {Function} callback    callback that returns a promise of the network operation. If rejected with ConnectionError, it will be retried by calling the callback again.
- * @return {any} the result of the network operation
- * @throws {ConnectionError} If after maxAttempts the callback still throws ConnectionError
+ * @param maxAttempts - maximum attempts to try
+ * @param callback - callback that returns a promise of the network operation. If rejected with ConnectionError, it will be retried by calling the callback again.
+ * @returns the result of the network operation
+ * @throws {@link ConnectionError} If after maxAttempts the callback still throws ConnectionError
  */
 export async function retryNetworkOperation<T>(maxAttempts: number, callback: () => Promise<T>): Promise<T> {
     let attempts = 0;
diff --git a/src/indexeddb-helpers.ts b/src/indexeddb-helpers.ts
index 695a3145ff2..6f99ae54b8b 100644
--- a/src/indexeddb-helpers.ts
+++ b/src/indexeddb-helpers.ts
@@ -18,9 +18,9 @@ limitations under the License.
  * Check if an IndexedDB database exists. The only way to do so is to try opening it, so
  * we do that and then delete it did not exist before.
  *
- * @param {Object} indexedDB The `indexedDB` interface
- * @param {string} dbName The database name to test for
- * @returns {boolean} Whether the database exists
+ * @param indexedDB - The `indexedDB` interface
+ * @param dbName - The database name to test for
+ * @returns Whether the database exists
  */
 export function exists(indexedDB: IDBFactory, dbName: string): Promise<boolean> {
     return new Promise<boolean>((resolve, reject) => {
diff --git a/src/indexeddb-worker.ts b/src/indexeddb-worker.ts
index 45facc485a4..78e87b37329 100644
--- a/src/indexeddb-worker.ts
+++ b/src/indexeddb-worker.ts
@@ -20,6 +20,6 @@ limitations under the License.
  * to be used separately
  */
 
-/** The {@link module:indexeddb-store-worker~IndexedDBStoreWorker} class. */
+/** The {@link IndexedDBStoreWorker} class. */
 export { IndexedDBStoreWorker } from "./store/indexeddb-store-worker";
 
diff --git a/src/interactive-auth.ts b/src/interactive-auth.ts
index df4a42c2726..219569e6148 100644
--- a/src/interactive-auth.ts
+++ b/src/interactive-auth.ts
@@ -16,8 +16,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/** @module interactive-auth */
-
 import { logger } from './logger';
 import { MatrixClient } from "./client";
 import { defer, IDeferred } from "./utils";
@@ -31,8 +29,11 @@ interface IFlow {
 }
 
 export interface IInputs {
+    // An email address. If supplied, a flow using email verification will be chosen.
     emailAddress?: string;
+    // An ISO two letter country code. Gives the country that opts.phoneNumber should be resolved relative to.
     phoneCountry?: string;
+    // A phone number. If supplied, a flow using phone number validation will be chosen.
     phoneNumber?: string;
     registrationToken?: string;
 }
@@ -106,15 +107,66 @@ class NoAuthFlowFoundError extends Error {
 }
 
 interface IOpts {
+    /**
+     * A matrix client to use for the auth process
+     */
     matrixClient: MatrixClient;
+    /**
+     * Error response from the last request. If null, a request will be made with no auth before starting.
+     */
     authData?: IAuthData;
+    /**
+     * Inputs provided by the user and used by different stages of the auto process.
+     * The inputs provided will affect what flow is chosen.
+     */
     inputs?: IInputs;
+    /**
+     * If resuming an existing interactive auth session, the sessionId of that session.
+     */
     sessionId?: string;
+    /**
+     * If resuming an existing interactive auth session, the client secret for that session
+     */
     clientSecret?: string;
+    /**
+     * If returning from having completed m.login.email.identity auth, the sid for the email verification session.
+     */
     emailSid?: string;
+
+    /**
+     * Called with the new auth dict to submit the request.
+     * Also passes a second deprecated arg which is a flag set to true if this request is a background request.
+     * 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: IAuthData | null, background: boolean): Promise<IAuthData>;
+    /**
+     * 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.
+     * The arguments are: the login type (eg m.login.password); and an object which is either an error or an
+     * informational object specific to the login type.
+     * If the 'errcode' key is defined, the object is an error, and has keys:
+     *     errcode: string, the textual error code, eg. M_UNKNOWN
+     *     error: string, human readable string describing the error
+     *
+     * The login type specific objects are as follows:
+     *     m.login.email.identity:
+     *         * emailSid: string, the sid of the active email auth session
+     */
     stateUpdated(nextStage: AuthType, status: IStageStatus): void;
+
+    /**
+     * A function that takes the email address (string), clientSecret (string), attempt number (int) and
+     * sessionId (string) and calls the relevant requestToken function and returns the promise returned by that
+     * 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 }>;
+    /**
+     * 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
 }
@@ -131,70 +183,7 @@ interface IOpts {
  * callbacks, and information gathered from the user can be submitted with
  * submitAuthDict.
  *
- * @constructor
- * @alias module:interactive-auth
- *
- * @param {object} opts  options object
- *
- * @param {object} opts.matrixClient A matrix client to use for the auth process
- *
- * @param {object?} opts.authData error response from the last request. If
- *    null, a request will be made with no auth before starting.
- *
- * @param {function(object?): Promise} opts.doRequest
- *     called with the new auth dict to submit the request. Also passes a
- *     second deprecated arg which is a flag set to true if this request
- *     is a background request. 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.
- *
- * @param {function(boolean): Promise} opts.busyChanged
- *     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.
- *
- * @param {function(string, object?)} opts.stateUpdated
- *     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.
- *     The arguments are: the login type (eg m.login.password); and an object
- *     which is either an error or an informational object specific to the
- *     login type. If the 'errcode' key is defined, the object is an error,
- *     and has keys:
- *         errcode: string, the textual error code, eg. M_UNKNOWN
- *         error: string, human readable string describing the error
- *
- *     The login type specific objects are as follows:
- *         m.login.email.identity:
- *          * emailSid: string, the sid of the active email auth session
- *
- * @param {object?} opts.inputs Inputs provided by the user and used by different
- *     stages of the auto process. The inputs provided will affect what flow is chosen.
- *
- * @param {string?} opts.inputs.emailAddress An email address. If supplied, a flow
- *     using email verification will be chosen.
- *
- * @param {string?} opts.inputs.phoneCountry An ISO two letter country code. Gives
- *     the country that opts.phoneNumber should be resolved relative to.
- *
- * @param {string?} opts.inputs.phoneNumber A phone number. If supplied, a flow
- *     using phone number validation will be chosen.
- *
- * @param {string?} opts.sessionId If resuming an existing interactive auth session,
- *     the sessionId of that session.
- *
- * @param {string?} opts.clientSecret If resuming an existing interactive auth session,
- *     the client secret for that session
- *
- * @param {string?} opts.emailSid If returning from having completed m.login.email.identity
- *     auth, the sid for the email verification session.
- *
- * @param {function?} opts.requestEmailToken A function that takes the email address (string),
- *     clientSecret (string), attempt number (int) and sessionId (string) and calls the
- *     relevant requestToken function and returns the promise returned by that function.
- *     If the resulting promise rejects, the rejection will propagate through to the
- *     attemptAuth promise.
- *
+ * @param opts - options object
  */
 export class InteractiveAuth {
     private readonly matrixClient: MatrixClient;
@@ -236,7 +225,7 @@ export class InteractiveAuth {
     /**
      * begin the authentication process.
      *
-     * @return {Promise} which resolves to the response on success,
+     * @returns which resolves to the response on success,
      * or rejects with the error on failure. Rejects with NoAuthFlowFoundError if
      *     no suitable authentication flow can be found
      */
@@ -307,7 +296,7 @@ export class InteractiveAuth {
     /**
      * get the auth session ID
      *
-     * @return {string} session id
+     * @returns session id
      */
     public getSessionId(): string | undefined {
         return this.data?.session;
@@ -317,7 +306,7 @@ export class InteractiveAuth {
      * get the client secret used for validation sessions
      * with the identity server.
      *
-     * @return {string} client secret
+     * @returns client secret
      */
     public getClientSecret(): string {
         return this.clientSecret;
@@ -326,8 +315,8 @@ export class InteractiveAuth {
     /**
      * get the server params for a given stage
      *
-     * @param {string} loginType login type for the stage
-     * @return {object?} any parameters from the server for this stage
+     * @param loginType - login type for the stage
+     * @returns any parameters from the server for this stage
      */
     public getStageParams(loginType: string): Record<string, any> | undefined {
         return this.data.params?.[loginType];
@@ -342,10 +331,10 @@ export class InteractiveAuth {
      * make attemptAuth resolve/reject, or cause the startAuthStage callback
      * to be called for a new stage.
      *
-     * @param {object} authData new auth dict to send to the server. Should
+     * @param authData - new auth dict to send to the server. Should
      *    include a `type` property denoting the login type, as well as any
      *    other params for that stage.
-     * @param {boolean} background If true, this request failing will not result
+     * @param background - If true, this request failing will not result
      *    in the attemptAuth promise being rejected. This can be set to true
      *    for requests that just poll to see if auth has been completed elsewhere.
      */
@@ -398,7 +387,7 @@ export class InteractiveAuth {
      * Gets the sid for the email validation session
      * Specific to m.login.email.identity
      *
-     * @returns {string} The sid of the email auth session
+     * @returns The sid of the email auth session
      */
     public getEmailSid(): string | undefined {
         return this.emailSid;
@@ -410,7 +399,7 @@ export class InteractiveAuth {
      * of the email validation.
      * Specific to m.login.email.identity
      *
-     * @param {string} sid The sid for the email validation session
+     * @param sid - The sid for the email validation session
      */
     public setEmailSid(sid: string): void {
         this.emailSid = sid;
@@ -448,9 +437,9 @@ export class InteractiveAuth {
      * Fire off a request, and either resolve the promise, or call
      * startAuthStage.
      *
-     * @private
-     * @param {object?} auth new auth dict, including session id
-     * @param {boolean?} background If true, this request is a background poll, so it
+     * @internal
+     * @param auth - new auth dict, including session id
+     * @param background - If true, this request is a background poll, so it
      *    failing will not result in the attemptAuth promise being rejected.
      *    This can be set to true for requests that just poll to see if auth has
      *    been completed elsewhere.
@@ -526,8 +515,8 @@ export class InteractiveAuth {
     /**
      * Pick the next stage and call the callback
      *
-     * @private
-     * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
+     * @internal
+     * @throws {@link NoAuthFlowFoundError} If no suitable authentication flow can be found
      */
     private startNextAuthStage(): void {
         const nextStage = this.chooseStage();
@@ -559,9 +548,9 @@ export class InteractiveAuth {
     /**
      * Pick the next auth stage
      *
-     * @private
-     * @return {string?} login type
-     * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
+     * @internal
+     * @returns login type
+     * @throws {@link NoAuthFlowFoundError} If no suitable authentication flow can be found
      */
     private chooseStage(): AuthType | undefined {
         if (this.chosenFlow === null) {
@@ -584,9 +573,9 @@ export class InteractiveAuth {
      * this could result in the email not being used which would leave
      * the account with no means to reset a password.
      *
-     * @private
-     * @return {object} flow
-     * @throws {NoAuthFlowFoundError} If no suitable authentication flow can be found
+     * @internal
+     * @returns flow
+     * @throws {@link NoAuthFlowFoundError} If no suitable authentication flow can be found
      */
     private chooseFlow(): IFlow {
         const flows = this.data.flows || [];
@@ -625,9 +614,8 @@ export class InteractiveAuth {
     /**
      * Get the first uncompleted stage in the given flow
      *
-     * @private
-     * @param {object} flow
-     * @return {string} login type
+     * @internal
+     * @returns login type
      */
     private firstUncompletedStage(flow: IFlow): AuthType | undefined {
         const completed = this.data.completed || [];
diff --git a/src/logger.ts b/src/logger.ts
index de1ca6619c1..7077dee02e2 100644
--- a/src/logger.ts
+++ b/src/logger.ts
@@ -15,10 +15,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module logger
- */
-
 import log, { Logger } from "loglevel";
 
 // This is to demonstrate, that you can use any namespace you want.
@@ -56,7 +52,7 @@ log.methodFactory = function(methodName, logLevel, loggerName) {
 };
 
 /**
- * Drop-in replacement for <code>console</code> using {@link https://www.npmjs.com/package/loglevel|loglevel}.
+ * Drop-in replacement for `console` using {@link https://www.npmjs.com/package/loglevel|loglevel}.
  * Can be tailored down to specific use cases if needed.
  */
 export const logger = log.getLogger(DEFAULT_NAMESPACE) as PrefixedLogger;
diff --git a/src/matrix.ts b/src/matrix.ts
index 421e0e6ed87..d075c098e64 100644
--- a/src/matrix.ts
+++ b/src/matrix.ts
@@ -70,8 +70,7 @@ let cryptoStoreFactory = (): CryptoStore => new MemoryCryptoStore;
 /**
  * Configure a different factory to be used for creating crypto stores
  *
- * @param {Function} fac  a function which will return a new
- *    {@link module:crypto.store.base~CryptoStore}.
+ * @param fac - a function which will return a new {@link CryptoStore}
  */
 export function setCryptoStoreFactory(fac: () => CryptoStore): void {
     cryptoStoreFactory = fac;
@@ -88,24 +87,14 @@ function amendClientOpts(opts: ICreateClientOpts): ICreateClientOpts {
 }
 
 /**
- * Construct a Matrix Client. Similar to {@link module:client.MatrixClient}
+ * Construct a Matrix Client. Similar to {@link MatrixClient}
  * except that the 'request', 'store' and 'scheduler' dependencies are satisfied.
- * @param {Object} opts The configuration options for this client. These configuration
- * options will be passed directly to {@link module:client.MatrixClient}.
- * @param {Object} opts.store If not set, defaults to
- * {@link module:store/memory.MemoryStore}.
- * @param {Object} opts.scheduler If not set, defaults to
- * {@link module:scheduler~MatrixScheduler}.
+ * @param opts - The configuration options for this client. These configuration
+ * options will be passed directly to {@link MatrixClient}.
  *
- * @param {module:crypto.store.base~CryptoStore=} opts.cryptoStore
- *    crypto store implementation. Calls the factory supplied to
- *    {@link setCryptoStoreFactory} if unspecified; or if no factory has been
- *    specified, uses a default implementation (indexeddb in the browser,
- *    in-memory otherwise).
- *
- * @return {MatrixClient} A new matrix client.
- * @see {@link module:client.MatrixClient} for the full list of options for
- * <code>opts</code>.
+ * @returns A new matrix client.
+ * @see {@link MatrixClient} for the full list of options for
+ * `opts`.
  */
 export function createClient(opts: ICreateClientOpts): MatrixClient {
     return new MatrixClient(amendClientOpts(opts));
diff --git a/src/models/MSC3089Branch.ts b/src/models/MSC3089Branch.ts
index 25ce51a20a1..e4c0eb2870a 100644
--- a/src/models/MSC3089Branch.ts
+++ b/src/models/MSC3089Branch.ts
@@ -67,7 +67,7 @@ export class MSC3089Branch {
 
     /**
      * Deletes the file from the tree, including all prior edits/versions.
-     * @returns {Promise<void>} Resolves when complete.
+     * @returns Promise which resolves when complete.
      */
     public async delete(): Promise<void> {
         await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {}, this.id);
@@ -79,7 +79,7 @@ export class MSC3089Branch {
 
     /**
      * Gets the name for this file.
-     * @returns {string} The name, or "Unnamed File" if unknown.
+     * @returns The name, or "Unnamed File" if unknown.
      */
     public getName(): string {
         return this.indexEvent.getContent()['name'] || "Unnamed File";
@@ -87,8 +87,8 @@ export class MSC3089Branch {
 
     /**
      * Sets the name for this file.
-     * @param {string} name The new name for this file.
-     * @returns {Promise<void>} Resolves when complete.
+     * @param name - The new name for this file.
+     * @returns Promise which resolves when complete.
      */
     public async setName(name: string): Promise<void> {
         await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
@@ -99,7 +99,7 @@ export class MSC3089Branch {
 
     /**
      * Gets whether or not a file is locked.
-     * @returns {boolean} True if locked, false otherwise.
+     * @returns True if locked, false otherwise.
      */
     public isLocked(): boolean {
         return this.indexEvent.getContent()['locked'] || false;
@@ -107,8 +107,8 @@ export class MSC3089Branch {
 
     /**
      * Sets a file as locked or unlocked.
-     * @param {boolean} locked True to lock the file, false otherwise.
-     * @returns {Promise<void>} Resolves when complete.
+     * @param locked - True to lock the file, false otherwise.
+     * @returns Promise which resolves when complete.
      */
     public async setLocked(locked: boolean): Promise<void> {
         await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
@@ -119,7 +119,7 @@ export class MSC3089Branch {
 
     /**
      * Gets information about the file needed to download it.
-     * @returns {Promise<{info: IEncryptedFile, httpUrl: string}>} Information about the file.
+     * @returns Information about the file.
      */
     public async getFileInfo(): Promise<{ info: IEncryptedFile, httpUrl: string }> {
         const event = await this.getFileEvent();
@@ -136,7 +136,7 @@ export class MSC3089Branch {
 
     /**
      * Gets the event the file points to.
-     * @returns {Promise<MatrixEvent>} Resolves to the file's event.
+     * @returns Promise which resolves to the file's event.
      */
     public async getFileEvent(): Promise<MatrixEvent> {
         const room = this.client.getRoom(this.roomId);
@@ -161,11 +161,11 @@ export class MSC3089Branch {
 
     /**
      * Creates a new version of this file with contents in a type that is compatible with MatrixClient.uploadContent().
-     * @param {string} name The name of the file.
-     * @param {File | String | Buffer | ReadStream | Blob} encryptedContents The encrypted contents.
-     * @param {Partial<IEncryptedFile>} info The encrypted file information.
-     * @param {IContent} additionalContent Optional event content fields to include in the message.
-     * @returns {Promise<ISendEventResponse>} Resolves to the file event's sent response.
+     * @param name - The name of the file.
+     * @param encryptedContents - The encrypted contents.
+     * @param info - The encrypted file information.
+     * @param additionalContent - Optional event content fields to include in the message.
+     * @returns Promise which resolves to the file event's sent response.
      */
     public async createNewVersion(
         name: string,
@@ -200,7 +200,7 @@ export class MSC3089Branch {
 
     /**
      * Gets the file's version history, starting at this file.
-     * @returns {Promise<MSC3089Branch[]>} Resolves to the file's version history, with the
+     * @returns Promise which resolves to the file's version history, with the
      * first element being the current version and the last element being the first version.
      */
     public async getVersionHistory(): Promise<MSC3089Branch[]> {
diff --git a/src/models/MSC3089TreeSpace.ts b/src/models/MSC3089TreeSpace.ts
index f437eab84da..76c733996c1 100644
--- a/src/models/MSC3089TreeSpace.ts
+++ b/src/models/MSC3089TreeSpace.ts
@@ -111,8 +111,8 @@ export class MSC3089TreeSpace {
 
     /**
      * Sets the name of the tree space.
-     * @param {string} name The new name for the space.
-     * @returns {Promise<void>} Resolves when complete.
+     * @param name - The new name for the space.
+     * @returns Promise which resolves when complete.
      */
     public async setName(name: string): Promise<void> {
         await this.client.sendStateEvent(this.roomId, EventType.RoomName, { name }, "");
@@ -121,15 +121,15 @@ export class MSC3089TreeSpace {
     /**
      * Invites a user to the tree space. They will be given the default Viewer
      * permission level unless specified elsewhere.
-     * @param {string} userId The user ID to invite.
-     * @param {boolean} andSubspaces True (default) to invite the user to all
+     * @param userId - The user ID to invite.
+     * @param andSubspaces - True (default) to invite the user to all
      * directories/subspaces too, recursively.
-     * @param {boolean} shareHistoryKeys True (default) to share encryption keys
+     * @param shareHistoryKeys - True (default) to share encryption keys
      * with the invited user. This will allow them to decrypt the events (files)
      * in the tree. Keys will not be shared if the room is lacking appropriate
      * history visibility (by default, history visibility is "shared" in trees,
      * which is an appropriate visibility for these purposes).
-     * @returns {Promise<void>} Resolves when complete.
+     * @returns Promise which resolves when complete.
      */
     public async invite(userId: string, andSubspaces = true, shareHistoryKeys = true): Promise<void> {
         const promises: Promise<void>[] = [this.retryInvite(userId)];
@@ -164,9 +164,9 @@ export class MSC3089TreeSpace {
      * Sets the permissions of a user to the given role. Note that if setting a user
      * to Owner then they will NOT be able to be demoted. If the user does not have
      * permission to change the power level of the target, an error will be thrown.
-     * @param {string} userId The user ID to change the role of.
-     * @param {TreePermissions} role The role to assign.
-     * @returns {Promise<void>} Resolves when complete.
+     * @param userId - The user ID to change the role of.
+     * @param role - The role to assign.
+     * @returns Promise which resolves when complete.
      */
     public async setPermissions(userId: string, role: TreePermissions): Promise<void> {
         const currentPls = this.room.currentState.getStateEvents(EventType.RoomPowerLevels, "");
@@ -200,8 +200,8 @@ export class MSC3089TreeSpace {
      * Gets the current permissions of a user. Note that any users missing explicit permissions (or not
      * in the space) will be considered Viewers. Appropriate membership checks need to be performed
      * elsewhere.
-     * @param {string} userId The user ID to check permissions of.
-     * @returns {TreePermissions} The permissions for the user, defaulting to Viewer.
+     * @param userId - The user ID to check permissions of.
+     * @returns The permissions for the user, defaulting to Viewer.
      */
     public getPermissions(userId: string): TreePermissions {
         const currentPls = this.room.currentState.getStateEvents(EventType.RoomPowerLevels, "");
@@ -220,8 +220,8 @@ export class MSC3089TreeSpace {
 
     /**
      * Creates a directory under this tree space, represented as another tree space.
-     * @param {string} name The name for the directory.
-     * @returns {Promise<MSC3089TreeSpace>} Resolves to the created directory.
+     * @param name - The name for the directory.
+     * @returns Promise which resolves to the created directory.
      */
     public async createDirectory(name: string): Promise<MSC3089TreeSpace> {
         const directory = await this.client.unstableCreateFileTree(name);
@@ -239,7 +239,7 @@ export class MSC3089TreeSpace {
 
     /**
      * Gets a list of all known immediate subdirectories to this tree space.
-     * @returns {MSC3089TreeSpace[]} The tree spaces (directories). May be empty, but not null.
+     * @returns The tree spaces (directories). May be empty, but not null.
      */
     public getDirectories(): MSC3089TreeSpace[] {
         const trees: MSC3089TreeSpace[] = [];
@@ -261,8 +261,8 @@ export class MSC3089TreeSpace {
     /**
      * Gets a subdirectory of a given ID under this tree space. Note that this will not recurse
      * into children and instead only look one level deep.
-     * @param {string} roomId The room ID (directory ID) to find.
-     * @returns {MSC3089TreeSpace | undefined} The directory, or undefined if not found.
+     * @param roomId - The room ID (directory ID) to find.
+     * @returns The directory, or undefined if not found.
      */
     public getDirectory(roomId: string): MSC3089TreeSpace | undefined {
         return this.getDirectories().find(r => r.roomId === roomId);
@@ -270,7 +270,7 @@ export class MSC3089TreeSpace {
 
     /**
      * Deletes the tree, kicking all members and deleting **all subdirectories**.
-     * @returns {Promise<void>} Resolves when complete.
+     * @returns Promise which resolves when complete.
      */
     public async delete(): Promise<void> {
         const subdirectories = this.getDirectories();
@@ -341,7 +341,7 @@ export class MSC3089TreeSpace {
     /**
      * Gets the current order index for this directory. Note that if this is the top level space
      * then -1 will be returned.
-     * @returns {number} The order index of this space.
+     * @returns The order index of this space.
      */
     public getOrder(): number {
         if (this.isTopLevel) return -1;
@@ -357,8 +357,8 @@ export class MSC3089TreeSpace {
      * Sets the order index for this directory within its parent. Note that if this is a top level
      * space then an error will be thrown. -1 can be used to move the child to the start, and numbers
      * larger than the number of children can be used to move the child to the end.
-     * @param {number} index The new order index for this space.
-     * @returns {Promise<void>} Resolves when complete.
+     * @param index - The new order index for this space.
+     * @returns Promise which resolves when complete.
      * @throws Throws if this is a top level space.
      */
     public async setOrder(index: number): Promise<void> {
@@ -464,11 +464,11 @@ export class MSC3089TreeSpace {
     /**
      * Creates (uploads) a new file to this tree. The file must have already been encrypted for the room.
      * The file contents are in a type that is compatible with MatrixClient.uploadContent().
-     * @param {string} name The name of the file.
-     * @param {File | String | Buffer | ReadStream | Blob} encryptedContents The encrypted contents.
-     * @param {Partial<IEncryptedFile>} info The encrypted file information.
-     * @param {IContent} additionalContent Optional event content fields to include in the message.
-     * @returns {Promise<ISendEventResponse>} Resolves to the file event's sent response.
+     * @param name - The name of the file.
+     * @param encryptedContents - The encrypted contents.
+     * @param info - The encrypted file information.
+     * @param additionalContent - Optional event content fields to include in the message.
+     * @returns Promise which resolves to the file event's sent response.
      */
     public async createFile(
         name: string,
@@ -512,8 +512,8 @@ export class MSC3089TreeSpace {
 
     /**
      * Retrieves a file from the tree.
-     * @param {string} fileEventId The event ID of the file.
-     * @returns {MSC3089Branch | null} The file, or null if not found.
+     * @param fileEventId - The event ID of the file.
+     * @returns The file, or null if not found.
      */
     public getFile(fileEventId: string): MSC3089Branch | null {
         const branch = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name, fileEventId);
@@ -522,7 +522,7 @@ export class MSC3089TreeSpace {
 
     /**
      * Gets an array of all known files for the tree.
-     * @returns {MSC3089Branch[]} The known files. May be empty, but not null.
+     * @returns The known files. May be empty, but not null.
      */
     public listFiles(): MSC3089Branch[] {
         return this.listAllFiles().filter(b => b.isActive);
@@ -530,7 +530,7 @@ export class MSC3089TreeSpace {
 
     /**
      * Gets an array of all known files for the tree, including inactive/invalid ones.
-     * @returns {MSC3089Branch[]} The known files. May be empty, but not null.
+     * @returns The known files. May be empty, but not null.
      */
     public listAllFiles(): MSC3089Branch[] {
         const branches = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name) ?? [];
diff --git a/src/models/event-context.ts b/src/models/event-context.ts
index 60252627bde..0401cd53007 100644
--- a/src/models/event-context.ts
+++ b/src/models/event-context.ts
@@ -17,9 +17,6 @@ limitations under the License.
 import { MatrixEvent } from "./event";
 import { Direction } from "./event-timeline";
 
-/**
- * @module models/event-context
- */
 export class EventContext {
     private timeline: MatrixEvent[];
     private ourEventIndex = 0;
@@ -38,9 +35,7 @@ export class EventContext {
      * It also stores pagination tokens for going backwards and forwards in the
      * timeline.
      *
-     * @param {MatrixEvent} ourEvent  the event at the centre of this context
-     *
-     * @constructor
+     * @param ourEvent - the event at the centre of this context
      */
     public constructor(public readonly ourEvent: MatrixEvent) {
         this.timeline = [ourEvent];
@@ -51,7 +46,7 @@ export class EventContext {
      *
      * This is a convenience function for getTimeline()[getOurEventIndex()].
      *
-     * @return {MatrixEvent} The event at the centre of this context.
+     * @returns The event at the centre of this context.
      */
     public getEvent(): MatrixEvent {
         return this.timeline[this.ourEventIndex];
@@ -60,7 +55,7 @@ export class EventContext {
     /**
      * Get the list of events in this context
      *
-     * @return {Array} An array of MatrixEvents
+     * @returns An array of MatrixEvents
      */
     public getTimeline(): MatrixEvent[] {
         return this.timeline;
@@ -68,8 +63,6 @@ export class EventContext {
 
     /**
      * Get the index in the timeline of our event
-     *
-     * @return {Number}
      */
     public getOurEventIndex(): number {
         return this.ourEventIndex;
@@ -78,9 +71,7 @@ export class EventContext {
     /**
      * Get a pagination token.
      *
-     * @param {boolean} backwards   true to get the pagination token for going
-     *                                  backwards in time
-     * @return {string}
+     * @param backwards -   true to get the pagination token for going
      */
     public getPaginateToken(backwards = false): string | null {
         return this.paginateTokens[backwards ? Direction.Backward : Direction.Forward];
@@ -91,8 +82,8 @@ export class EventContext {
      *
      * Generally this will be used only by the matrix js sdk.
      *
-     * @param {string} token        pagination token
-     * @param {boolean} backwards   true to set the pagination token for going
+     * @param token -        pagination token
+     * @param backwards -   true to set the pagination token for going
      *                                   backwards in time
      */
     public setPaginateToken(token?: string, backwards = false): void {
@@ -102,8 +93,8 @@ export class EventContext {
     /**
      * Add more events to the timeline
      *
-     * @param {Array} events      new events, in timeline order
-     * @param {boolean} atStart   true to insert new events at the start
+     * @param events -      new events, in timeline order
+     * @param atStart -   true to insert new events at the start
      */
     public addEvents(events: MatrixEvent[], atStart = false): void {
         // TODO: should we share logic with Room.addEventsToTimeline?
diff --git a/src/models/event-status.ts b/src/models/event-status.ts
index faca97186c9..a5113e0b790 100644
--- a/src/models/event-status.ts
+++ b/src/models/event-status.ts
@@ -17,7 +17,6 @@ limitations under the License.
 /**
  * Enum for event statuses.
  * @readonly
- * @enum {string}
  */
 export enum EventStatus {
     /** The event was not sent and will no longer be retried. */
diff --git a/src/models/event-timeline-set.ts b/src/models/event-timeline-set.ts
index 6dd2a0e7740..e1da746c993 100644
--- a/src/models/event-timeline-set.ts
+++ b/src/models/event-timeline-set.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/event-timeline-set
- */
-
 import { EventTimeline, IAddEventOptions } from "./event-timeline";
 import { MatrixEvent } from "./event";
 import { logger } from '../logger';
@@ -31,16 +27,20 @@ import { Thread, ThreadFilterType } from "./thread";
 
 const DEBUG = true;
 
+/* istanbul ignore next */
 let debuglog: (...args: any[]) => void;
 if (DEBUG) {
     // using bind means that we get to keep useful line numbers in the console
     debuglog = logger.log.bind(logger);
 } else {
+    /* istanbul ignore next */
     debuglog = function(): void {};
 }
 
 interface IOpts {
+    // Set to true to enable improved timeline support.
     timelineSupport?: boolean;
+    // The filter object, if any, for this timelineSet.
     filter?: Filter;
     pendingEvents?: boolean;
 }
@@ -51,7 +51,9 @@ export enum DuplicateStrategy {
 }
 
 export interface IRoomTimelineData {
+    // the timeline the event was added to/removed from
     timeline: EventTimeline;
+    // true if the event was a real-time event added to the end of the live timeline
     liveEvent?: boolean;
 }
 
@@ -75,6 +77,26 @@ export interface IAddLiveEventOptions
 type EmittedEvents = RoomEvent.Timeline | RoomEvent.TimelineReset;
 
 export type EventTimelineSetHandlerMap = {
+    /**
+     * Fires whenever the timeline in a room is updated.
+     * @param event - The matrix event which caused this event to fire.
+     * @param room - The room, if any, whose timeline was updated.
+     * @param toStartOfTimeline - True if this event was added to the start
+     * @param removed - True if this event has just been removed from the timeline
+     * (beginning; oldest) of the timeline e.g. due to pagination.
+     *
+     * @param data - more data about the event
+     *
+     * @example
+     * ```
+     * matrixClient.on("Room.timeline",
+     *                 function(event, room, toStartOfTimeline, removed, data) {
+     *   if (!toStartOfTimeline && data.liveEvent) {
+     *     var messageToAppend = room.timeline.[room.timeline.length - 1];
+     *   }
+     * });
+     * ```
+     */
     [RoomEvent.Timeline]: (
         event: MatrixEvent,
         room: Room | undefined,
@@ -82,6 +104,18 @@ export type EventTimelineSetHandlerMap = {
         removed: boolean,
         data: IRoomTimelineData,
     ) => void;
+    /**
+     * Fires whenever the live timeline in a room is reset.
+     *
+     * When we get a 'limited' sync (for example, after a network outage), we reset
+     * the live timeline to be empty before adding the recent events to the new
+     * timeline. This event is fired after the timeline is reset, and before the
+     * new events are added.
+     *
+     * @param room - The room whose live timeline was reset, if any
+     * @param timelineSet - timelineSet room whose live timeline was reset
+     * @param resetAllTimelines - True if all timelines were reset.
+     */
     [RoomEvent.TimelineReset]: (
         room: Room | undefined,
         eventTimelineSet: EventTimelineSet,
@@ -119,20 +153,13 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * <p>In order that we can find events from their ids later, we also maintain a
      * map from event_id to timeline and index.
      *
-     * @constructor
-     * @param {Room=} room
-     * Room for this timelineSet. May be null for non-room cases, such as the
+     * @param room - Room for this timelineSet. May be null for non-room cases, such as the
      * notification timeline.
-     * @param {Object} opts Options inherited from Room.
-     *
-     * @param {boolean} [opts.timelineSupport = false]
-     * Set to true to enable improved timeline support.
-     * @param {Object} [opts.filter = null]
-     * The filter object, if any, for this timelineSet.
-     * @param {MatrixClient=} client the Matrix client which owns this EventTimelineSet,
+     * @param opts - Options inherited from Room.
+     * @param client - the Matrix client which owns this EventTimelineSet,
      * can be omitted if room is specified.
-     * @param {Thread=} thread the thread to which this timeline set relates.
-     * @param {boolean} isThreadTimeline Whether this timeline set relates to a thread list timeline
+     * @param thread - the thread to which this timeline set relates.
+     * @param isThreadTimeline - Whether this timeline set relates to a thread list timeline
      * (e.g., All threads or My threads)
      */
     public constructor(
@@ -159,7 +186,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
 
     /**
      * Get all the timelines in this set
-     * @return {module:models/event-timeline~EventTimeline[]} the timelines in this set
+     * @returns the timelines in this set
      */
     public getTimelines(): EventTimeline[] {
         return this.timelines;
@@ -167,7 +194,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
 
     /**
      * Get the filter object this timeline set is filtered on, if any
-     * @return {?Filter} the optional filter for this timelineSet
+     * @returns the optional filter for this timelineSet
      */
     public getFilter(): Filter | undefined {
         return this.filter;
@@ -176,7 +203,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Set the filter object this timeline set is filtered on
      * (passed to the server when paginating via /messages).
-     * @param {Filter} filter the filter for this timelineSet
+     * @param filter - the filter for this timelineSet
      */
     public setFilter(filter?: Filter): void {
         this.filter = filter;
@@ -186,10 +213,10 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * Get the list of pending sent events for this timelineSet's room, filtered
      * by the timelineSet's filter if appropriate.
      *
-     * @return {module:models/event.MatrixEvent[]} A list of the sent events
+     * @returns A list of the sent events
      * waiting for remote echo.
      *
-     * @throws If <code>opts.pendingEventOrdering</code> was not 'detached'
+     * @throws If `opts.pendingEventOrdering` was not 'detached'
      */
     public getPendingEvents(): MatrixEvent[] {
         if (!this.room || !this.displayPendingEvents) {
@@ -201,7 +228,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Get the live timeline for this room.
      *
-     * @return {module:models/event-timeline~EventTimeline} live timeline
+     * @returns live timeline
      */
     public getLiveTimeline(): EventTimeline {
         return this.liveTimeline;
@@ -210,7 +237,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Set the live timeline for this room.
      *
-     * @return {module:models/event-timeline~EventTimeline} live timeline
+     * @returns live timeline
      */
     public setLiveTimeline(timeline: EventTimeline): void {
         this.liveTimeline = timeline;
@@ -218,8 +245,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
 
     /**
      * Return the timeline (if any) this event is in.
-     * @param {String} eventId the eventId being sought
-     * @return {module:models/event-timeline~EventTimeline} timeline
+     * @param eventId - the eventId being sought
+     * @returns timeline
      */
     public eventIdToTimeline(eventId: string): EventTimeline | undefined {
         return this._eventIdToTimeline.get(eventId);
@@ -228,8 +255,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Track a new event as if it were in the same timeline as an old event,
      * replacing it.
-     * @param {String} oldEventId  event ID of the original event
-     * @param {String} newEventId  event ID of the replacement event
+     * @param oldEventId -  event ID of the original event
+     * @param newEventId -  event ID of the replacement event
      */
     public replaceEventId(oldEventId: string, newEventId: string): void {
         const existingTimeline = this._eventIdToTimeline.get(oldEventId);
@@ -244,11 +271,12 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      *
      * <p>This is used when /sync returns a 'limited' timeline.
      *
-     * @param {string=} backPaginationToken   token for back-paginating the new timeline
-     * @param {string=} forwardPaginationToken token for forward-paginating the old live timeline,
+     * @param backPaginationToken -   token for back-paginating the new timeline
+     * @param forwardPaginationToken - token for forward-paginating the old live timeline,
      * if absent or null, all timelines are reset.
      *
-     * @fires module:client~MatrixClient#event:"Room.timelineReset"
+     * @remarks
+     * Fires {@link RoomEvent.TimelineReset}
      */
     public resetLiveTimeline(backPaginationToken?: string, forwardPaginationToken?: string): void {
         // Each EventTimeline has RoomState objects tracking the state at the start
@@ -293,8 +321,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Get the timeline which contains the given event, if any
      *
-     * @param {string} eventId  event ID to look for
-     * @return {?module:models/event-timeline~EventTimeline} timeline containing
+     * @param eventId -  event ID to look for
+     * @returns timeline containing
      * the given event, or null if unknown
      */
     public getTimelineForEvent(eventId?: string): EventTimeline | null {
@@ -306,8 +334,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Get an event which is stored in our timelines
      *
-     * @param {string} eventId  event ID to look for
-     * @return {?module:models/event~MatrixEvent} the given event, or undefined if unknown
+     * @param eventId -  event ID to look for
+     * @returns the given event, or undefined if unknown
      */
     public findEventById(eventId: string): MatrixEvent | undefined {
         const tl = this.getTimelineForEvent(eventId);
@@ -322,7 +350,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Add a new timeline to this timeline list
      *
-     * @return {module:models/event-timeline~EventTimeline} newly-created timeline
+     * @returns newly-created timeline
      */
     public addTimeline(): EventTimeline {
         if (!this.timelineSupport) {
@@ -341,18 +369,19 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      *
      * <p>Will fire "Room.timeline" for each event added.
      *
-     * @param {MatrixEvent[]} events A list of events to add.
+     * @param events - A list of events to add.
      *
-     * @param {boolean} toStartOfTimeline   True to add these events to the start
+     * @param toStartOfTimeline -   True to add these events to the start
      * (oldest) instead of the end (newest) of the timeline. If true, the oldest
      * event will be the <b>last</b> element of 'events'.
      *
-     * @param {module:models/event-timeline~EventTimeline} timeline   timeline to
+     * @param timeline -   timeline to
      *    add events to.
      *
-     * @param {string=} paginationToken   token for the next batch of events
+     * @param paginationToken -   token for the next batch of events
      *
-     * @fires module:client~MatrixClient#event:"Room.timeline"
+     * @remarks
+     * Fires {@link RoomEvent.Timeline}
      *
      */
     public addEventsToTimeline(
@@ -557,8 +586,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Add an event to the end of this live timeline.
      *
-     * @param {MatrixEvent} event Event to be added
-     * @param {IAddLiveEventOptions} options addLiveEvent options
+     * @param event - Event to be added
+     * @param options - addLiveEvent options
      */
     public addLiveEvent(
         event: MatrixEvent,
@@ -653,11 +682,10 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      *
      * Will fire "Room.timeline" for each event added.
      *
-     * @param {MatrixEvent} event
-     * @param {EventTimeline} timeline
-     * @param {IAddEventToTimelineOptions} options addEventToTimeline options
+     * @param options - addEventToTimeline options
      *
-     * @fires module:client~MatrixClient#event:"Room.timeline"
+     * @remarks
+     * Fires {@link RoomEvent.Timeline}
      */
     public addEventToTimeline(
         event: MatrixEvent,
@@ -745,11 +773,12 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * Replaces event with ID oldEventId with one with newEventId, if oldEventId is
      * recognised.  Otherwise, add to the live timeline.  Used to handle remote echos.
      *
-     * @param {MatrixEvent} localEvent     the new event to be added to the timeline
-     * @param {String} oldEventId          the ID of the original event
-     * @param {boolean} newEventId         the ID of the replacement event
+     * @param localEvent -     the new event to be added to the timeline
+     * @param oldEventId -          the ID of the original event
+     * @param newEventId -         the ID of the replacement event
      *
-     * @fires module:client~MatrixClient#event:"Room.timeline"
+     * @remarks
+     * Fires {@link RoomEvent.Timeline}
      */
     public handleRemoteEcho(
         localEvent: MatrixEvent,
@@ -771,9 +800,9 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Removes a single event from this room.
      *
-     * @param {String} eventId  The id of the event to remove
+     * @param eventId -  The id of the event to remove
      *
-     * @return {?MatrixEvent} the removed event, or null if the event was not found
+     * @returns the removed event, or null if the event was not found
      * in this room.
      */
     public removeEvent(eventId: string): MatrixEvent | null {
@@ -796,10 +825,10 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     /**
      * Determine where two events appear in the timeline relative to one another
      *
-     * @param {string} eventId1   The id of the first event
-     * @param {string} eventId2   The id of the second event
+     * @param eventId1 -   The id of the first event
+     * @param eventId2 -   The id of the second event
 
-     * @return {?number} a number less than zero if eventId1 precedes eventId2, and
+     * @returns a number less than zero if eventId1 precedes eventId2, and
      *    greater than zero if eventId1 succeeds eventId2. zero if they are the
      *    same event; null if we can't tell (either because we don't know about one
      *    of the events, or because they are in separate timelines which don't join
@@ -873,9 +902,9 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * for events which should be shown in the main room timeline.
      * Requires the `room` property to have been set at EventTimelineSet construction time.
      *
-     * @param event {MatrixEvent} the event to check whether it belongs to this timeline set.
-     * @throws {Error} if `room` was not set when constructing this timeline set.
-     * @return {boolean} whether the event belongs to this timeline set.
+     * @param event - the event to check whether it belongs to this timeline set.
+     * @throws Error if `room` was not set when constructing this timeline set.
+     * @returns whether the event belongs to this timeline set.
      */
     public canContain(event: MatrixEvent): boolean {
         if (!this.room) {
@@ -891,43 +920,3 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         return shouldLiveInRoom;
     }
 }
-
-/**
- * Fires whenever the timeline in a room is updated.
- * @event module:client~MatrixClient#"Room.timeline"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {?Room} room The room, if any, whose timeline was updated.
- * @param {boolean} toStartOfTimeline True if this event was added to the start
- * @param {boolean} removed True if this event has just been removed from the timeline
- * (beginning; oldest) of the timeline e.g. due to pagination.
- *
- * @param {object} data  more data about the event
- *
- * @param {module:models/event-timeline.EventTimeline} data.timeline the timeline the
- * event was added to/removed from
- *
- * @param {boolean} data.liveEvent true if the event was a real-time event
- * added to the end of the live timeline
- *
- * @example
- * matrixClient.on("Room.timeline",
- *                 function(event, room, toStartOfTimeline, removed, data) {
- *   if (!toStartOfTimeline && data.liveEvent) {
- *     var messageToAppend = room.timeline.[room.timeline.length - 1];
- *   }
- * });
- */
-
-/**
- * Fires whenever the live timeline in a room is reset.
- *
- * When we get a 'limited' sync (for example, after a network outage), we reset
- * the live timeline to be empty before adding the recent events to the new
- * timeline. This event is fired after the timeline is reset, and before the
- * new events are added.
- *
- * @event module:client~MatrixClient#"Room.timelineReset"
- * @param {Room} room The room whose live timeline was reset, if any
- * @param {EventTimelineSet} timelineSet timelineSet room whose live timeline was reset
- * @param {boolean} resetAllTimelines True if all timelines were reset.
- */
diff --git a/src/models/event-timeline.ts b/src/models/event-timeline.ts
index eff2b791057..ad97a4ef27a 100644
--- a/src/models/event-timeline.ts
+++ b/src/models/event-timeline.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/event-timeline
- */
-
 import { logger } from '../logger';
 import { IMarkerFoundOptions, RoomState } from "./room-state";
 import { EventTimelineSet } from "./event-timeline-set";
@@ -63,9 +59,9 @@ export class EventTimeline {
     /**
      * Static helper method to set sender and target properties
      *
-     * @param {MatrixEvent} event   the event whose metadata is to be set
-     * @param {RoomState} stateContext  the room state to be queried
-     * @param {boolean} toStartOfTimeline  if true the event's forwardLooking flag is set false
+     * @param event -   the event whose metadata is to be set
+     * @param stateContext -  the room state to be queried
+     * @param toStartOfTimeline -  if true the event's forwardLooking flag is set false
      */
     public static setEventMetadata(event: MatrixEvent, stateContext: RoomState, toStartOfTimeline: boolean): void {
         // When we try to generate a sentinel member before we have that member
@@ -127,8 +123,7 @@ export class EventTimeline {
      * <p>Once a timeline joins up with its neighbour, they are linked together into a
      * doubly-linked list.
      *
-     * @param {EventTimelineSet} eventTimelineSet the set of timelines this is part of
-     * @constructor
+     * @param eventTimelineSet - the set of timelines this is part of
      */
     public constructor(private readonly eventTimelineSet: EventTimelineSet) {
         this.roomId = eventTimelineSet.room?.roomId ?? null;
@@ -148,9 +143,9 @@ export class EventTimeline {
      *
      * <p>This can only be called before any events are added.
      *
-     * @param {MatrixEvent[]} stateEvents list of state events to initialise the
+     * @param stateEvents - list of state events to initialise the
      * state with.
-     * @throws {Error} if an attempt is made to call this after addEvent is called.
+     * @throws Error if an attempt is made to call this after addEvent is called.
      */
     public initialiseState(stateEvents: MatrixEvent[], { timelineWasEmpty }: IInitialiseStateOptions = {}): void {
         if (this.events.length > 0) {
@@ -167,11 +162,11 @@ export class EventTimeline {
      * The end state of this timeline gets replaced with an independent copy of the current RoomState,
      * and will need a new pagination token if it ever needs to paginate forwards.
 
-     * @param {string} direction   EventTimeline.BACKWARDS to get the state at the
+     * @param direction -   EventTimeline.BACKWARDS to get the state at the
      *   start of the timeline; EventTimeline.FORWARDS to get the state at the end
      *   of the timeline.
      *
-     * @return {EventTimeline} the new timeline
+     * @returns the new timeline
      */
     public forkLive(direction: Direction): EventTimeline {
         const forkState = this.getState(direction);
@@ -191,11 +186,11 @@ export class EventTimeline {
     /**
      * Creates an independent timeline, inheriting the directional state from this timeline.
      *
-     * @param {string} direction   EventTimeline.BACKWARDS to get the state at the
+     * @param direction -   EventTimeline.BACKWARDS to get the state at the
      *   start of the timeline; EventTimeline.FORWARDS to get the state at the end
      *   of the timeline.
      *
-     * @return {EventTimeline} the new timeline
+     * @returns the new timeline
      */
     public fork(direction: Direction): EventTimeline {
         const forkState = this.getState(direction);
@@ -207,7 +202,7 @@ export class EventTimeline {
 
     /**
      * Get the ID of the room for this timeline
-     * @return {string} room ID
+     * @returns room ID
      */
     public getRoomId(): string | null {
         return this.roomId;
@@ -215,7 +210,7 @@ export class EventTimeline {
 
     /**
      * Get the filter for this timeline's timelineSet (if any)
-     * @return {Filter} filter
+     * @returns filter
      */
     public getFilter(): Filter | undefined {
         return this.eventTimelineSet.getFilter();
@@ -223,7 +218,7 @@ export class EventTimeline {
 
     /**
      * Get the timelineSet for this timeline
-     * @return {EventTimelineSet} timelineSet
+     * @returns timelineSet
      */
     public getTimelineSet(): EventTimelineSet {
         return this.eventTimelineSet;
@@ -237,8 +232,6 @@ export class EventTimeline {
      * relative to the base index (although note that a given event's index may
      * well be less than the base index, thus giving that event a negative relative
      * index).
-     *
-     * @return {number}
      */
     public getBaseIndex(): number {
         return this.baseIndex;
@@ -247,7 +240,7 @@ export class EventTimeline {
     /**
      * Get the list of events in this context
      *
-     * @return {MatrixEvent[]} An array of MatrixEvents
+     * @returns An array of MatrixEvents
      */
     public getEvents(): MatrixEvent[] {
         return this.events;
@@ -256,11 +249,11 @@ export class EventTimeline {
     /**
      * Get the room state at the start/end of the timeline
      *
-     * @param {string} direction   EventTimeline.BACKWARDS to get the state at the
+     * @param direction -   EventTimeline.BACKWARDS to get the state at the
      *   start of the timeline; EventTimeline.FORWARDS to get the state at the end
      *   of the timeline.
      *
-     * @return {RoomState} state at the start/end of the timeline
+     * @returns state at the start/end of the timeline
      */
     public getState(direction: Direction): RoomState | undefined {
         if (direction == EventTimeline.BACKWARDS) {
@@ -275,11 +268,11 @@ export class EventTimeline {
     /**
      * Get a pagination token
      *
-     * @param {string} direction   EventTimeline.BACKWARDS to get the pagination
+     * @param direction -   EventTimeline.BACKWARDS to get the pagination
      *   token for going backwards in time; EventTimeline.FORWARDS to get the
      *   pagination token for going forwards in time.
      *
-     * @return {?string} pagination token
+     * @returns pagination token
      */
     public getPaginationToken(direction: Direction): string | null {
         if (this.roomId) {
@@ -294,9 +287,9 @@ export class EventTimeline {
     /**
      * Set a pagination token
      *
-     * @param {?string} token       pagination token
+     * @param token -       pagination token
      *
-     * @param {string} direction    EventTimeline.BACKWARDS to set the pagination
+     * @param direction -    EventTimeline.BACKWARDS to set the pagination
      *   token for going backwards in time; EventTimeline.FORWARDS to set the
      *   pagination token for going forwards in time.
      */
@@ -313,10 +306,10 @@ export class EventTimeline {
     /**
      * Get the next timeline in the series
      *
-     * @param {string} direction EventTimeline.BACKWARDS to get the previous
+     * @param direction - EventTimeline.BACKWARDS to get the previous
      *   timeline; EventTimeline.FORWARDS to get the next timeline.
      *
-     * @return {?EventTimeline} previous or following timeline, if they have been
+     * @returns previous or following timeline, if they have been
      * joined up.
      */
     public getNeighbouringTimeline(direction: Direction): EventTimeline | null {
@@ -332,12 +325,12 @@ export class EventTimeline {
     /**
      * Set the next timeline in the series
      *
-     * @param {EventTimeline} neighbour previous/following timeline
+     * @param neighbour - previous/following timeline
      *
-     * @param {string} direction EventTimeline.BACKWARDS to set the previous
+     * @param direction - EventTimeline.BACKWARDS to set the previous
      *   timeline; EventTimeline.FORWARDS to set the next timeline.
      *
-     * @throws {Error} if an attempt is made to set the neighbouring timeline when
+     * @throws Error if an attempt is made to set the neighbouring timeline when
      * it is already set.
      */
     public setNeighbouringTimeline(neighbour: EventTimeline, direction: Direction): void {
@@ -361,8 +354,8 @@ export class EventTimeline {
     /**
      * Add a new event to the timeline, and update the state
      *
-     * @param {MatrixEvent} event   new event
-     * @param {IAddEventOptions} options addEvent options
+     * @param event - new event
+     * @param options - addEvent options
      */
     public addEvent(
         event: MatrixEvent,
@@ -447,8 +440,8 @@ export class EventTimeline {
     /**
      * Remove an event from the timeline
      *
-     * @param {string} eventId  ID of event to be removed
-     * @return {?MatrixEvent} removed event, or null if not found
+     * @param eventId -  ID of event to be removed
+     * @returns removed event, or null if not found
      */
     public removeEvent(eventId: string): MatrixEvent | null {
         for (let i = this.events.length - 1; i >= 0; i--) {
@@ -467,7 +460,7 @@ export class EventTimeline {
     /**
      * Return a string to identify this timeline, for debugging
      *
-     * @return {string} name for this timeline
+     * @returns name for this timeline
      */
     public toString(): string {
         return this.name;
diff --git a/src/models/event.ts b/src/models/event.ts
index 2864aa6b520..2b082f9b6dc 100644
--- a/src/models/event.ts
+++ b/src/models/event.ts
@@ -17,7 +17,6 @@ limitations under the License.
 /**
  * This is an internal module. See {@link MatrixEvent} and {@link RoomEvent} for
  * the public classes.
- * @module models/event
  */
 
 import { ExtensibleEvent, ExtensibleEvents, Optional } from "matrix-events-sdk";
@@ -80,15 +79,15 @@ export interface IEvent {
     redacts?: string;
 
     /**
-     * @deprecated
+     * @deprecated in favour of `sender`
      */
     user_id?: string;
     /**
-     * @deprecated
+     * @deprecated in favour of `unsigned.prev_content`
      */
     prev_content?: IContent;
     /**
-     * @deprecated
+     * @deprecated in favour of `origin_server_ts`
      */
     age?: number;
 }
@@ -150,8 +149,11 @@ interface IKeyRequestRecipient {
 }
 
 export interface IDecryptOptions {
+    // Emits "event.decrypted" if set to true
     emit?: boolean;
+    // True if this is a retry (enables more logging)
     isRetry?: boolean;
+    // whether the message should be re-decrypted if it was previously successfully decrypted with an untrusted key
     forceRedecryptIfUntrusted?: boolean;
 }
 
@@ -192,6 +194,12 @@ export enum MatrixEventEvent {
 export type MatrixEventEmittedEvents = MatrixEventEvent | ThreadEvent.Update;
 
 export type MatrixEventHandlerMap = {
+    /**
+     * Fires when an event is decrypted
+     *
+     * @param event - The matrix event which has been decrypted
+     * @param err - The error that occurred during decryption, or `undefined` if no error occurred.
+     */
     [MatrixEventEvent.Decrypted]: (event: MatrixEvent, err?: Error) => void;
     [MatrixEventEvent.BeforeRedaction]: (event: MatrixEvent, redactionEvent: MatrixEvent) => void;
     [MatrixEventEvent.VisibilityChange]: (event: MatrixEvent, visible: boolean) => void;
@@ -271,12 +279,43 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      */
     public localTimestamp: number;
 
-    // XXX: these should be read-only
+    /**
+     * The room member who sent this event, or null e.g.
+     * this is a presence event. This is only guaranteed to be set for events that
+     * appear in a timeline, ie. do not guarantee that it will be set on state
+     * events.
+     * @privateRemarks
+     * Should be read-only
+     */
     public sender: RoomMember | null = null;
+    /**
+     * The room member who is the target of this event, e.g.
+     * the invitee, the person being banned, etc.
+     * @privateRemarks
+     * Should be read-only
+     */
     public target: RoomMember | null = null;
+    /**
+     * The sending status of the event.
+     * @privateRemarks
+     * Should be read-only
+     */
     public status: EventStatus | null = null;
+    /**
+     * most recent error associated with sending the event, if any
+     * @privateRemarks
+     * Should be read-only
+     */
     public error: MatrixError | null = null;
-    public forwardLooking = true; // only state events may be backwards looking
+    /**
+     * True if this event is 'forward looking', meaning
+     * that getDirectionalContent() will return event.content and not event.prev_content.
+     * Only state events may be backwards looking
+     * Default: true. <strong>This property is experimental and may change.</strong>
+     * @privateRemarks
+     * Should be read-only
+     */
+    public forwardLooking = true;
 
     /* If the event is a `m.key.verification.request` (or to_device `m.key.verification.start`) event,
      * `Crypto` will set this the `VerificationRequest` for the event
@@ -288,26 +327,11 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Construct a Matrix Event object
-     * @constructor
-     *
-     * @param {Object} event The raw event to be wrapped in this DAO
      *
-     * @prop {Object} event The raw (possibly encrypted) event. <b>Do not access
+     * @param event - The raw (possibly encrypted) event. <b>Do not access
      * this property</b> directly unless you absolutely have to. Prefer the getter
      * methods defined on this class. Using the getter methods shields your app
      * from changes to event JSON between Matrix versions.
-     *
-     * @prop {RoomMember} sender The room member who sent this event, or null e.g.
-     * this is a presence event. This is only guaranteed to be set for events that
-     * appear in a timeline, ie. do not guarantee that it will be set on state
-     * events.
-     * @prop {RoomMember} target The room member who is the target of this event, e.g.
-     * the invitee, the person being banned, etc.
-     * @prop {EventStatus} status The sending status of the event.
-     * @prop {Error} error most recent error associated with sending the event, if any
-     * @prop {boolean} forwardLooking True if this event is 'forward looking', meaning
-     * that getDirectionalContent() will return event.content and not event.prev_content.
-     * Default: true. <strong>This property is experimental and may change.</strong>
      */
     public constructor(public event: Partial<IEvent> = {}) {
         super();
@@ -360,7 +384,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Gets the event as though it would appear unencrypted. If the event is already not
      * encrypted, it is simply returned as-is.
-     * @returns {IEvent} The event in wire format.
+     * @returns The event in wire format.
      */
     public getEffectiveEvent(): IEvent {
         const content = Object.assign({}, this.getContent()); // clone for mutation
@@ -389,7 +413,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Get the event_id for this event.
-     * @return {string} The event ID, e.g. <code>$143350589368169JsLZx:localhost
+     * @returns The event ID, e.g. <code>$143350589368169JsLZx:localhost
      * </code>
      */
     public getId(): string | undefined {
@@ -398,7 +422,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Get the user_id for this event.
-     * @return {string} The user ID, e.g. <code>@alice:matrix.org</code>
+     * @returns The user ID, e.g. `@alice:matrix.org`
      */
     public getSender(): string | undefined {
         return this.event.sender || this.event.user_id; // v2 / v1
@@ -407,7 +431,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Get the (decrypted, if necessary) type of event.
      *
-     * @return {string} The event type, e.g. <code>m.room.message</code>
+     * @returns The event type, e.g. `m.room.message`
      */
     public getType(): EventType | string {
         if (this.clearEvent) {
@@ -420,16 +444,16 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Get the (possibly encrypted) type of the event that will be sent to the
      * homeserver.
      *
-     * @return {string} The event type.
+     * @returns The event type.
      */
     public getWireType(): EventType | string {
         return this.event.type!;
     }
 
     /**
-     * Get the room_id for this event. This will return <code>undefined</code>
-     * for <code>m.presence</code> events.
-     * @return {string?} The room ID, e.g. <code>!cURbafjkfsMDVwdRDQ:matrix.org
+     * Get the room_id for this event. This will return `undefined`
+     * for `m.presence` events.
+     * @returns The room ID, e.g. <code>!cURbafjkfsMDVwdRDQ:matrix.org
      * </code>
      */
     public getRoomId(): string | undefined {
@@ -438,7 +462,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Get the timestamp of this event.
-     * @return {Number} The event timestamp, e.g. <code>1433502692297</code>
+     * @returns The event timestamp, e.g. `1433502692297`
      */
     public getTs(): number {
         return this.event.origin_server_ts!;
@@ -446,7 +470,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Get the timestamp of this event, as a Date object.
-     * @return {Date} The event date, e.g. <code>new Date(1433502692297)</code>
+     * @returns The event date, e.g. `new Date(1433502692297)`
      */
     public getDate(): Date | null {
         return this.event.origin_server_ts ? new Date(this.event.origin_server_ts) : null;
@@ -457,7 +481,11 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * This is intended for logging, to help trace errors. Example output:
      *
-     * id=$HjnOHV646n0SjLDAqFrgIjim7RCpB7cdMXFrekWYAn type=m.room.encrypted sender=@user:example.com room=!room:example.com ts=2022-10-25T17:30:28.404Z
+     * @example
+     * ```
+     * id=$HjnOHV646n0SjLDAqFrgIjim7RCpB7cdMXFrekWYAn type=m.room.encrypted
+     * sender=@user:example.com room=!room:example.com ts=2022-10-25T17:30:28.404Z
+     * ```
      */
     public getDetails(): string {
         let details = `id=${this.getId()} type=${this.getWireType()} sender=${this.getSender()}`;
@@ -476,7 +504,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Get the (decrypted, if necessary) event content JSON, even if the event
      * was replaced by another event.
      *
-     * @return {Object} The event content JSON, or an empty object.
+     * @returns The event content JSON, or an empty object.
      */
     public getOriginalContent<T = IContent>(): T {
         if (this._localRedactionEvent) {
@@ -493,7 +521,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * or the content from the replacing event, if any.
      * See `makeReplaced`.
      *
-     * @return {Object} The event content JSON, or an empty object.
+     * @returns The event content JSON, or an empty object.
      */
     public getContent<T extends IContent = IContent>(): T {
         if (this._localRedactionEvent) {
@@ -509,7 +537,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Get the (possibly encrypted) event content JSON that will be sent to the
      * homeserver.
      *
-     * @return {Object} The event content JSON, or an empty object.
+     * @returns The event content JSON, or an empty object.
      */
     public getWireContent(): IContent {
         return this.event.content || {};
@@ -560,7 +588,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Get the previous event content JSON. This will only return something for
      * state events which exist in the timeline.
-     * @return {Object} The previous event content JSON, or an empty object.
+     * @returns The previous event content JSON, or an empty object.
      */
     public getPrevContent(): IContent {
         // v2 then v1 then default
@@ -573,7 +601,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * In practice, this means we get the chronologically earlier content value
      * for this event (this method should surely be called getEarlierContent)
      * <strong>This method is experimental and may change.</strong>
-     * @return {Object} event.content if this event is forward-looking, else
+     * @returns event.content if this event is forward-looking, else
      * event.prev_content.
      */
     public getDirectionalContent(): IContent {
@@ -585,7 +613,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * event arrived at the device, and not the age of the event when this
      * function was called.
      * Can only be returned once the server has echo'ed back
-     * @return {Number|undefined} The age of this event in milliseconds.
+     * @returns The age of this event in milliseconds.
      */
     public getAge(): number | undefined {
         return this.getUnsigned().age || this.event.age; // v2 / v1
@@ -595,7 +623,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Get the age of the event when this function was called.
      * This is the 'age' field adjusted according to how long this client has
      * had the event.
-     * @return {Number} The age of this event in milliseconds.
+     * @returns The age of this event in milliseconds.
      */
     public getLocalAge(): number {
         return Date.now() - this.localTimestamp;
@@ -604,7 +632,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Get the event state_key if it has one. This will return <code>undefined
      * </code> for message events.
-     * @return {string} The event's <code>state_key</code>.
+     * @returns The event's `state_key`.
      */
     public getStateKey(): string | undefined {
         return this.event.state_key;
@@ -612,7 +640,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Check if this event is a state event.
-     * @return {boolean} True if this is a state event.
+     * @returns True if this is a state event.
      */
     public isState(): boolean {
         return this.event.state_key !== undefined;
@@ -624,18 +652,18 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * @internal
      *
-     * @param {string} cryptoType type of the encrypted event - typically
+     * @param cryptoType - type of the encrypted event - typically
      * <tt>"m.room.encrypted"</tt>
      *
-     * @param {object} cryptoContent raw 'content' for the encrypted event.
+     * @param cryptoContent - raw 'content' for the encrypted event.
      *
-     * @param {string} senderCurve25519Key curve25519 key to record for the
+     * @param senderCurve25519Key - curve25519 key to record for the
      *   sender of this event.
-     *   See {@link module:models/event.MatrixEvent#getSenderKey}.
+     *   See {@link MatrixEvent#getSenderKey}.
      *
-     * @param {string} claimedEd25519Key claimed ed25519 key to record for the
+     * @param claimedEd25519Key - claimed ed25519 key to record for the
      *   sender if this event.
-     *   See {@link module:models/event.MatrixEvent#getClaimedEd25519Key}
+     *   See {@link MatrixEvent#getClaimedEd25519Key}
      */
     public makeEncrypted(
         cryptoType: string,
@@ -657,7 +685,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Check if this event is currently being decrypted.
      *
-     * @return {boolean} True if this event is currently being decrypted, else false.
+     * @returns True if this event is currently being decrypted, else false.
      */
     public isBeingDecrypted(): boolean {
         return this.decryptionPromise != null;
@@ -672,7 +700,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * (This implies that we might retry decryption at some point in the future)
      *
-     * @return {boolean} True if this event is an encrypted event which we
+     * @returns True if this event is an encrypted event which we
      *     couldn't decrypt.
      */
     public isDecryptionFailure(): boolean {
@@ -695,14 +723,9 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * @internal
      *
-     * @param {module:crypto} crypto crypto module
-     * @param {object} options
-     * @param {boolean} options.isRetry True if this is a retry (enables more logging)
-     * @param {boolean} options.emit Emits "event.decrypted" if set to true
-     * @param {boolean} options.forceRedecryptIfUntrusted whether the message should be
-     *     re-decrypted if it was previously successfully decrypted with an untrusted key
+     * @param crypto - crypto module
      *
-     * @returns {Promise} promise which resolves (to undefined) when the decryption
+     * @returns promise which resolves (to undefined) when the decryption
      * attempt is completed.
      */
     public async attemptDecryption(crypto: Crypto, options: IDecryptOptions = {}): Promise<void> {
@@ -741,10 +764,10 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Cancel any room key request for this event and resend another.
      *
-     * @param {module:crypto} crypto crypto module
-     * @param {string} userId the user who received this event
+     * @param crypto - crypto module
+     * @param userId - the user who received this event
      *
-     * @returns {Promise} a promise that resolves when the request is queued
+     * @returns a promise that resolves when the request is queued
      */
     public cancelAndResendKeyRequest(crypto: Crypto, userId: string): Promise<void> {
         const wireContent = this.getWireContent();
@@ -759,9 +782,9 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Calculate the recipients for keyshare requests.
      *
-     * @param {string} userId the user who received this event.
+     * @param userId - the user who received this event.
      *
-     * @returns {Array} array of recipients
+     * @returns array of recipients
      */
     public getKeyRequestRecipients(userId: string): IKeyRequestRecipient[] {
         // send the request to all of our own devices, and the
@@ -903,10 +926,10 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * @internal
      *
-     * @fires module:models/event.MatrixEvent#"Event.decrypted"
+     * @param decryptionResult - the decryption result, including the plaintext and some key info
      *
-     * @param {module:crypto~EventDecryptionResult} decryptionResult
-     *     the decryption result, including the plaintext and some key info
+     * @remarks
+     * Fires {@link MatrixEventEvent.Decrypted}
      */
     private setClearData(decryptionResult: IEventDecryptionResult): void {
         this.clearEvent = decryptionResult.clearEvent;
@@ -922,7 +945,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Gets the cleartext content for this event. If the event is not encrypted,
      * or encryption has not been completed, this will return null.
      *
-     * @returns {Object} The cleartext (decrypted) content for the event
+     * @returns The cleartext (decrypted) content for the event
      */
     public getClearContent(): IContent | null {
         return this.clearEvent ? this.clearEvent.content : null;
@@ -930,7 +953,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Check if the event is encrypted.
-     * @return {boolean} True if this event is encrypted.
+     * @returns True if this event is encrypted.
      */
     public isEncrypted(): boolean {
         return !this.isState() && this.event.type === EventType.RoomMessageEncrypted;
@@ -946,8 +969,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * For a megolm-encrypted event, it is inferred from the Olm message which
      * established the megolm session
-     *
-     * @return {string}
      */
     public getSenderKey(): string | null {
         return this.senderCurve25519Key;
@@ -957,8 +978,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * The additional keys the sender of this encrypted event claims to possess.
      *
      * Just a wrapper for #getClaimedEd25519Key (q.v.)
-     *
-     * @return {Object<string, string>}
      */
     public getKeysClaimed(): Partial<Record<"ed25519", string>> {
         if (!this.claimedEd25519Key) return {};
@@ -982,8 +1001,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * In general, applications should not use this method directly, but should
      * instead use MatrixClient.getEventSenderDeviceInfo.
-     *
-     * @return {string}
      */
     public getClaimedEd25519Key(): string | null {
         return this.claimedEd25519Key;
@@ -1001,7 +1018,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * If the device that sent us the key (A) got it from another device which
      * it wasn't prepared to vouch for (B), the result will be [A, B]. And so on.
      *
-     * @return {string[]} base64-encoded curve25519 keys, from oldest to newest.
+     * @returns base64-encoded curve25519 keys, from oldest to newest.
      */
     public getForwardingCurve25519KeyChain(): string[] {
         return this.forwardingCurve25519KeyChain;
@@ -1010,8 +1027,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Whether the decryption key was obtained from an untrusted source. If so,
      * we cannot verify the authenticity of the message.
-     *
-     * @return {boolean}
      */
     public isKeySourceUntrusted(): boolean | undefined {
         return !!this.untrusted;
@@ -1047,13 +1062,15 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Change the visibility of an event, as per https://github.com/matrix-org/matrix-doc/pull/3531 .
      *
-     * @fires module:models/event.MatrixEvent#"Event.visibilityChange" if `visibilityEvent`
+     * @param visibilityChange - event holding a hide/unhide payload, or nothing
+     *   if the event is being reset to its original visibility (presumably
+     *   by a visibility event being redacted).
+     *
+     * @remarks
+     * Fires {@link MatrixEventEvent.VisibilityChange} if `visibilityEvent`
      *   caused a change in the actual visibility of this event, either by making it
      *   visible (if it was hidden), by making it hidden (if it was visible) or by
      *   changing the reason (if it was hidden).
-     * @param visibilityChange event holding a hide/unhide payload, or nothing
-     *   if the event is being reset to its original visibility (presumably
-     *   by a visibility event being redacted).
      */
     public applyVisibilityEvent(visibilityChange?: IVisibilityChange): void {
         const visible = visibilityChange?.visible ?? true;
@@ -1093,8 +1110,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Update the content of an event in the same way it would be by the server
      * if it were redacted before it was sent to us
      *
-     * @param {module:models/event.MatrixEvent} redactionEvent
-     *     event causing the redaction
+     * @param redactionEvent - event causing the redaction
      */
     public makeRedacted(redactionEvent: MatrixEvent): void {
         // quick sanity-check
@@ -1145,7 +1161,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Check if this event has been redacted
      *
-     * @return {boolean} True if this event has been redacted
+     * @returns True if this event has been redacted
      */
     public isRedacted(): boolean {
         return Boolean(this.getUnsigned().redacted_because);
@@ -1154,7 +1170,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Check if this event is a redaction of another event
      *
-     * @return {boolean} True if this event is a redaction
+     * @returns True if this event is a redaction
      */
     public isRedaction(): boolean {
         return this.getType() === EventType.RoomRedaction;
@@ -1201,7 +1217,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Check if this event alters the visibility of another event,
      * as per https://github.com/matrix-org/matrix-doc/pull/3531.
      *
-     * @returns {boolean} True if this event alters the visibility
+     * @returns True if this event alters the visibility
      * of another event.
      */
     public isVisibilityEvent(): boolean {
@@ -1212,7 +1228,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Get the (decrypted, if necessary) redaction event JSON
      * if event was redacted
      *
-     * @returns {object} The redaction event JSON, or an empty object
+     * @returns The redaction event JSON, or an empty object
      */
     public getRedactionEvent(): IEvent | {} | null {
         if (!this.isRedacted()) return null;
@@ -1229,7 +1245,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Get the push actions, if known, for this event
      *
-     * @return {?Object} push actions
+     * @returns push actions
      */
     public getPushActions(): IActionsObject | null {
         return this.pushActions;
@@ -1238,7 +1254,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Set the push actions for this event.
      *
-     * @param {Object} pushActions push actions
+     * @param pushActions - push actions
      */
     public setPushActions(pushActions: IActionsObject | null): void {
         this.pushActions = pushActions;
@@ -1246,7 +1262,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Replace the `event` property and recalculate any properties based on it.
-     * @param {Object} event the object to assign to the `event` property
+     * @param event - the object to assign to the `event` property
      */
     public handleRemoteEcho(event: object): void {
         const oldUnsigned = this.getUnsigned();
@@ -1276,8 +1292,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Whether the event is in any phase of sending, send failure, waiting for
      * remote echo, etc.
-     *
-     * @return {boolean}
      */
     public isSending(): boolean {
         return !!this.status;
@@ -1286,7 +1300,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Update the event's sending status and emit an event as well.
      *
-     * @param {String} status The new status
+     * @param status - The new status
      */
     public setStatus(status: EventStatus | null): void {
         this.status = status;
@@ -1302,9 +1316,8 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Get whether the event is a relation event, and of a given type if
      * `relType` is passed in. State events cannot be relation events
      *
-     * @param {string?} relType if given, checks that the relation is of the
+     * @param relType - if given, checks that the relation is of the
      * given type
-     * @return {boolean}
      */
     public isRelation(relType?: string): boolean {
         // Relation info is lifted out of the encrypted content when sent to
@@ -1319,8 +1332,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Get relation info for the event, if any.
-     *
-     * @return {Object}
      */
     public getRelation(): IEventRelation | null {
         if (!this.isRelation()) {
@@ -1332,9 +1343,10 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Set an event that replaces the content of this event, through an m.replace relation.
      *
-     * @fires module:models/event.MatrixEvent#"Event.replaced"
+     * @param newEvent - the event with the replacing content, if any.
      *
-     * @param {MatrixEvent?} newEvent the event with the replacing content, if any.
+     * @remarks
+     * Fires {@link MatrixEventEvent.Replaced}
      */
     public makeReplaced(newEvent?: MatrixEvent): void {
         // don't allow redacted events to be replaced.
@@ -1359,8 +1371,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Returns the status of any associated edit or redaction
      * (not for reactions/annotations as their local echo doesn't affect the original event),
      * or else the status of the event.
-     *
-     * @return {EventStatus}
      */
     public getAssociatedStatus(): EventStatus | null {
         if (this._replacingEvent) {
@@ -1377,8 +1387,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Returns the event ID of the event replacing the content of this event, if any.
-     *
-     * @return {string?}
      */
     public replacingEventId(): string | undefined {
         const replaceRelation = this.getServerAggregatedRelation<IAggregatedRelation>(RelationType.Replace);
@@ -1393,8 +1401,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Returns the event replacing the content of this event, if any.
      * Replacements are aggregated on the server, so this would only
      * return an event in case it came down the sync, or for local echo of edits.
-     *
-     * @return {MatrixEvent?}
      */
     public replacingEvent(): MatrixEvent | null {
         return this._replacingEvent;
@@ -1402,8 +1408,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Returns the origin_server_ts of the event replacing the content of this event, if any.
-     *
-     * @return {Date?}
      */
     public replacingEventDate(): Date | undefined {
         const replaceRelation = this.getServerAggregatedRelation<IAggregatedRelation>(RelationType.Replace);
@@ -1419,7 +1423,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Returns the event that wants to redact this event, but hasn't been sent yet.
-     * @return {MatrixEvent} the event
+     * @returns the event
      */
     public localRedactionEvent(): MatrixEvent | null {
         return this._localRedactionEvent;
@@ -1427,8 +1431,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * For relations and redactions, returns the event_id this event is referring to.
-     *
-     * @return {string?}
      */
     public getAssociatedId(): string | undefined {
         const relation = this.getRelation();
@@ -1443,8 +1445,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Checks if this event is associated with another event. See `getAssociatedId`.
-     *
-     * @return {boolean}
      * @deprecated use hasAssociation instead.
      */
     public hasAssocation(): boolean {
@@ -1453,8 +1453,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
 
     /**
      * Checks if this event is associated with another event. See `getAssociatedId`.
-     *
-     * @return {boolean}
      */
     public hasAssociation(): boolean {
         return !!this.getAssociatedId();
@@ -1466,7 +1464,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Used to replace a local id with remote one before sending
      * an event with a related id.
      *
-     * @param {string} eventId the new event id
+     * @param eventId - the new event id
      */
     public updateAssociatedId(eventId: string): void {
         const relation = this.getRelation();
@@ -1481,7 +1479,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Flags an event as cancelled due to future conditions. For example, a verification
      * request event in the same sync transaction may be flagged as cancelled to warn
      * listeners that a cancellation event is coming down the same pipe shortly.
-     * @param {boolean} cancelled Whether the event is to be cancelled or not.
+     * @param cancelled - Whether the event is to be cancelled or not.
      */
     public flagCancelled(cancelled = true): void {
         this._isCancelled = cancelled;
@@ -1490,7 +1488,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     /**
      * Gets whether or not the event is flagged as cancelled. See flagCancelled() for
      * more information.
-     * @returns {boolean} True if the event is cancelled, false otherwise.
+     * @returns True if the event is cancelled, false otherwise.
      */
     public isCancelled(): boolean {
         return this._isCancelled;
@@ -1508,7 +1506,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      *
      * This is meant to be used to snapshot the event details themselves, not the
      * features (such as sender) surrounding the event.
-     * @returns {MatrixEvent} A snapshot of this event.
+     * @returns A snapshot of this event.
      */
     public toSnapshot(): MatrixEvent {
         const ev = new MatrixEvent(JSON.parse(JSON.stringify(this.event)));
@@ -1525,8 +1523,8 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * Determines if this event is equivalent to the given event. This only checks
      * the event object itself, not the other properties of the event. Intended for
      * use with toSnapshot() to identify events changing.
-     * @param {MatrixEvent} otherEvent The other event to check against.
-     * @returns {boolean} True if the events are the same, false otherwise.
+     * @param otherEvent - The other event to check against.
+     * @returns True if the events are the same, false otherwise.
      */
     public isEquivalentTo(otherEvent: MatrixEvent): boolean {
         if (!otherEvent) return false;
@@ -1546,8 +1544,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * This is named `toJSON` for use with `JSON.stringify` which checks objects
      * for functions named `toJSON` and will call them to customise the output
      * if they are defined.
-     *
-     * @return {Object}
      */
     public toJSON(): object {
         const event = this.getEffectiveEvent();
@@ -1625,15 +1621,3 @@ const REDACT_KEEP_CONTENT_MAP: Record<string, Record<string, 1>> = {
         'users': 1, 'users_default': 1,
     },
 } as const;
-
-/**
- * Fires when an event is decrypted
- *
- * @event module:models/event.MatrixEvent#"Event.decrypted"
- *
- * @param {module:models/event.MatrixEvent} event
- *    The matrix event which has been decrypted
- * @param {module:crypto/algorithms/base.DecryptionError?} err
- *    The error that occurred during decryption, or `undefined` if no
- *    error occurred.
- */
diff --git a/src/models/invites-ignorer.ts b/src/models/invites-ignorer.ts
index 907d1ca176c..c17d22f9f9e 100644
--- a/src/models/invites-ignorer.ts
+++ b/src/models/invites-ignorer.ts
@@ -81,10 +81,10 @@ export class IgnoredInvites {
     /**
      * Add a new rule.
      *
-     * @param scope The scope for this rule.
-     * @param entity The entity covered by this rule. Globs are supported.
-     * @param reason A human-readable reason for introducing this new rule.
-     * @return The event id for the new rule.
+     * @param scope - The scope for this rule.
+     * @param entity - The entity covered by this rule. Globs are supported.
+     * @param reason - A human-readable reason for introducing this new rule.
+     * @returns The event id for the new rule.
      */
     public async addRule(scope: PolicyScope, entity: string, reason: string): Promise<string> {
         const target = await this.getOrCreateTargetRoom();
@@ -107,9 +107,9 @@ export class IgnoredInvites {
      * Add a new room to the list of sources. If the user isn't a member of the
      * room, attempt to join it.
      *
-     * @param roomId A valid room id. If this room is already in the list
+     * @param roomId - A valid room id. If this room is already in the list
      * of sources, it will not be duplicated.
-     * @return `true` if the source was added, `false` if it was already present.
+     * @returns `true` if the source was added, `false` if it was already present.
      * @throws If `roomId` isn't the id of a room that the current user is already
      * member of or can join.
      *
@@ -142,8 +142,8 @@ export class IgnoredInvites {
     /**
      * Find out whether an invite should be ignored.
      *
-     * @param sender The user id for the user who issued the invite.
-     * @param roomId The room to which the user is invited.
+     * @param sender - The user id for the user who issued the invite.
+     * @param roomId - The room to which the user is invited.
      * @returns A rule matching the entity, if any was found, `null` otherwise.
      */
     public async getRuleForInvite({ sender, roomId }: {
diff --git a/src/models/read-receipt.ts b/src/models/read-receipt.ts
index 391cd98117e..afea2ebdf99 100644
--- a/src/models/read-receipt.ts
+++ b/src/models/read-receipt.ts
@@ -63,9 +63,9 @@ export abstract class ReadReceipt<
 
     /**
      * Gets the latest receipt for a given user in the room
-     * @param userId The id of the user for which we want the receipt
-     * @param ignoreSynthesized Whether to ignore synthesized receipts or not
-     * @param receiptType Optional. The type of the receipt we want to get
+     * @param userId - The id of the user for which we want the receipt
+     * @param ignoreSynthesized - Whether to ignore synthesized receipts or not
+     * @param receiptType - Optional. The type of the receipt we want to get
      * @returns the latest receipts of the chosen type for the chosen user
      */
     public getReadReceiptForUserId(
@@ -82,11 +82,11 @@ export abstract class ReadReceipt<
     /**
      * Get the ID of the event that a given user has read up to, or null if we
      * have received no read receipts from them.
-     * @param {String} userId The user ID to get read receipt event ID for
-     * @param {Boolean} ignoreSynthesized If true, return only receipts that have been
+     * @param userId - The user ID to get read receipt event ID for
+     * @param ignoreSynthesized - If true, return only receipts that have been
      *                                    sent by the server, not implicit ones generated
      *                                    by the JS SDK.
-     * @return {String} ID of the latest event that the given user has read, or null.
+     * @returns ID of the latest event that the given user has read, or null.
      */
     public getEventReadUpTo(userId: string, ignoreSynthesized = false): string | null {
         // XXX: This is very very ugly and I hope I won't have to ever add a new
@@ -212,8 +212,8 @@ export abstract class ReadReceipt<
 
     /**
      * Get a list of receipts for the given event.
-     * @param {MatrixEvent} event the event to get receipts for
-     * @return {Object[]} A list of receipts with a userId, type and data keys or
+     * @param event - the event to get receipts for
+     * @returns A list of receipts with a userId, type and data keys or
      * an empty list.
      */
     public getReceiptsForEvent(event: MatrixEvent): CachedReceipt[] {
@@ -225,9 +225,9 @@ export abstract class ReadReceipt<
     /**
      * Add a temporary local-echo receipt to the room to reflect in the
      * client the fact that we've sent one.
-     * @param {string} userId The user ID if the receipt sender
-     * @param {MatrixEvent} e The event that is to be acknowledged
-     * @param {ReceiptType} receiptType The type of receipt
+     * @param userId - The user ID if the receipt sender
+     * @param e - The event that is to be acknowledged
+     * @param receiptType - The type of receipt
      */
     public addLocalEchoReceipt(userId: string, e: MatrixEvent, receiptType: ReceiptType): void {
         this.addReceipt(synthesizeReceipt(userId, e, receiptType), true);
@@ -235,8 +235,8 @@ export abstract class ReadReceipt<
 
     /**
      * Get a list of user IDs who have <b>read up to</b> the given event.
-     * @param {MatrixEvent} event the event to get read receipts for.
-     * @return {String[]} A list of user IDs.
+     * @param event - the event to get read receipts for.
+     * @returns A list of user IDs.
      */
     public getUsersReadUpTo(event: MatrixEvent): string[] {
         return this.getReceiptsForEvent(event).filter(function(receipt) {
@@ -250,9 +250,9 @@ export abstract class ReadReceipt<
      * Determines if the given user has read a particular event ID with the known
      * history of the room. This is not a definitive check as it relies only on
      * what is available to the room at the time of execution.
-     * @param {String} userId The user ID to check the read state of.
-     * @param {String} eventId The event ID to check if the user read.
-     * @returns {Boolean} True if the user has read the event, false otherwise.
+     * @param userId - The user ID to check the read state of.
+     * @param eventId - The event ID to check if the user read.
+     * @returns True if the user has read the event, false otherwise.
      */
     public hasUserReadEvent(userId: string, eventId: string): boolean {
         const readUpToId = this.getEventReadUpTo(userId, false);
diff --git a/src/models/relations-container.ts b/src/models/relations-container.ts
index 55e098a3f6d..397e9c52b66 100644
--- a/src/models/relations-container.ts
+++ b/src/models/relations-container.ts
@@ -32,17 +32,14 @@ export class RelationsContainer {
     /**
      * Get a collection of child events to a given event in this timeline set.
      *
-     * @param {String} eventId
-     * The ID of the event that you'd like to access child events for.
+     * @param eventId - The ID of the event that you'd like to access child events for.
      * For example, with annotations, this would be the ID of the event being annotated.
-     * @param {String} relationType
-     * The type of relationship involved, such as "m.annotation", "m.reference", "m.replace", etc.
-     * @param {String} eventType
-     * The relation event's type, such as "m.reaction", etc.
-     * @throws If <code>eventId</code>, <code>relationType</code> or <code>eventType</code>
+     * @param relationType - The type of relationship involved, such as "m.annotation", "m.reference", "m.replace", etc.
+     * @param eventType - The relation event's type, such as "m.reaction", etc.
+     * @throws If `eventId</code>, <code>relationType</code> or <code>eventType`
      * are not valid.
      *
-     * @returns {?Relations}
+     * @returns
      * A container for relation events or undefined if there are no relation events for
      * the relationType.
      */
@@ -71,7 +68,7 @@ export class RelationsContainer {
      * Child events can point to other child events as their parent, so this method may be
      * called for events which are also logically child events.
      *
-     * @param {MatrixEvent} event The event to check as relation target.
+     * @param event - The event to check as relation target.
      */
     public aggregateParentEvent(event: MatrixEvent): void {
         const relationsForEvent = this.relations.get(event.getId()!);
@@ -87,8 +84,8 @@ export class RelationsContainer {
     /**
      * Add relation events to the relevant relation collection.
      *
-     * @param {MatrixEvent} event The new child event to be aggregated.
-     * @param {EventTimelineSet} timelineSet The event timeline set within which to search for the related event if any.
+     * @param event - The new child event to be aggregated.
+     * @param timelineSet - The event timeline set within which to search for the related event if any.
      */
     public aggregateChildEvent(event: MatrixEvent, timelineSet?: EventTimelineSet): void {
         if (event.isRedacted() || event.status === EventStatus.CANCELLED) {
diff --git a/src/models/relations.ts b/src/models/relations.ts
index 00fb7f6e979..1a984985749 100644
--- a/src/models/relations.ts
+++ b/src/models/relations.ts
@@ -52,13 +52,9 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
     private readonly client: MatrixClient;
 
     /**
-     * @param {RelationType} relationType
-     * The type of relation involved, such as "m.annotation", "m.reference",
-     * "m.replace", etc.
-     * @param {String} eventType
-     * The relation event's type, such as "m.reaction", etc.
-     * @param {MatrixClient|Room} client
-     * The client which created this instance. For backwards compatibility also accepts a Room.
+     * @param relationType - The type of relation involved, such as "m.annotation", "m.reference", "m.replace", etc.
+     * @param eventType - The relation event's type, such as "m.reaction", etc.
+     * @param client - The client which created this instance. For backwards compatibility also accepts a Room.
      */
     public constructor(
         public readonly relationType: RelationType | string,
@@ -72,8 +68,7 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
     /**
      * Add relation events to this collection.
      *
-     * @param {MatrixEvent} event
-     * The new relation event to be added.
+     * @param event - The new relation event to be added.
      */
     public async addEvent(event: MatrixEvent): Promise<void> {
         if (this.relationEventIds.has(event.getId()!)) {
@@ -120,8 +115,7 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
     /**
      * Remove relation event from this collection.
      *
-     * @param {MatrixEvent} event
-     * The relation event to remove.
+     * @param event - The relation event to remove.
      */
     private async removeEvent(event: MatrixEvent): Promise<void> {
         if (!this.relations.has(event)) {
@@ -157,8 +151,8 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
     /**
      * Listens for event status changes to remove cancelled events.
      *
-     * @param {MatrixEvent} event The event whose status has changed
-     * @param {EventStatus} status The new status
+     * @param event - The event whose status has changed
+     * @param status - The new status
      */
     private onEventStatus = (event: MatrixEvent, status: EventStatus | null): void => {
         if (!event.isSending()) {
@@ -181,7 +175,6 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
      * won't match timeline order in the case of scrollback.
      * TODO: Tweak `addEvent` to insert correctly for scrollback.
      *
-     * @return {Array}
      * Relation events in insertion order.
      */
     public getRelations(): MatrixEvent[] {
@@ -246,8 +239,7 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
      *   - after the server accepted the redaction and remote echoed back to us
      *   - before the original event has been marked redacted in the client
      *
-     * @param {MatrixEvent} redactedEvent
-     * The original relation event that is about to be redacted.
+     * @param redactedEvent - The original relation event that is about to be redacted.
      */
     private onBeforeRedaction = async (redactedEvent: MatrixEvent): Promise<void> => {
         if (!this.relations.has(redactedEvent)) {
@@ -275,7 +267,6 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
      *
      * This is currently only supported for the annotation relation type.
      *
-     * @return {Array}
      * An array of [key, events] pairs sorted by descending event count.
      * The events are stored in a Set (which preserves insertion order).
      */
@@ -293,7 +284,6 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
      *
      * This is currently only supported for the annotation relation type.
      *
-     * @return {Object}
      * An object with each relation sender as a key and the matching Set of
      * events for that sender as a value.
      */
@@ -311,8 +301,6 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
      *
      * This is currently only supported for the m.replace relation type,
      * once the target event is known, see `addEvent`.
-     *
-     * @return {MatrixEvent?}
      */
     public async getLastReplacement(): Promise<MatrixEvent | null> {
         if (this.relationType !== RelationType.Replace) {
@@ -354,7 +342,7 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
     }
 
     /*
-     * @param {MatrixEvent} targetEvent the event the relations are related to.
+     * @param targetEvent - the event the relations are related to.
      */
     public async setTargetEvent(event: MatrixEvent): Promise<void> {
         if (this.targetEvent) {
diff --git a/src/models/room-member.ts b/src/models/room-member.ts
index 28023f79152..21f8f5f650e 100644
--- a/src/models/room-member.ts
+++ b/src/models/room-member.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/room-member
- */
-
 import { getHttpUriForMxc } from "../content-repo";
 import * as utils from "../utils";
 import { User } from "./user";
@@ -35,9 +31,56 @@ export enum RoomMemberEvent {
 }
 
 export type RoomMemberEventHandlerMap = {
+    /**
+     * Fires whenever any room member's membership state changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param member - The member whose RoomMember.membership changed.
+     * @param oldMembership - The previous membership state. Null if it's a new member.
+     * @example
+     * ```
+     * matrixClient.on("RoomMember.membership", function(event, member, oldMembership){
+     *   var newState = member.membership;
+     * });
+     * ```
+     */
     [RoomMemberEvent.Membership]: (event: MatrixEvent, member: RoomMember, oldMembership?: string) => void;
+    /**
+     * Fires whenever any room member's name changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param member - The member whose RoomMember.name changed.
+     * @param oldName - The previous name. Null if the member didn't have a name previously.
+     * @example
+     * ```
+     * matrixClient.on("RoomMember.name", function(event, member){
+     *   var newName = member.name;
+     * });
+     * ```
+     */
     [RoomMemberEvent.Name]: (event: MatrixEvent, member: RoomMember, oldName: string | null) => void;
+    /**
+     * Fires whenever any room member's power level changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param member - The member whose RoomMember.powerLevel changed.
+     * @example
+     * ```
+     * matrixClient.on("RoomMember.powerLevel", function(event, member){
+     *   var newPowerLevel = member.powerLevel;
+     *   var newNormPowerLevel = member.powerLevelNorm;
+     * });
+     * ```
+     */
     [RoomMemberEvent.PowerLevel]: (event: MatrixEvent, member: RoomMember) => void;
+    /**
+     * Fires whenever any room member's typing state changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param member - The member whose RoomMember.typing changed.
+     * @example
+     * ```
+     * matrixClient.on("RoomMember.typing", function(event, member){
+     *   var isTyping = member.typing;
+     * });
+     * ```
+     */
     [RoomMemberEvent.Typing]: (event: MatrixEvent, member: RoomMember) => void;
 };
 
@@ -47,41 +90,55 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
     public requestedProfileInfo = false; // used by sync.ts
 
     // XXX these should be read-only
+    /**
+     * True if the room member is currently typing.
+     */
     public typing = false;
+    /**
+     * The human-readable name for this room member. This will be
+     * disambiguated with a suffix of " (\@user_id:matrix.org)" if another member shares the
+     * same displayname.
+     */
     public name: string;
+    /**
+     * The ambiguous displayname of this room member.
+     */
     public rawDisplayName: string;
+    /**
+     * The power level for this room member.
+     */
     public powerLevel = 0;
+    /**
+     * The normalised power level (0-100) for this room member.
+     */
     public powerLevelNorm = 0;
+    /**
+     * The User object for this room member, if one exists.
+     */
     public user?: User;
+    /**
+     * The membership state for this room member e.g. 'join'.
+     */
     public membership?: string;
+    /**
+     * True if the member's name is disambiguated.
+     */
     public disambiguate = false;
+    /**
+     * The events describing this RoomMember.
+     */
     public events: {
+        /**
+         * The m.room.member event for this RoomMember.
+         */
         member?: MatrixEvent;
     } = {};
 
     /**
      * Construct a new room member.
      *
-     * @constructor
-     * @alias module:models/room-member
-     *
-     * @param {string} roomId The room ID of the member.
-     * @param {string} userId The user ID of the member.
-     * @prop {string} roomId The room ID for this member.
-     * @prop {string} userId The user ID of this member.
-     * @prop {boolean} typing True if the room member is currently typing.
-     * @prop {string} name The human-readable name for this room member. This will be
-     * disambiguated with a suffix of " (@user_id:matrix.org)" if another member shares the
-     * same displayname.
-     * @prop {string} rawDisplayName The ambiguous displayname of this room member.
-     * @prop {Number} powerLevel The power level for this room member.
-     * @prop {Number} powerLevelNorm The normalised power level (0-100) for this
-     * room member.
-     * @prop {User} user The User object for this room member, if one exists.
-     * @prop {string} membership The membership state for this room member e.g. 'join'.
-     * @prop {Object} events The events describing this RoomMember.
-     * @prop {MatrixEvent} events.member The m.room.member event for this RoomMember.
-     * @prop {boolean} disambiguate True if the member's name is disambiguated.
+     * @param roomId - The room ID of the member.
+     * @param userId - The user ID of the member.
      */
     public constructor(public readonly roomId: string, public readonly userId: string) {
         super();
@@ -99,7 +156,7 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
     }
 
     /**
-     * @return {boolean} does the member come from a channel that is not sync?
+     * @returns does the member come from a channel that is not sync?
      * This is used to store the member seperately
      * from the sync state so it available across browser sessions.
      */
@@ -110,11 +167,13 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
     /**
      * Update this room member's membership event. May fire "RoomMember.name" if
      * this event updates this member's name.
-     * @param {MatrixEvent} event The <code>m.room.member</code> event
-     * @param {RoomState} roomState Optional. The room state to take into account
+     * @param event - The `m.room.member` event
+     * @param roomState - Optional. The room state to take into account
      * when calculating (e.g. for disambiguating users with the same name).
-     * @fires module:client~MatrixClient#event:"RoomMember.name"
-     * @fires module:client~MatrixClient#event:"RoomMember.membership"
+     *
+     * @remarks
+     * Fires {@link RoomMemberEvent.Name}
+     * Fires {@link RoomMemberEvent.Membership}
      */
     public setMembershipEvent(event: MatrixEvent, roomState?: RoomState): void {
         const displayName = event.getDirectionalContent().displayname ?? "";
@@ -164,9 +223,10 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
     /**
      * Update this room member's power level event. May fire
      * "RoomMember.powerLevel" if this event updates this member's power levels.
-     * @param {MatrixEvent} powerLevelEvent The <code>m.room.power_levels</code>
-     * event
-     * @fires module:client~MatrixClient#event:"RoomMember.powerLevel"
+     * @param powerLevelEvent - The `m.room.power_levels` event
+     *
+     * @remarks
+     * Fires {@link RoomMemberEvent.PowerLevel}
      */
     public setPowerLevelEvent(powerLevelEvent: MatrixEvent): void {
         if (powerLevelEvent.getType() !== EventType.RoomPowerLevels || powerLevelEvent.getStateKey() !== "") {
@@ -206,8 +266,10 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
     /**
      * Update this room member's typing event. May fire "RoomMember.typing" if
      * this event changes this member's typing state.
-     * @param {MatrixEvent} event The typing event
-     * @fires module:client~MatrixClient#event:"RoomMember.typing"
+     * @param event - The typing event
+     *
+     * @remarks
+     * Fires {@link RoomMemberEvent.Typing}
      */
     public setTypingEvent(event: MatrixEvent): void {
         if (event.getType() !== "m.typing") {
@@ -240,7 +302,7 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
      * Get the timestamp when this RoomMember was last updated. This timestamp is
      * updated when properties on this RoomMember are updated.
      * It is updated <i>before</i> firing events.
-     * @return {number} The timestamp
+     * @returns The timestamp
      */
     public getLastModifiedTime(): number {
         return this.modified;
@@ -255,7 +317,7 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
     /**
      * If this member was invited with the is_direct flag set, return
      * the user that invited this member
-     * @return {string} user id of the inviter
+     * @returns user id of the inviter
      */
     public getDMInviter(): string | undefined {
         // when not available because that room state hasn't been loaded in,
@@ -285,21 +347,21 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
 
     /**
      * Get the avatar URL for a room member.
-     * @param {string} baseUrl The base homeserver URL See
-     * {@link module:client~MatrixClient#getHomeserverUrl}.
-     * @param {Number} width The desired width of the thumbnail.
-     * @param {Number} height The desired height of the thumbnail.
-     * @param {string} resizeMethod The thumbnail resize method to use, either
+     * @param baseUrl - The base homeserver URL See
+     * {@link MatrixClient#getHomeserverUrl}.
+     * @param width - The desired width of the thumbnail.
+     * @param height - The desired height of the thumbnail.
+     * @param resizeMethod - The thumbnail resize method to use, either
      * "crop" or "scale".
-     * @param {Boolean} allowDefault (optional) Passing false causes this method to
+     * @param allowDefault - (optional) Passing false causes this method to
      * return null if the user has no avatar image. Otherwise, a default image URL
      * will be returned. Default: true. (Deprecated)
-     * @param {Boolean} allowDirectLinks (optional) If true, the avatar URL will be
+     * @param allowDirectLinks - (optional) If true, the avatar URL will be
      * returned even if it is a direct hyperlink rather than a matrix content URL.
      * If false, any non-matrix content URLs will be ignored. Setting this option to
      * true will expose URLs that, if fetched, will leak information about the user
      * to anyone who they share a room with.
-     * @return {?string} the avatar URL or null.
+     * @returns the avatar URL or null.
      */
     public getAvatarUrl(
         baseUrl: string,
@@ -323,7 +385,7 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
 
     /**
      * get the mxc avatar url, either from a state event, or from a lazily loaded member
-     * @return {string} the mxc avatar url
+     * @returns the mxc avatar url
      */
     public getMxcAvatarUrl(): string | undefined {
         if (this.events.member) {
@@ -390,52 +452,3 @@ function calculateDisplayName(
     // with the embed chars or marker chars.
     return utils.removeDirectionOverrideChars(displayName);
 }
-
-/**
- * Fires whenever any room member's name changes.
- * @event module:client~MatrixClient#"RoomMember.name"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.name changed.
- * @param {string?} oldName The previous name. Null if the member didn't have a
- *    name previously.
- * @example
- * matrixClient.on("RoomMember.name", function(event, member){
- *   var newName = member.name;
- * });
- */
-
-/**
- * Fires whenever any room member's membership state changes.
- * @event module:client~MatrixClient#"RoomMember.membership"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.membership changed.
- * @param {string?} oldMembership The previous membership state. Null if it's a
- *    new member.
- * @example
- * matrixClient.on("RoomMember.membership", function(event, member, oldMembership){
- *   var newState = member.membership;
- * });
- */
-
-/**
- * Fires whenever any room member's typing state changes.
- * @event module:client~MatrixClient#"RoomMember.typing"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.typing changed.
- * @example
- * matrixClient.on("RoomMember.typing", function(event, member){
- *   var isTyping = member.typing;
- * });
- */
-
-/**
- * Fires whenever any room member's power level changes.
- * @event module:client~MatrixClient#"RoomMember.powerLevel"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.powerLevel changed.
- * @example
- * matrixClient.on("RoomMember.powerLevel", function(event, member){
- *   var newPowerLevel = member.powerLevel;
- *   var newNormPowerLevel = member.powerLevelNorm;
- * });
- */
diff --git a/src/models/room-state.ts b/src/models/room-state.ts
index e69d9515268..01081f33a6a 100644
--- a/src/models/room-state.ts
+++ b/src/models/room-state.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/room-state
- */
-
 import { RoomMember } from "./room-member";
 import { logger } from '../logger';
 import * as utils from "../utils";
@@ -77,8 +73,52 @@ export enum RoomStateEvent {
 }
 
 export type RoomStateEventHandlerMap = {
+    /**
+     * Fires whenever the event dictionary in room state is updated.
+     * @param event - The matrix event which caused this event to fire.
+     * @param state - The room state whose RoomState.events dictionary
+     * was updated.
+     * @param prevEvent - The event being replaced by the new state, if
+     * known. Note that this can differ from `getPrevContent()` on the new state event
+     * as this is the store's view of the last state, not the previous state provided
+     * by the server.
+     * @example
+     * ```
+     * matrixClient.on("RoomState.events", function(event, state, prevEvent){
+     *   var newStateEvent = event;
+     * });
+     * ```
+     */
     [RoomStateEvent.Events]: (event: MatrixEvent, state: RoomState, lastStateEvent: MatrixEvent | null) => void;
+    /**
+     * Fires whenever a member in the members dictionary is updated in any way.
+     * @param event - The matrix event which caused this event to fire.
+     * @param state - The room state whose RoomState.members dictionary
+     * was updated.
+     * @param member - The room member that was updated.
+     * @example
+     * ```
+     * matrixClient.on("RoomState.members", function(event, state, member){
+     *   var newMembershipState = member.membership;
+     * });
+     * ```
+     */
     [RoomStateEvent.Members]: (event: MatrixEvent, state: RoomState, member: RoomMember) => void;
+    /**
+     * Fires whenever a member is added to the members dictionary. The RoomMember
+     * will not be fully populated yet (e.g. no membership state) but will already
+     * be available in the members dictionary.
+     * @param event - The matrix event which caused this event to fire.
+     * @param state - The room state whose RoomState.members dictionary
+     * was updated with a new entry.
+     * @param member - The room member that was added.
+     * @example
+     * ```
+     * matrixClient.on("RoomState.newMember", function(event, state, member){
+     *   // add event listeners on 'member'
+     * });
+     * ```
+     */
     [RoomStateEvent.NewMember]: (event: MatrixEvent, state: RoomState, member: RoomMember) => void;
     [RoomStateEvent.Update]: (state: RoomState) => void;
     [RoomStateEvent.BeaconLiveness]: (state: RoomState, hasLiveBeacons: boolean) => void;
@@ -109,8 +149,11 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     private modified = -1;
 
     // XXX: Should be read-only
+    // The room member dictionary, keyed on the user's ID.
     public members: Record<string, RoomMember> = {}; // userId: RoomMember
+    // The state events dictionary, keyed on the event type and then the state_key value.
     public events = new Map<string, Map<string, MatrixEvent>>(); // Map<eventType, Map<stateKey, MatrixEvent>>
+    // The pagination token for this state.
     public paginationToken: string | null = null;
 
     public readonly beacons = new Map<BeaconIdentifier, Beacon>();
@@ -123,8 +166,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * It can be mutated by adding state events to it.
      * There are two types of room member associated with a state event:
      * normal member objects (accessed via getMember/getMembers) which mutate
-     * with the state to represent the current state of that room/user, eg.
-     * the object returned by getMember('@bob:example.com') will mutate to
+     * with the state to represent the current state of that room/user, e.g.
+     * the object returned by `getMember('@bob:example.com')` will mutate to
      * get a different display name if Bob later changes his display name
      * in the room.
      * There are also 'sentinel' members (accessed via getSentinelMember).
@@ -137,18 +180,12 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * after the display name change will return a new RoomMember object
      * with Bob's new display name.
      *
-     * @constructor
-     * @param {?string} roomId Optional. The ID of the room which has this state.
+     * @param roomId - Optional. The ID of the room which has this state.
      * If none is specified it just tracks paginationTokens, useful for notifTimelineSet
-     * @param {?object} oobMemberFlags Optional. The state of loading out of bound members.
+     * @param oobMemberFlags - Optional. The state of loading out of bound members.
      * As the timeline might get reset while they are loading, this state needs to be inherited
      * and shared when the room state is cloned for the new timeline.
      * This should only be passed from clone.
-     * @prop {Object.<string, RoomMember>} members The room member dictionary, keyed
-     * on the user's ID.
-     * @prop {Object.<string, Object.<string, MatrixEvent>>} events The state
-     * events dictionary, keyed on the event type and then the state_key value.
-     * @prop {string} paginationToken The pagination token for this state.
      */
     public constructor(public readonly roomId: string, private oobMemberFlags = { status: OobStatus.NotStarted }) {
         super();
@@ -158,7 +195,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Returns the number of joined members in this room
      * This method caches the result.
-     * @return {number} The number of members in this room whose membership is 'join'
+     * @returns The number of members in this room whose membership is 'join'
      */
     public getJoinedMemberCount(): number {
         if (this.summaryJoinedMemberCount !== null) {
@@ -174,7 +211,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Set the joined member count explicitly (like from summary part of the sync response)
-     * @param {number} count the amount of joined members
+     * @param count - the amount of joined members
      */
     public setJoinedMemberCount(count: number): void {
         this.summaryJoinedMemberCount = count;
@@ -182,7 +219,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Returns the number of invited members in this room
-     * @return {number} The number of members in this room whose membership is 'invite'
+     * @returns The number of members in this room whose membership is 'invite'
      */
     public getInvitedMemberCount(): number {
         if (this.summaryInvitedMemberCount !== null) {
@@ -198,7 +235,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Set the amount of invited members in this room
-     * @param {number} count the amount of invited members
+     * @param count - the amount of invited members
      */
     public setInvitedMemberCount(count: number): void {
         this.summaryInvitedMemberCount = count;
@@ -206,7 +243,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Get all RoomMembers in this room.
-     * @return {Array<RoomMember>} A list of RoomMembers.
+     * @returns A list of RoomMembers.
      */
     public getMembers(): RoomMember[] {
         return Object.values(this.members);
@@ -214,8 +251,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Get all RoomMembers in this room, excluding the user IDs provided.
-     * @param {Array<string>} excludedIds The user IDs to exclude.
-     * @return {Array<RoomMember>} A list of RoomMembers.
+     * @param excludedIds - The user IDs to exclude.
+     * @returns A list of RoomMembers.
      */
     public getMembersExcept(excludedIds: string[]): RoomMember[] {
         return this.getMembers().filter((m) => !excludedIds.includes(m.userId));
@@ -223,8 +260,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Get a room member by their user ID.
-     * @param {string} userId The room member's user ID.
-     * @return {RoomMember} The member or null if they do not exist.
+     * @param userId - The room member's user ID.
+     * @returns The member or null if they do not exist.
      */
     public getMember(userId: string): RoomMember | null {
         return this.members[userId] || null;
@@ -236,8 +273,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * may no longer be represented correctly by Room.currentState or Room.oldState.
      * The term 'sentinel' refers to the fact that this RoomMember is an unchanging
      * guardian for state at this particular point in time.
-     * @param {string} userId The room member's user ID.
-     * @return {RoomMember} The member or null if they do not exist.
+     * @param userId - The room member's user ID.
+     * @returns The member or null if they do not exist.
      */
     public getSentinelMember(userId: string): RoomMember | null {
         if (!userId) return null;
@@ -256,12 +293,12 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Get state events from the state of the room.
-     * @param {string} eventType The event type of the state event.
-     * @param {string} stateKey Optional. The state_key of the state event. If
-     * this is <code>undefined</code> then all matching state events will be
+     * @param eventType - The event type of the state event.
+     * @param stateKey - Optional. The state_key of the state event. If
+     * this is `undefined` then all matching state events will be
      * returned.
-     * @return {MatrixEvent[]|MatrixEvent} A list of events if state_key was
-     * <code>undefined</code>, else a single event (or null if no match found).
+     * @returns A list of events if state_key was
+     * `undefined`, else a single event (or null if no match found).
      */
     public getStateEvents(eventType: EventType | string): MatrixEvent[];
     public getStateEvents(eventType: EventType | string, stateKey: string): MatrixEvent | null;
@@ -287,7 +324,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Creates a copy of this room state so that mutations to either won't affect the other.
-     * @return {RoomState} the copy of the room state
+     * @returns the copy of the room state
      */
     public clone(): RoomState {
         const copy = new RoomState(this.roomId, this.oobMemberFlags);
@@ -333,7 +370,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * When lazy loading members while back-paginating,
      * the relevant room state for the timeline chunk at the end
      * of the chunk can be set with this method.
-     * @param {MatrixEvent[]} events state events to prepend
+     * @param events - state events to prepend
      */
     public setUnknownStateEvents(events: MatrixEvent[]): void {
         const unknownStateEvents = events.filter((event) => {
@@ -345,16 +382,17 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Add an array of one or more state MatrixEvents, overwriting any existing
-     * state with the same {type, stateKey} tuple. Will fire "RoomState.events"
+     * state with the same `{type, stateKey}` tuple. Will fire "RoomState.events"
      * for every event added. May fire "RoomState.members" if there are
-     * <code>m.room.member</code> events. May fire "RoomStateEvent.Marker" if there are
-     * <code>UNSTABLE_MSC2716_MARKER</code> events.
-     * @param {MatrixEvent[]} stateEvents a list of state events for this room.
-     * @param {IMarkerFoundOptions} markerFoundOptions
-     * @fires module:client~MatrixClient#event:"RoomState.members"
-     * @fires module:client~MatrixClient#event:"RoomState.newMember"
-     * @fires module:client~MatrixClient#event:"RoomState.events"
-     * @fires module:client~MatrixClient#event:"RoomStateEvent.Marker"
+     * `m.room.member` events. May fire "RoomStateEvent.Marker" if there are
+     * `UNSTABLE_MSC2716_MARKER` events.
+     * @param stateEvents - a list of state events for this room.
+     *
+     * @remarks
+     * Fires {@link RoomStateEvent.Members}
+     * Fires {@link RoomStateEvent.NewMember}
+     * Fires {@link RoomStateEvent.Events}
+     * Fires {@link RoomStateEvent.Marker}
      */
     public setStateEvents(stateEvents: MatrixEvent[], markerFoundOptions?: IMarkerFoundOptions): void {
         this.updateModifiedTime();
@@ -479,10 +517,12 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * create it and emit the `RoomState.newMember` event.
      * This method makes sure the member is added to the members dictionary
      * before emitting, as this is done from setStateEvents and setOutOfBandMember.
-     * @param {string} userId the id of the user to look up
-     * @param {MatrixEvent} event the membership event for the (new) member. Used to emit.
-     * @fires module:client~MatrixClient#event:"RoomState.newMember"
-     * @returns {RoomMember} the member, existing or newly created.
+     * @param userId - the id of the user to look up
+     * @param event - the membership event for the (new) member. Used to emit.
+     * @returns the member, existing or newly created.
+     *
+     * @remarks
+     * Fires {@link RoomStateEvent.NewMember}
      */
     private getOrCreateMember(userId: string, event: MatrixEvent): RoomMember {
         let member = this.members[userId];
@@ -578,7 +618,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Get the out-of-band members loading state, whether loading is needed or not.
      * Note that loading might be in progress and hence isn't needed.
-     * @return {boolean} whether or not the members of this room need to be loaded
+     * @returns whether or not the members of this room need to be loaded
      */
     public needsOutOfBandMembers(): boolean {
         return this.oobMemberFlags.status === OobStatus.NotStarted;
@@ -624,7 +664,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Sets the loaded out-of-band members.
-     * @param {MatrixEvent[]} stateEvents array of membership state events
+     * @param stateEvents - array of membership state events
      */
     public setOutOfBandMembers(stateEvents: MatrixEvent[]): void {
         logger.log(`LL: RoomState about to set ${stateEvents.length} OOB members ...`);
@@ -639,7 +679,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Sets a single out of band member, used by both setOutOfBandMembers and clone
-     * @param {MatrixEvent} stateEvent membership state event
+     * @param stateEvent - membership state event
      */
     private setOutOfBandMember(stateEvent: MatrixEvent): void {
         if (stateEvent.getType() !== EventType.RoomMember) {
@@ -668,7 +708,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Set the current typing event for this room.
-     * @param {MatrixEvent} event The typing event
+     * @param event - The typing event
      */
     public setTypingEvent(event: MatrixEvent): void {
         Object.values(this.members).forEach(function(member) {
@@ -679,8 +719,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Get the m.room.member event which has the given third party invite token.
      *
-     * @param {string} token The token
-     * @return {?MatrixEvent} The m.room.member event or null
+     * @param token - The token
+     * @returns The m.room.member event or null
      */
     public getInviteForThreePidToken(token: string): MatrixEvent | null {
         return this.tokenToInvite[token] || null;
@@ -696,7 +736,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Get the timestamp when this room state was last updated. This timestamp is
      * updated when this object has received new state events.
-     * @return {number} The timestamp
+     * @returns The timestamp
      */
     public getLastModifiedTime(): number {
         return this.modified;
@@ -704,8 +744,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Get user IDs with the specified or similar display names.
-     * @param {string} displayName The display name to get user IDs from.
-     * @return {string[]} An array of user IDs or an empty array.
+     * @param displayName - The display name to get user IDs from.
+     * @returns An array of user IDs or an empty array.
      */
     public getUserIdsWithDisplayName(displayName: string): string[] {
         return this.displayNameToUserIds.get(utils.removeHiddenChars(displayName)) ?? [];
@@ -714,9 +754,9 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Returns true if userId is in room, event is not redacted and either sender of
      * mxEvent or has power level sufficient to redact events other than their own.
-     * @param {MatrixEvent} mxEvent The event to test permission for
-     * @param {string} userId The user ID of the user to test permission for
-     * @return {boolean} true if the given used ID can redact given event
+     * @param mxEvent - The event to test permission for
+     * @param userId - The user ID of the user to test permission for
+     * @returns true if the given used ID can redact given event
      */
     public maySendRedactionForEvent(mxEvent: MatrixEvent, userId: string): boolean {
         const member = this.getMember(userId);
@@ -734,9 +774,9 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Returns true if the given power level is sufficient for action
-     * @param {string} action The type of power level to check
-     * @param {number} powerLevel The power level of the member
-     * @return {boolean} true if the given power level is sufficient
+     * @param action - The type of power level to check
+     * @param powerLevel - The power level of the member
+     * @returns true if the given power level is sufficient
      */
     public hasSufficientPowerLevelFor(action: "ban" | "kick" | "redact", powerLevel: number): boolean {
         const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, "");
@@ -756,8 +796,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Short-form for maySendEvent('m.room.message', userId)
-     * @param {string} userId The user ID of the user to test permission for
-     * @return {boolean} true if the given user ID should be permitted to send
+     * @param userId - The user ID of the user to test permission for
+     * @returns true if the given user ID should be permitted to send
      *                   message events into the given room.
      */
     public maySendMessage(userId: string): boolean {
@@ -767,9 +807,9 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Returns true if the given user ID has permission to send a normal
      * event of type `eventType` into this room.
-     * @param {string} eventType The type of event to test
-     * @param {string} userId The user ID of the user to test permission for
-     * @return {boolean} true if the given user ID should be permitted to send
+     * @param eventType - The type of event to test
+     * @param userId - The user ID of the user to test permission for
+     * @returns true if the given user ID should be permitted to send
      *                        the given type of event into this room,
      *                        according to the room's state.
      */
@@ -780,9 +820,9 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
       * Returns true if the given MatrixClient has permission to send a state
       * event of type `stateEventType` into this room.
-      * @param {string} stateEventType The type of state events to test
-      * @param {MatrixClient} cli The client to test permission for
-      * @return {boolean} true if the given client should be permitted to send
+      * @param stateEventType - The type of state events to test
+      * @param cli - The client to test permission for
+      * @returns true if the given client should be permitted to send
       *                        the given type of state event into this room,
       *                        according to the room's state.
       */
@@ -796,9 +836,9 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Returns true if the given user ID has permission to send a state
      * event of type `stateEventType` into this room.
-     * @param {string} stateEventType The type of state events to test
-     * @param {string} userId The user ID of the user to test permission for
-     * @return {boolean} true if the given user ID should be permitted to send
+     * @param stateEventType - The type of state events to test
+     * @param userId - The user ID of the user to test permission for
+     * @returns true if the given user ID should be permitted to send
      *                        the given type of state event into this room,
      *                        according to the room's state.
      */
@@ -809,12 +849,12 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Returns true if the given user ID has permission to send a normal or state
      * event of type `eventType` into this room.
-     * @param {string} eventType The type of event to test
-     * @param {string} userId The user ID of the user to test permission for
-     * @param {boolean} state If true, tests if the user may send a state
+     * @param eventType - The type of event to test
+     * @param userId - The user ID of the user to test permission for
+     * @param state - If true, tests if the user may send a state
      event of this type. Otherwise tests whether
      they may send a regular event.
-     * @return {boolean} true if the given user ID should be permitted to send
+     * @returns true if the given user ID should be permitted to send
      *                        the given type of event into this room,
      *                        according to the room's state.
      */
@@ -859,9 +899,9 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     /**
      * Returns true if the given user ID has permission to trigger notification
      * of type `notifLevelKey`
-     * @param {string} notifLevelKey The level of notification to test (eg. 'room')
-     * @param {string} userId The user ID of the user to test permission for
-     * @return {boolean} true if the given user ID has permission to trigger a
+     * @param notifLevelKey - The level of notification to test (eg. 'room')
+     * @param userId - The user ID of the user to test permission for
+     * @returns true if the given user ID has permission to trigger a
      *                        notification of this type.
      */
     public mayTriggerNotifOfType(notifLevelKey: string, userId: string): boolean {
@@ -887,7 +927,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.
-     * @returns {string} the join_rule applied to this room
+     * @returns the join_rule applied to this room
      */
     public getJoinRule(): JoinRule {
         const joinRuleEvent = this.getStateEvents(EventType.RoomJoinRules, "");
@@ -897,7 +937,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Returns the history visibility based on the m.room.history_visibility state event, defaulting to `shared`.
-     * @returns {HistoryVisibility} the history_visibility applied to this room
+     * @returns the history_visibility applied to this room
      */
     public getHistoryVisibility(): HistoryVisibility {
         const historyVisibilityEvent = this.getStateEvents(EventType.RoomHistoryVisibility, "");
@@ -907,7 +947,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
 
     /**
      * Returns the guest access based on the m.room.guest_access state event, defaulting to `shared`.
-     * @returns {GuestAccess} the guest_access applied to this room
+     * @returns the guest_access applied to this room
      */
     public getGuestAccess(): GuestAccess {
         const guestAccessEvent = this.getStateEvents(EventType.RoomGuestAccess, "");
@@ -959,47 +999,3 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
         }
     }
 }
-
-/**
- * Fires whenever the event dictionary in room state is updated.
- * @event module:client~MatrixClient#"RoomState.events"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomState} state The room state whose RoomState.events dictionary
- * was updated.
- * @param {MatrixEvent} prevEvent The event being replaced by the new state, if
- * known. Note that this can differ from `getPrevContent()` on the new state event
- * as this is the store's view of the last state, not the previous state provided
- * by the server.
- * @example
- * matrixClient.on("RoomState.events", function(event, state, prevEvent){
- *   var newStateEvent = event;
- * });
- */
-
-/**
- * Fires whenever a member in the members dictionary is updated in any way.
- * @event module:client~MatrixClient#"RoomState.members"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomState} state The room state whose RoomState.members dictionary
- * was updated.
- * @param {RoomMember} member The room member that was updated.
- * @example
- * matrixClient.on("RoomState.members", function(event, state, member){
- *   var newMembershipState = member.membership;
- * });
- */
-
-/**
- * Fires whenever a member is added to the members dictionary. The RoomMember
- * will not be fully populated yet (e.g. no membership state) but will already
- * be available in the members dictionary.
- * @event module:client~MatrixClient#"RoomState.newMember"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomState} state The room state whose RoomState.members dictionary
- * was updated with a new entry.
- * @param {RoomMember} member The room member that was added.
- * @example
- * matrixClient.on("RoomState.newMember", function(event, state, member){
- *   // add event listeners on 'member'
- * });
- */
diff --git a/src/models/room-summary.ts b/src/models/room-summary.ts
index 218a4afcc8d..d12eb66ece5 100644
--- a/src/models/room-summary.ts
+++ b/src/models/room-summary.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/room-summary
- */
-
 export interface IRoomSummary {
     "m.heroes": string[];
     "m.joined_member_count"?: number;
@@ -25,25 +21,23 @@ export interface IRoomSummary {
 }
 
 interface IInfo {
+    /** The title of the room (e.g. `m.room.name`) */
     title: string;
+    /** The description of the room (e.g. `m.room.topic`) */
     desc?: string;
+    /** The number of joined users. */
     numMembers?: number;
+    /** The list of aliases for this room. */
     aliases?: string[];
+    /** The timestamp for this room. */
     timestamp?: number;
 }
 
 /**
  * Construct a new Room Summary. A summary can be used for display on a recent
  * list, without having to load the entire room list into memory.
- * @constructor
- * @param {string} roomId Required. The ID of this room.
- * @param {Object} info Optional. The summary info. Additional keys are supported.
- * @param {string} info.title The title of the room (e.g. <code>m.room.name</code>)
- * @param {string} info.desc The description of the room (e.g.
- * <code>m.room.topic</code>)
- * @param {Number} info.numMembers The number of joined users.
- * @param {string[]} info.aliases The list of aliases for this room.
- * @param {Number} info.timestamp The timestamp for this room.
+ * @param roomId - Required. The ID of this room.
+ * @param info - Optional. The summary info. Additional keys are supported.
  */
 export class RoomSummary {
     public constructor(public readonly roomId: string, info?: IInfo) {}
diff --git a/src/models/room.ts b/src/models/room.ts
index 4c3ebafbe82..48de9a58c1b 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/room
- */
-
 import { Optional } from "matrix-events-sdk";
 
 import {
@@ -73,7 +69,17 @@ export const KNOWN_SAFE_ROOM_VERSION = '9';
 const SAFE_ROOM_VERSIONS = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];
 
 interface IOpts {
+    /**
+     * Controls where pending messages appear in a room's timeline.
+     * If "<b>chronological</b>", messages will appear in the timeline when the call to `sendEvent` was made.
+     * If "<b>detached</b>", pending messages will appear in a separate list,
+     * accessible via {@link Room#getPendingEvents}.
+     * Default: "chronological".
+     */
     pendingEventOrdering?: PendingEventOrdering;
+    /**
+     * Set to true to enable improved timeline support.
+     */
     timelineSupport?: boolean;
     lazyLoadMembers?: boolean;
 }
@@ -151,13 +157,117 @@ export type RoomEmittedEvents = RoomEvent
     | BeaconEvent.LivenessChange;
 
 export type RoomEventHandlerMap = {
+    /**
+     * Fires when the logged in user's membership in the room is updated.
+     *
+     * @param room - The room in which the membership has been updated
+     * @param membership - The new membership value
+     * @param prevMembership - The previous membership value
+     */
     [RoomEvent.MyMembership]: (room: Room, membership: string, prevMembership?: string) => void;
+    /**
+     * Fires whenever a room's tags are updated.
+     * @param event - The tags event
+     * @param room - The room whose Room.tags was updated.
+     * @example
+     * ```
+     * matrixClient.on("Room.tags", function(event, room){
+     *   var newTags = event.getContent().tags;
+     *   if (newTags["favourite"]) showStar(room);
+     * });
+     * ```
+     */
     [RoomEvent.Tags]: (event: MatrixEvent, room: Room) => void;
+    /**
+     * Fires whenever a room's account_data is updated.
+     * @param event - The account_data event
+     * @param room - The room whose account_data was updated.
+     * @param prevEvent - The event being replaced by
+     * the new account data, if known.
+     * @example
+     * ```
+     * matrixClient.on("Room.accountData", function(event, room, oldEvent){
+     *   if (event.getType() === "m.room.colorscheme") {
+     *       applyColorScheme(event.getContents());
+     *   }
+     * });
+     * ```
+     */
     [RoomEvent.AccountData]: (event: MatrixEvent, room: Room, lastEvent?: MatrixEvent) => void;
-    [RoomEvent.Receipt]: (event: MatrixEvent, room: Room) => void;
+    /**
+     * Fires whenever a receipt is received for a room
+     * @param event - The receipt event
+     * @param room - The room whose receipts was updated.
+     * @example
+     * ```
+     * matrixClient.on("Room.receipt", function(event, room){
+     *   var receiptContent = event.getContent();
+     * });
+     * ```
+     */
+    [RoomEvent.Receipt]: (event: MatrixEvent, room: Room) => void;/**
+     * Fires whenever the name of a room is updated.
+     * @param room - The room whose Room.name was updated.
+     * @example
+     * ```
+     * matrixClient.on("Room.name", function(room){
+     *   var newName = room.name;
+     * });
+     * ```
+     */
     [RoomEvent.Name]: (room: Room) => void;
+    /**
+     * Fires when an event we had previously received is redacted.
+     *
+     * (Note this is *not* fired when the redaction happens before we receive the
+     * event).
+     *
+     * @param event - The matrix redaction event
+     * @param room - The room containing the redacted event
+     */
     [RoomEvent.Redaction]: (event: MatrixEvent, room: Room) => void;
+    /**
+     * Fires when an event that was previously redacted isn't anymore.
+     * This happens when the redaction couldn't be sent and
+     * was subsequently cancelled by the user. Redactions have a local echo
+     * which is undone in this scenario.
+     *
+     * @param event - The matrix redaction event that was cancelled.
+     * @param room - The room containing the unredacted event
+     */
     [RoomEvent.RedactionCancelled]: (event: MatrixEvent, room: Room) => void;
+    /**
+     * Fires when the status of a transmitted event is updated.
+     *
+     * <p>When an event is first transmitted, a temporary copy of the event is
+     * inserted into the timeline, with a temporary event id, and a status of
+     * 'SENDING'.
+     *
+     * <p>Once the echo comes back from the server, the content of the event
+     * (MatrixEvent.event) is replaced by the complete event from the homeserver,
+     * thus updating its event id, as well as server-generated fields such as the
+     * timestamp. Its status is set to null.
+     *
+     * <p>Once the /send request completes, if the remote echo has not already
+     * arrived, the event is updated with a new event id and the status is set to
+     * 'SENT'. The server-generated fields are of course not updated yet.
+     *
+     * <p>If the /send fails, In this case, the event's status is set to
+     * 'NOT_SENT'. If it is later resent, the process starts again, setting the
+     * status to 'SENDING'. Alternatively, the message may be cancelled, which
+     * removes the event from the room, and sets the status to 'CANCELLED'.
+     *
+     * <p>This event is raised to reflect each of the transitions above.
+     *
+     * @param event - The matrix event which has been updated
+     *
+     * @param room - The room containing the redacted event
+     *
+     * @param oldEventId - The previous event id (the temporary event id,
+     *    except when updating a successfully-sent event when its echo arrives)
+     *
+     * @param oldStatus - The previous event status.
+     */
     [RoomEvent.LocalEchoUpdated]: (
         event: MatrixEvent,
         room: Room,
@@ -227,7 +337,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     public normalizedName: string;
     /**
      * Dict of room tags; the keys are the tag name and the values
-     * are any metadata associated with the tag - e.g. { "fav" : { order: 1 } }
+     * are any metadata associated with the tag - e.g. `{ "fav" : { order: 1 } }`
      */
     public tags: Record<string, Record<string, any>> = {}; // $tagName: { $metadata: $value }
     /**
@@ -301,21 +411,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * <p>In order that we can find events from their ids later, we also maintain a
      * map from event_id to timeline and index.
      *
-     * @constructor
-     * @alias module:models/room
-     * @param {string} roomId Required. The ID of this room.
-     * @param {MatrixClient} client Required. The client, used to lazy load members.
-     * @param {string} myUserId Required. The ID of the syncing user.
-     * @param {Object=} opts Configuration options
-     *
-     * @param {String=} opts.pendingEventOrdering Controls where pending messages
-     * appear in a room's timeline. If "<b>chronological</b>", messages will appear
-     * in the timeline when the call to <code>sendEvent</code> was made. If
-     * "<b>detached</b>", pending messages will appear in a separate list,
-     * accessible via {@link module:models/room#getPendingEvents}. Default:
-     * "chronological".
-     * @param {boolean} [opts.timelineSupport = false] Set to true to enable improved
-     * timeline support.
+     * @param roomId - Required. The ID of this room.
+     * @param client - Required. The client, used to lazy load members.
+     * @param myUserId - Required. The ID of the syncing user.
+     * @param opts - Configuration options
      */
     public constructor(
         public readonly roomId: string,
@@ -402,7 +501,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * - Last event of every room (to generate likely message preview)
      * - All events up to the read receipt (to calculate an accurate notification count)
      *
-     * @returns {Promise} Signals when all events have been decrypted
+     * @returns Signals when all events have been decrypted
      */
     public async decryptCriticalEvents(): Promise<void> {
         if (!this.client.isCryptoEnabled()) return;
@@ -425,7 +524,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Bulk decrypt events in a room
      *
-     * @returns {Promise} Signals when all events have been decrypted
+     * @returns Signals when all events have been decrypted
      */
     public async decryptAllEvents(): Promise<void> {
         if (!this.client.isCryptoEnabled()) return;
@@ -443,7 +542,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Gets the creator of the room
-     * @returns {string} The creator of the room, or null if it could not be determined
+     * @returns The creator of the room, or null if it could not be determined
      */
     public getCreator(): string | null {
         const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
@@ -452,7 +551,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Gets the version of the room
-     * @returns {string} The version of the room, or null if it could not be determined
+     * @returns The version of the room, or null if it could not be determined
      */
     public getVersion(): string {
         const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
@@ -468,7 +567,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Determines whether this room needs to be upgraded to a new version
-     * @returns {string?} What version the room should be upgraded to, or null if
+     * @returns What version the room should be upgraded to, or null if
      *     the room does not require upgrading at this time.
      * @deprecated Use #getRecommendedVersion() instead
      */
@@ -489,13 +588,13 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Determines the recommended room version for the room. This returns an
-     * object with 3 properties: <code>version</code> as the new version the
+     * object with 3 properties: `version` as the new version the
      * room should be upgraded to (may be the same as the current version);
-     * <code>needsUpgrade</code> to indicate if the room actually can be
-     * upgraded (ie: does the current version not match?); and <code>urgent</code>
+     * `needsUpgrade` to indicate if the room actually can be
+     * upgraded (ie: does the current version not match?); and `urgent`
      * to indicate if the new version patches a vulnerability in a previous
      * version.
-     * @returns {Promise<{version: string, needsUpgrade: boolean, urgent: boolean}>}
+     * @returns
      * Resolves to the version the room should be upgraded to.
      */
     public async getRecommendedVersion(): Promise<IRecommendedVersion> {
@@ -576,8 +675,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Determines whether the given user is permitted to perform a room upgrade
-     * @param {String} userId The ID of the user to test against
-     * @returns {boolean} True if the given user is permitted to upgrade the room
+     * @param userId - The ID of the user to test against
+     * @returns True if the given user is permitted to upgrade the room
      */
     public userMayUpgradeRoom(userId: string): boolean {
         return this.currentState.maySendStateEvent(EventType.RoomTombstone, userId);
@@ -586,10 +685,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get the list of pending sent events for this room
      *
-     * @return {module:models/event.MatrixEvent[]} A list of the sent events
+     * @returns A list of the sent events
      * waiting for remote echo.
      *
-     * @throws If <code>opts.pendingEventOrdering</code> was not 'detached'
+     * @throws If `opts.pendingEventOrdering` was not 'detached'
      */
     public getPendingEvents(): MatrixEvent[] {
         if (!this.pendingEventList) {
@@ -604,8 +703,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Removes a pending event for this room
      *
-     * @param {string} eventId
-     * @return {boolean} True if an element was removed.
+     * @returns True if an element was removed.
      */
     public removePendingEvent(eventId: string): boolean {
         if (!this.pendingEventList) {
@@ -630,8 +728,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * Check whether the pending event list contains a given event by ID.
      * If pending event ordering is not "detached" then this returns false.
      *
-     * @param {string} eventId The event ID to check for.
-     * @return {boolean}
+     * @param eventId - The event ID to check for.
      */
     public hasPendingEvent(eventId: string): boolean {
         return this.pendingEventList?.some(event => event.getId() === eventId) ?? false;
@@ -640,8 +737,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get a specific event from the pending event list, if configured, null otherwise.
      *
-     * @param {string} eventId The event ID to check for.
-     * @return {MatrixEvent}
+     * @param eventId - The event ID to check for.
      */
     public getPendingEvent(eventId: string): MatrixEvent | null {
         return this.pendingEventList?.find(event => event.getId() === eventId) ?? null;
@@ -650,7 +746,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get the live unfiltered timeline for this room.
      *
-     * @return {module:models/event-timeline~EventTimeline} live timeline
+     * @returns live timeline
      */
     public getLiveTimeline(): EventTimeline {
         return this.getUnfilteredTimelineSet().getLiveTimeline();
@@ -659,7 +755,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get the timestamp of the last message in the room
      *
-     * @return {number} the timestamp of the last message in the room
+     * @returns the timestamp of the last message in the room
      */
     public getLastActiveTimestamp(): number {
         const timeline = this.getLiveTimeline();
@@ -673,7 +769,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     }
 
     /**
-     * @return {string} the membership type (join | leave | invite) for the logged in user
+     * @returns the membership type (join | leave | invite) for the logged in user
      */
     public getMyMembership(): string {
         return this.selfMembership ?? "leave";
@@ -682,7 +778,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * If this room is a DM we're invited to,
      * try to find out who invited us
-     * @return {string} user id of the inviter
+     * @returns user id of the inviter
      */
     public getDMInviter(): string | undefined {
         const me = this.getMember(this.myUserId);
@@ -701,7 +797,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Assuming this room is a DM room, tries to guess with which user.
-     * @return {string} user id of the other member (could be syncing user)
+     * @returns user id of the other member (could be syncing user)
      */
     public guessDMUserId(): string {
         const me = this.getMember(this.myUserId);
@@ -768,7 +864,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Sets the membership this room was received as during sync
-     * @param {string} membership join | leave | invite
+     * @param membership - join | leave | invite
      */
     public updateMyMembership(membership: string): void {
         const prevMembership = this.selfMembership;
@@ -812,7 +908,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * Preloads the member list in case lazy loading
      * of memberships is in use. Can be called multiple times,
      * it will only preload once.
-     * @return {Promise} when preloading is done and
+     * @returns when preloading is done and
      * accessing the members on the room will take
      * all members in the room into account
      */
@@ -893,7 +989,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Empty out the current live timeline and re-request it. This is used when
-     * historical messages are imported into the room via MSC2716 `/batch_send
+     * historical messages are imported into the room via MSC2716 `/batch_send`
      * because the client may already have that section of the timeline loaded.
      * We need to force the client to throw away their current timeline so that
      * when they back paginate over the area again with the historical messages
@@ -998,8 +1094,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      *
      * <p>This is used when /sync returns a 'limited' timeline.
      *
-     * @param {string=} backPaginationToken   token for back-paginating the new timeline
-     * @param {string=} forwardPaginationToken token for forward-paginating the old live timeline,
+     * @param backPaginationToken -   token for back-paginating the new timeline
+     * @param forwardPaginationToken - token for forward-paginating the old live timeline,
      * if absent or null, all timelines are reset, removing old ones (including the previous live
      * timeline which would otherwise be unable to paginate forwards without this token).
      * Removing just the old live timeline whilst preserving previous ones is not supported.
@@ -1018,7 +1114,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Fix up this.timeline, this.oldState and this.currentState
      *
-     * @private
+     * @internal
      */
     private fixUpLegacyTimelineFields(): void {
         const previousOldState = this.oldState;
@@ -1077,7 +1173,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * disabled, then we aren't tracking room devices at all, so we can't answer this, and an
      * error will be thrown.
      *
-     * @return {boolean} the result
+     * @returns the result
      */
     public async hasUnverifiedDevices(): Promise<boolean> {
         if (!this.client.isRoomEncrypted(this.roomId)) {
@@ -1095,7 +1191,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Return the timeline sets for this room.
-     * @return {EventTimelineSet[]} array of timeline sets for this room
+     * @returns array of timeline sets for this room
      */
     public getTimelineSets(): EventTimelineSet[] {
         return this.timelineSets;
@@ -1103,7 +1199,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Helper to return the main unfiltered timeline set for this room
-     * @return {EventTimelineSet} room's unfiltered timeline set
+     * @returns room's unfiltered timeline set
      */
     public getUnfilteredTimelineSet(): EventTimelineSet {
         return this.timelineSets[0];
@@ -1112,8 +1208,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get the timeline which contains the given event from the unfiltered set, if any
      *
-     * @param {string} eventId  event ID to look for
-     * @return {?module:models/event-timeline~EventTimeline} timeline containing
+     * @param eventId -  event ID to look for
+     * @returns timeline containing
      * the given event, or null if unknown
      */
     public getTimelineForEvent(eventId: string): EventTimeline | null {
@@ -1129,7 +1225,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Add a new timeline to this room's unfiltered timeline set
      *
-     * @return {module:models/event-timeline~EventTimeline} newly-created timeline
+     * @returns newly-created timeline
      */
     public addTimeline(): EventTimeline {
         return this.getUnfilteredTimelineSet().addTimeline();
@@ -1138,7 +1234,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Whether the timeline needs to be refreshed in order to pull in new
      * historical messages that were imported.
-     * @param {Boolean} value The value to set
+     * @param value - The value to set
      */
     public setTimelineNeedsRefresh(value: boolean): void {
         this.timelineNeedsRefresh = value;
@@ -1147,7 +1243,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Whether the timeline needs to be refreshed in order to pull in new
      * historical messages that were imported.
-     * @return {Boolean} .
+     * @returns .
      */
     public getTimelineNeedsRefresh(): boolean {
         return this.timelineNeedsRefresh;
@@ -1156,8 +1252,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get an event which is stored in our unfiltered timeline set, or in a thread
      *
-     * @param {string} eventId event ID to look for
-     * @return {?module:models/event.MatrixEvent} the given event, or undefined if unknown
+     * @param eventId - event ID to look for
+     * @returns the given event, or undefined if unknown
      */
     public findEventById(eventId: string): MatrixEvent | undefined {
         let event = this.getUnfilteredTimelineSet().findEventById(eventId);
@@ -1178,8 +1274,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get one of the notification counts for this room
-     * @param {String} type The type of notification count to get. default: 'total'
-     * @return {Number} The notification count, or undefined if there is no count
+     * @param type - The type of notification count to get. default: 'total'
+     * @returns The notification count, or undefined if there is no count
      *                  for this type.
      */
     public getUnreadNotificationCount(type = NotificationCountType.Total): number {
@@ -1205,8 +1301,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get one of the notification counts for this room
-     * @param {String} type The type of notification count to get. default: 'total'
-     * @return {Number} The notification count, or undefined if there is no count
+     * @param type - The type of notification count to get. default: 'total'
+     * @returns The notification count, or undefined if there is no count
      *                  for this type.
      */
     public getRoomUnreadNotificationCount(type = NotificationCountType.Total): number {
@@ -1216,8 +1312,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * @experimental
      * Get one of the notification counts for a thread
-     * @param threadId the root event ID
-     * @param type The type of notification count to get. default: 'total'
+     * @param threadId - the root event ID
+     * @param type - The type of notification count to get. default: 'total'
      * @returns The notification count, or undefined if there is no count
      *          for this type.
      */
@@ -1228,7 +1324,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * @experimental
      * Checks if the current room has unread thread notifications
-     * @returns {boolean}
+     * @returns
      */
     public hasThreadUnreadNotification(): boolean {
         for (const notification of this.threadNotifications.values()) {
@@ -1242,9 +1338,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * @experimental
      * Swet one of the notification count for a thread
-     * @param threadId the root event ID
-     * @param type The type of notification count to get. default: 'total'
-     * @returns {void}
+     * @param threadId - the root event ID
+     * @param type - The type of notification count to get. default: 'total'
+     * @returns
      */
     public setThreadUnreadNotificationCount(threadId: string, type: NotificationCountType, count: number): void {
         const notification: NotificationCount = {
@@ -1299,8 +1395,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Set one of the notification counts for this room
-     * @param {String} type The type of notification count to set.
-     * @param {Number} count The new count
+     * @param type - The type of notification count to set.
+     * @param count - The new count
      */
     public setUnreadNotificationCount(type: NotificationCountType, count: number): void {
         this.notificationCounts[type] = count;
@@ -1329,7 +1425,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Whether to send encrypted messages to devices within this room.
-     * @param {Boolean} value true to blacklist unverified devices, null
+     * @param value - true to blacklist unverified devices, null
      * to use the global value for this room.
      */
     public setBlacklistUnverifiedDevices(value: boolean): void {
@@ -1338,7 +1434,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Whether to send encrypted messages to devices within this room.
-     * @return {Boolean} true if blacklisting unverified devices, null
+     * @returns true if blacklisting unverified devices, null
      * if the global value should be used for this room.
      */
     public getBlacklistUnverifiedDevices(): boolean | null {
@@ -1348,15 +1444,15 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get the avatar URL for a room if one was set.
-     * @param {String} baseUrl The homeserver base URL. See
-     * {@link module:client~MatrixClient#getHomeserverUrl}.
-     * @param {Number} width The desired width of the thumbnail.
-     * @param {Number} height The desired height of the thumbnail.
-     * @param {string} resizeMethod The thumbnail resize method to use, either
+     * @param baseUrl - The homeserver base URL. See
+     * {@link MatrixClient#getHomeserverUrl}.
+     * @param width - The desired width of the thumbnail.
+     * @param height - The desired height of the thumbnail.
+     * @param resizeMethod - The thumbnail resize method to use, either
      * "crop" or "scale".
-     * @param {boolean} allowDefault True to allow an identicon for this room if an
+     * @param allowDefault - True to allow an identicon for this room if an
      * avatar URL wasn't explicitly set. Default: true. (Deprecated)
-     * @return {?string} the avatar URL or null.
+     * @returns the avatar URL or null.
      */
     public getAvatarUrl(
         baseUrl: string,
@@ -1380,7 +1476,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get the mxc avatar url for the room, if one was set.
-     * @return {string} the mxc avatar url or falsy
+     * @returns the mxc avatar url or falsy
      */
     public getMxcAvatarUrl(): string | null {
         return this.currentState.getStateEvents(EventType.RoomAvatar, "")?.getContent()?.url || null;
@@ -1390,7 +1486,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * Get this room's canonical alias
      * The alias returned by this function may not necessarily
      * still point to this room.
-     * @return {?string} The room's canonical alias, or null if there is none
+     * @returns The room's canonical alias, or null if there is none
      */
     public getCanonicalAlias(): string | null {
         const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "");
@@ -1402,7 +1498,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get this room's alternative aliases
-     * @return {array} The room's alternative aliases, or an empty array
+     * @returns The room's alternative aliases, or an empty array
      */
     public getAltAliases(): string[] {
         const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "");
@@ -1417,19 +1513,19 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      *
      * <p>Will fire "Room.timeline" for each event added.
      *
-     * @param {MatrixEvent[]} events A list of events to add.
+     * @param events - A list of events to add.
      *
-     * @param {boolean} toStartOfTimeline   True to add these events to the start
+     * @param toStartOfTimeline -   True to add these events to the start
      * (oldest) instead of the end (newest) of the timeline. If true, the oldest
      * event will be the <b>last</b> element of 'events'.
      *
-     * @param {module:models/event-timeline~EventTimeline} timeline   timeline to
+     * @param timeline -   timeline to
      *    add events to.
      *
-     * @param {string=} paginationToken   token for the next batch of events
-     *
-     * @fires module:client~MatrixClient#event:"Room.timeline"
+     * @param paginationToken -   token for the next batch of events
      *
+     * @remarks
+     * Fires {@link RoomEvent.Timeline}
      */
     public addEventsToTimeline(
         events: MatrixEvent[],
@@ -1456,8 +1552,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get a member from the current room state.
-     * @param {string} userId The user ID of the member.
-     * @return {RoomMember} The member or <code>null</code>.
+     * @param userId - The user ID of the member.
+     * @returns The member or `null`.
      */
     public getMember(userId: string): RoomMember | null {
         return this.currentState.getMember(userId);
@@ -1466,7 +1562,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get all currently loaded members from the current
      * room state.
-     * @returns {RoomMember[]} Room members
+     * @returns Room members
      */
     public getMembers(): RoomMember[] {
         return this.currentState.getMembers();
@@ -1474,7 +1570,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get a list of members whose membership state is "join".
-     * @return {RoomMember[]} A list of currently joined members.
+     * @returns A list of currently joined members.
      */
     public getJoinedMembers(): RoomMember[] {
         return this.getMembersWithMembership("join");
@@ -1485,7 +1581,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * This method caches the result.
      * This is a wrapper around the method of the same name in roomState, returning
      * its result for the room's current state.
-     * @return {number} The number of members in this room whose membership is 'join'
+     * @returns The number of members in this room whose membership is 'join'
      */
     public getJoinedMemberCount(): number {
         return this.currentState.getJoinedMemberCount();
@@ -1493,7 +1589,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns the number of invited members in this room
-     * @return {number} The number of members in this room whose membership is 'invite'
+     * @returns The number of members in this room whose membership is 'invite'
      */
     public getInvitedMemberCount(): number {
         return this.currentState.getInvitedMemberCount();
@@ -1501,7 +1597,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns the number of invited + joined members in this room
-     * @return {number} The number of members in this room whose membership is 'invite' or 'join'
+     * @returns The number of members in this room whose membership is 'invite' or 'join'
      */
     public getInvitedAndJoinedMemberCount(): number {
         return this.getInvitedMemberCount() + this.getJoinedMemberCount();
@@ -1509,8 +1605,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get a list of members with given membership state.
-     * @param {string} membership The membership state.
-     * @return {RoomMember[]} A list of members with the given membership state.
+     * @param membership - The membership state.
+     * @returns A list of members with the given membership state.
      */
     public getMembersWithMembership(membership: string): RoomMember[] {
         return this.currentState.getMembers().filter(function(m) {
@@ -1520,7 +1616,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Get a list of members we should be encrypting for in this room
-     * @return {Promise<RoomMember[]>} A list of members who
+     * @returns A list of members who
      * we should encrypt messages for in this room.
      */
     public async getEncryptionTargetMembers(): Promise<RoomMember[]> {
@@ -1534,7 +1630,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Determine whether we should encrypt messages for invited users in this room
-     * @return {boolean} if we should encrypt messages for invited users
+     * @returns if we should encrypt messages for invited users
      */
     public shouldEncryptForInvitedMembers(): boolean {
         const ev = this.currentState.getStateEvents(EventType.RoomHistoryVisibility, "");
@@ -1544,9 +1640,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Get the default room name (i.e. what a given user would see if the
      * room had no m.room.name)
-     * @param {string} userId The userId from whose perspective we want
+     * @param userId - The userId from whose perspective we want
      * to calculate the default name
-     * @return {string} The default room name
+     * @returns The default room name
      */
     public getDefaultRoomName(userId: string): string {
         return this.calculateRoomName(userId, true);
@@ -1554,9 +1650,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Check if the given user_id has the given membership state.
-     * @param {string} userId The user ID to check.
-     * @param {string} membership The membership e.g. <code>'join'</code>
-     * @return {boolean} True if this user_id has the given membership state.
+     * @param userId - The user ID to check.
+     * @param membership - The membership e.g. `'join'`
+     * @returns True if this user_id has the given membership state.
      */
     public hasMembershipState(userId: string, membership: string): boolean {
         const member = this.getMember(userId);
@@ -1568,9 +1664,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Add a timelineSet for this room with the given filter
-     * @param {Filter} filter The filter to be applied to this timelineSet
-     * @param {Object=} opts Configuration options
-     * @return {EventTimelineSet} The timelineSet
+     * @param filter - The filter to be applied to this timelineSet
+     * @param opts - Configuration options
+     * @returns The timelineSet
      */
     public getOrCreateFilteredTimelineSet(
         filter: Filter,
@@ -1714,8 +1810,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Takes the given thread root events and creates threads for them.
-     * @param events
-     * @param toStartOfTimeline
      */
     public processThreadRoots(events: MatrixEvent[], toStartOfTimeline: boolean): void {
         for (const rootEvent of events) {
@@ -1809,8 +1903,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Fetch a single page of threadlist messages for the specific thread filter
-     * @param filter
-     * @private
+     * @internal
      */
     private async fetchRoomThreadList(filter?: ThreadFilterType): Promise<void> {
         const timelineSet = filter === ThreadFilterType.My
@@ -1864,7 +1957,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Forget the timelineSet for this room with the given filter
      *
-     * @param {Filter} filter the filter whose timelineSet is to be forgotten
+     * @param filter - the filter whose timelineSet is to be forgotten
      */
     public removeFilteredTimelineSet(filter: Filter): void {
         const timelineSet = this.filteredTimelineSets[filter.filterId!];
@@ -2142,10 +2235,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * Add an event to the end of this room's live timelines. Will fire
      * "Room.timeline".
      *
-     * @param {MatrixEvent} event Event to be added
-     * @param {IAddLiveEventOptions} addLiveEventOptions addLiveEvent options
-     * @fires module:client~MatrixClient#event:"Room.timeline"
-     * @private
+     * @param event - Event to be added
+     * @param addLiveEventOptions - addLiveEvent options
+     * @internal
+     *
+     * @remarks
+     * Fires {@link RoomEvent.Timeline}
      */
     private addLiveEvent(event: MatrixEvent, addLiveEventOptions: IAddLiveEventOptions): void {
         const { duplicateStrategy, timelineWasEmpty, fromCache } = addLiveEventOptions;
@@ -2185,14 +2280,15 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      *
      * <p>This is an internal method, intended for use by MatrixClient.
      *
-     * @param {module:models/event.MatrixEvent} event The event to add.
+     * @param event - The event to add.
      *
-     * @param {string} txnId Transaction id for this outgoing event
-     *
-     * @fires module:client~MatrixClient#event:"Room.localEchoUpdated"
+     * @param txnId - Transaction id for this outgoing event
      *
      * @throws if the event doesn't have status SENDING, or we aren't given a
      * unique transaction id.
+     *
+     * @remarks
+     * Fires {@link RoomEvent.LocalEchoUpdated}
      */
     public addPendingEvent(event: MatrixEvent, txnId: string): void {
         if (event.status !== EventStatus.SENDING && event.status !== EventStatus.NOT_SENT) {
@@ -2264,7 +2360,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * all messages that are not yet encrypted will be discarded
      *
      * This is because the flow of EVENT_STATUS transition is
-     * queued => sending => encrypting => sending => sent
+     * `queued => sending => encrypting => sending => sent`
      *
      * Steps 3 and 4 are skipped for unencrypted room.
      * It is better to discard an unencrypted message rather than persisting
@@ -2296,7 +2392,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * which are just kept detached for their local echo.
      *
      * Also note that live events are aggregated in the live EventTimelineSet.
-     * @param {module:models/event.MatrixEvent} event the relation event that needs to be aggregated.
+     * @param event - the relation event that needs to be aggregated.
      */
     private aggregateNonLiveRelation(event: MatrixEvent): void {
         this.relations.aggregateChildEvent(event);
@@ -2312,13 +2408,15 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * <p>We move the event to the live timeline if it isn't there already, and
      * update it.
      *
-     * @param {module:models/event.MatrixEvent} remoteEvent   The event received from
+     * @param remoteEvent -   The event received from
      *    /sync
-     * @param {module:models/event.MatrixEvent} localEvent    The local echo, which
+     * @param localEvent -    The local echo, which
      *    should be either in the pendingEventList or the timeline.
      *
-     * @fires module:client~MatrixClient#event:"Room.localEchoUpdated"
-     * @private
+     * @internal
+     *
+     * @remarks
+     * Fires {@link RoomEvent.LocalEchoUpdated}
      */
     public handleRemoteEcho(remoteEvent: MatrixEvent, localEvent: MatrixEvent): void {
         const oldEventId = localEvent.getId()!;
@@ -2359,11 +2457,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      *
      * <p>This is an internal method.
      *
-     * @param {MatrixEvent} event      local echo event
-     * @param {EventStatus} newStatus  status to assign
-     * @param {string} newEventId      new event id to assign. Ignored unless
-     *    newStatus == EventStatus.SENT.
-     * @fires module:client~MatrixClient#event:"Room.localEchoUpdated"
+     * @param event -      local echo event
+     * @param newStatus -  status to assign
+     * @param newEventId -      new event id to assign. Ignored unless newStatus == EventStatus.SENT.
+     *
+     * @remarks
+     * Fires {@link RoomEvent.LocalEchoUpdated}
      */
     public updatePendingEvent(event: MatrixEvent, newStatus: EventStatus, newEventId?: string): void {
         logger.log(
@@ -2470,9 +2569,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * events and typing notifications. These events are treated as "live" so
      * they will go to the end of the timeline.
      *
-     * @param {MatrixEvent[]} events A list of events to add.
-     * @param {IAddLiveEventOptions} addLiveEventOptions addLiveEvent options
-     * @throws If <code>duplicateStrategy</code> is not falsey, 'replace' or 'ignore'.
+     * @param events - A list of events to add.
+     * @param addLiveEventOptions - addLiveEvent options
+     * @throws If `duplicateStrategy` is not falsey, 'replace' or 'ignore'.
      */
     public addLiveEvents(events: MatrixEvent[], addLiveEventOptions?: IAddLiveEventOptions): void;
     /**
@@ -2615,8 +2714,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Add a receipt event to the room.
-     * @param {MatrixEvent} event The m.receipt event.
-     * @param {Boolean} synthetic True if this event is implicit.
+     * @param event - The m.receipt event.
+     * @param synthetic - True if this event is implicit.
      */
     public addReceipt(event: MatrixEvent, synthetic = false): void {
         const content = event.getContent<ReceiptContent>();
@@ -2646,7 +2745,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Adds/handles ephemeral events such as typing notifications and read receipts.
-     * @param {MatrixEvent[]} events A list of events to process
+     * @param events - A list of events to process
      */
     public addEphemeralEvents(events: MatrixEvent[]): void {
         for (const event of events) {
@@ -2660,7 +2759,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Removes events from this room.
-     * @param {String[]} eventIds A list of eventIds to remove.
+     * @param eventIds - A list of eventIds to remove.
      */
     public removeEvents(eventIds: string[]): void {
         for (const eventId of eventIds) {
@@ -2671,9 +2770,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * Removes a single event from this room.
      *
-     * @param {String} eventId  The id of the event to remove
+     * @param eventId -  The id of the event to remove
      *
-     * @return {boolean} true if the event was removed from any of the room's timeline sets
+     * @returns true if the event was removed from any of the room's timeline sets
      */
     public removeEvent(eventId: string): boolean {
         let removedAny = false;
@@ -2693,7 +2792,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * Recalculate various aspects of the room, including the room name and
      * room summary. Call this any time the room's current state is modified.
      * May fire "Room.name" if the room name is updated.
-     * @fires module:client~MatrixClient#event:"Room.name"
+     *
+     * @remarks
+     * Fires {@link RoomEvent.Name}
      */
     public recalculate(): void {
         // set fake stripped state events if this is an invite room so logic remains
@@ -2736,7 +2837,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Update the room-tag event for the room.  The previous one is overwritten.
-     * @param {MatrixEvent} event the m.tag event
+     * @param event - the m.tag event
      */
     public addTags(event: MatrixEvent): void {
         // event content looks like:
@@ -2757,7 +2858,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Update the account_data events for this room, overwriting events of the same type.
-     * @param {Array<MatrixEvent>} events an array of account_data events to add
+     * @param events - an array of account_data events to add
      */
     public addAccountData(events: MatrixEvent[]): void {
         for (const event of events) {
@@ -2772,8 +2873,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Access account_data event of given event type for this room
-     * @param {string} type the type of account_data event to be accessed
-     * @return {?MatrixEvent} the account_data event in question
+     * @param type - the type of account_data event to be accessed
+     * @returns the account_data event in question
      */
     public getAccountData(type: EventType | string): MatrixEvent | undefined {
         return this.accountData[type];
@@ -2781,7 +2882,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns whether the syncing user has permission to send a message in the room
-     * @return {boolean} true if the user should be permitted to send
+     * @returns true if the user should be permitted to send
      *                   message events into the room.
      */
     public maySendMessage(): boolean {
@@ -2792,8 +2893,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns whether the given user has permissions to issue an invite for this room.
-     * @param {string} userId the ID of the Matrix user to check permissions for
-     * @returns {boolean} true if the user should be permitted to issue invites for this room.
+     * @param userId - the ID of the Matrix user to check permissions for
+     * @returns true if the user should be permitted to issue invites for this room.
      */
     public canInvite(userId: string): boolean {
         let canInvite = this.getMyMembership() === "join";
@@ -2808,7 +2909,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns the join rule based on the m.room.join_rule state event, defaulting to `invite`.
-     * @returns {string} the join_rule applied to this room
+     * @returns the join_rule applied to this room
      */
     public getJoinRule(): JoinRule {
         return this.currentState.getJoinRule();
@@ -2816,7 +2917,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns the history visibility based on the m.room.history_visibility state event, defaulting to `shared`.
-     * @returns {HistoryVisibility} the history_visibility applied to this room
+     * @returns the history_visibility applied to this room
      */
     public getHistoryVisibility(): HistoryVisibility {
         return this.currentState.getHistoryVisibility();
@@ -2824,7 +2925,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns the history visibility based on the m.room.history_visibility state event, defaulting to `shared`.
-     * @returns {HistoryVisibility} the history_visibility applied to this room
+     * @returns the history_visibility applied to this room
      */
     public getGuestAccess(): GuestAccess {
         return this.currentState.getGuestAccess();
@@ -2832,7 +2933,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns the type of the room from the `m.room.create` event content or undefined if none is set
-     * @returns {?string} the type of the room.
+     * @returns the type of the room.
      */
     public getType(): RoomType | string | undefined {
         const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
@@ -2848,7 +2949,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns whether the room is a space-room as defined by MSC1772.
-     * @returns {boolean} true if the room's type is RoomType.Space
+     * @returns true if the room's type is RoomType.Space
      */
     public isSpaceRoom(): boolean {
         return this.getType() === RoomType.Space;
@@ -2856,7 +2957,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns whether the room is a call-room as defined by MSC3417.
-     * @returns {boolean} true if the room's type is RoomType.UnstableCall
+     * @returns true if the room's type is RoomType.UnstableCall
      */
     public isCallRoom(): boolean {
         return this.getType() === RoomType.UnstableCall;
@@ -2864,7 +2965,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
     /**
      * Returns whether the room is a video room.
-     * @returns {boolean} true if the room's type is RoomType.ElementVideo
+     * @returns true if the room's type is RoomType.ElementVideo
      */
     public isElementVideoRoom(): boolean {
         return this.getType() === RoomType.ElementVideo;
@@ -2900,11 +3001,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     /**
      * This is an internal method. Calculates the name of the room from the current
      * room state.
-     * @param {string} userId The client's user ID. Used to filter room members
+     * @param userId - The client's user ID. Used to filter room members
      * correctly.
-     * @param {boolean} ignoreRoomNameEvent Return the implicit room name that we'd see if there
+     * @param ignoreRoomNameEvent - Return the implicit room name that we'd see if there
      * was no m.room.name event.
-     * @return {string} The calculated room name.
+     * @returns The calculated room name.
      */
     private calculateRoomName(userId: string, ignoreRoomNameEvent = false): string {
         if (!ignoreRoomNameEvent) {
@@ -3151,7 +3252,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * a (more recent) visibility change event, patch the event in
      * place so that clients now not to display it.
      *
-     * @param event Any matrix event. If this event has at least one a
+     * @param event - Any matrix event. If this event has at least one a
      * pending visibility change event, apply the latest visibility
      * change event.
      */
@@ -3250,118 +3351,3 @@ function memberNamesToRoomName(names: string[], count: number): string {
         }
     }
 }
-
-/**
- * Fires when an event we had previously received is redacted.
- *
- * (Note this is *not* fired when the redaction happens before we receive the
- * event).
- *
- * @event module:client~MatrixClient#"Room.redaction"
- * @param {MatrixEvent} event The matrix redaction event
- * @param {Room} room The room containing the redacted event
- */
-
-/**
- * Fires when an event that was previously redacted isn't anymore.
- * This happens when the redaction couldn't be sent and
- * was subsequently cancelled by the user. Redactions have a local echo
- * which is undone in this scenario.
- *
- * @event module:client~MatrixClient#"Room.redactionCancelled"
- * @param {MatrixEvent} event The matrix redaction event that was cancelled.
- * @param {Room} room The room containing the unredacted event
- */
-
-/**
- * Fires whenever the name of a room is updated.
- * @event module:client~MatrixClient#"Room.name"
- * @param {Room} room The room whose Room.name was updated.
- * @example
- * matrixClient.on("Room.name", function(room){
- *   var newName = room.name;
- * });
- */
-
-/**
- * Fires whenever a receipt is received for a room
- * @event module:client~MatrixClient#"Room.receipt"
- * @param {event} event The receipt event
- * @param {Room} room The room whose receipts was updated.
- * @example
- * matrixClient.on("Room.receipt", function(event, room){
- *   var receiptContent = event.getContent();
- * });
- */
-
-/**
- * Fires whenever a room's tags are updated.
- * @event module:client~MatrixClient#"Room.tags"
- * @param {event} event The tags event
- * @param {Room} room The room whose Room.tags was updated.
- * @example
- * matrixClient.on("Room.tags", function(event, room){
- *   var newTags = event.getContent().tags;
- *   if (newTags["favourite"]) showStar(room);
- * });
- */
-
-/**
- * Fires whenever a room's account_data is updated.
- * @event module:client~MatrixClient#"Room.accountData"
- * @param {event} event The account_data event
- * @param {Room} room The room whose account_data was updated.
- * @param {MatrixEvent} prevEvent The event being replaced by
- * the new account data, if known.
- * @example
- * matrixClient.on("Room.accountData", function(event, room, oldEvent){
- *   if (event.getType() === "m.room.colorscheme") {
- *       applyColorScheme(event.getContents());
- *   }
- * });
- */
-
-/**
- * Fires when the status of a transmitted event is updated.
- *
- * <p>When an event is first transmitted, a temporary copy of the event is
- * inserted into the timeline, with a temporary event id, and a status of
- * 'SENDING'.
- *
- * <p>Once the echo comes back from the server, the content of the event
- * (MatrixEvent.event) is replaced by the complete event from the homeserver,
- * thus updating its event id, as well as server-generated fields such as the
- * timestamp. Its status is set to null.
- *
- * <p>Once the /send request completes, if the remote echo has not already
- * arrived, the event is updated with a new event id and the status is set to
- * 'SENT'. The server-generated fields are of course not updated yet.
- *
- * <p>If the /send fails, In this case, the event's status is set to
- * 'NOT_SENT'. If it is later resent, the process starts again, setting the
- * status to 'SENDING'. Alternatively, the message may be cancelled, which
- * removes the event from the room, and sets the status to 'CANCELLED'.
- *
- * <p>This event is raised to reflect each of the transitions above.
- *
- * @event module:client~MatrixClient#"Room.localEchoUpdated"
- *
- * @param {MatrixEvent} event The matrix event which has been updated
- *
- * @param {Room} room The room containing the redacted event
- *
- * @param {string} oldEventId The previous event id (the temporary event id,
- *    except when updating a successfully-sent event when its echo arrives)
- *
- * @param {EventStatus} oldStatus The previous event status.
- */
-
-/**
- * Fires when the logged in user's membership in the room is updated.
- *
- * @event module:models/room~Room#"Room.myMembership"
- * @param {Room} room The room in which the membership has been updated
- * @param {string} membership The new membership value
- * @param {string} prevMembership The previous membership value
- */
-
diff --git a/src/models/search-result.ts b/src/models/search-result.ts
index f598301d785..2f27495acf4 100644
--- a/src/models/search-result.ts
+++ b/src/models/search-result.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/search-result
- */
-
 import { EventContext } from "./event-context";
 import { EventMapper } from "../event-mapper";
 import { IResultContext, ISearchResult } from "../@types/search";
@@ -25,10 +21,6 @@ import { IResultContext, ISearchResult } from "../@types/search";
 export class SearchResult {
     /**
      * Create a SearchResponse from the response to /search
-     * @static
-     * @param {Object} jsonObj
-     * @param {function} eventMapper
-     * @return {SearchResult}
      */
 
     public static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {
@@ -54,11 +46,9 @@ export class SearchResult {
     /**
      * Construct a new SearchResult
      *
-     * @param {number} rank   where this SearchResult ranks in the results
-     * @param {event-context.EventContext} context  the matching event and its
+     * @param rank -   where this SearchResult ranks in the results
+     * @param context -  the matching event and its
      *    context
-     *
-     * @constructor
      */
     public constructor(public readonly rank: number, public readonly context: EventContext) {}
 }
diff --git a/src/models/thread.ts b/src/models/thread.ts
index c595995b1cc..61b010a1859 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -247,10 +247,10 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
      * Add an event to the thread and updates
      * the tail/root references if needed
      * Will fire "Thread.update"
-     * @param event The event to add
-     * @param {boolean} toStartOfTimeline whether the event is being added
+     * @param event - The event to add
+     * @param toStartOfTimeline - whether the event is being added
      * to the start (and not the end) of the timeline.
-     * @param {boolean} emit whether to emit the Update event if the thread was updated or not.
+     * @param emit - whether to emit the Update event if the thread was updated or not.
      */
     public async addEvent(event: MatrixEvent, toStartOfTimeline: boolean, emit = true): Promise<void> {
         this.setEventMetadata(event);
diff --git a/src/models/typed-event-emitter.ts b/src/models/typed-event-emitter.ts
index 691ec5ec350..f9150077821 100644
--- a/src/models/typed-event-emitter.ts
+++ b/src/models/typed-event-emitter.ts
@@ -69,7 +69,7 @@ export class TypedEventEmitter<
         return super.listenerCount(event);
     }
 
-    public listeners(event: Events | EventEmitterEvents): Function[] {
+    public listeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter["listeners"]> {
         return super.listeners(event);
     }
 
@@ -119,7 +119,7 @@ export class TypedEventEmitter<
         return super.removeListener(event, listener);
     }
 
-    public rawListeners(event: Events | EventEmitterEvents): Function[] {
+    public rawListeners(event: Events | EventEmitterEvents): ReturnType<EventEmitter["rawListeners"]> {
         return super.rawListeners(event);
     }
 }
diff --git a/src/models/user.ts b/src/models/user.ts
index 5d92ca494cb..3dd199f3b1d 100644
--- a/src/models/user.ts
+++ b/src/models/user.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module models/user
- */
-
 import { MatrixEvent } from "./event";
 import { TypedEventEmitter } from "./typed-event-emitter";
 
@@ -30,51 +26,132 @@ export enum UserEvent {
 }
 
 export type UserEventHandlerMap = {
+    /**
+     * Fires whenever any user's display name changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param user - The user whose User.displayName changed.
+     * @example
+     * ```
+     * matrixClient.on("User.displayName", function(event, user){
+     *   var newName = user.displayName;
+     * });
+     * ```
+     */
     [UserEvent.DisplayName]: (event: MatrixEvent | undefined, user: User) => void;
+    /**
+     * Fires whenever any user's avatar URL changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param user - The user whose User.avatarUrl changed.
+     * @example
+     * ```
+     * matrixClient.on("User.avatarUrl", function(event, user){
+     *   var newUrl = user.avatarUrl;
+     * });
+     * ```
+     */
     [UserEvent.AvatarUrl]: (event: MatrixEvent | undefined, user: User) => void;
+    /**
+     * Fires whenever any user's presence changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param user - The user whose User.presence changed.
+     * @example
+     * ```
+     * matrixClient.on("User.presence", function(event, user){
+     *   var newPresence = user.presence;
+     * });
+     * ```
+     */
     [UserEvent.Presence]: (event: MatrixEvent | undefined, user: User) => void;
+    /**
+     * Fires whenever any user's currentlyActive changes.
+     * @param event - The matrix event which caused this event to fire.
+     * @param user - The user whose User.currentlyActive changed.
+     * @example
+     * ```
+     * matrixClient.on("User.currentlyActive", function(event, user){
+     *   var newCurrentlyActive = user.currentlyActive;
+     * });
+     * ```
+     */
     [UserEvent.CurrentlyActive]: (event: MatrixEvent | undefined, user: User) => void;
+    /**
+     * Fires whenever any user's lastPresenceTs changes,
+     * ie. whenever any presence event is received for a user.
+     * @param event - The matrix event which caused this event to fire.
+     * @param user - The user whose User.lastPresenceTs changed.
+     * @example
+     * ```
+     * matrixClient.on("User.lastPresenceTs", function(event, user){
+     *   var newlastPresenceTs = user.lastPresenceTs;
+     * });
+     * ```
+     */
     [UserEvent.LastPresenceTs]: (event: MatrixEvent | undefined, user: User) => void;
 };
 
 export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
     private modified = -1;
 
-    // XXX these should be read-only
+    /**
+     * The 'displayname' of the user if known.
+     * @privateRemarks
+     * Should be read-only
+     */
     public displayName?: string;
     public rawDisplayName?: string;
+    /**
+     * The 'avatar_url' of the user if known.
+     * @privateRemarks
+     * Should be read-only
+     */
     public avatarUrl?: string;
+    /**
+     * The presence status message if known.
+     * @privateRemarks
+     * Should be read-only
+     */
     public presenceStatusMsg?: string;
+    /**
+     * The presence enum if known.
+     * @privateRemarks
+     * Should be read-only
+     */
     public presence = "offline";
+    /**
+     * Timestamp (ms since the epoch) for when we last received presence data for this user.
+     * We can subtract lastActiveAgo from this to approximate an absolute value for when a user was last active.
+     * @privateRemarks
+     * Should be read-only
+     */
     public lastActiveAgo = 0;
+    /**
+     * The time elapsed in ms since the user interacted proactively with the server,
+     * or we saw a message from the user
+     * @privateRemarks
+     * Should be read-only
+     */
     public lastPresenceTs = 0;
+    /**
+     * Whether we should consider lastActiveAgo to be an approximation
+     * and that the user should be seen as active 'now'
+     * @privateRemarks
+     * Should be read-only
+     */
     public currentlyActive = false;
+    /**
+     * The events describing this user.
+     * @privateRemarks
+     * Should be read-only
+     */
     public events: {
+        /** The m.presence event for this user. */
         presence?: MatrixEvent;
         profile?: MatrixEvent;
     } = {};
 
     /**
-     * Construct a new User. A User must have an ID and can optionally have extra
-     * information associated with it.
-     * @constructor
-     * @param {string} userId Required. The ID of this user.
-     * @prop {string} userId The ID of the user.
-     * @prop {Object} info The info object supplied in the constructor.
-     * @prop {string} displayName The 'displayname' of the user if known.
-     * @prop {string} avatarUrl The 'avatar_url' of the user if known.
-     * @prop {string} presence The presence enum if known.
-     * @prop {string} presenceStatusMsg The presence status message if known.
-     * @prop {Number} lastActiveAgo The time elapsed in ms since the user interacted
-     *                proactively with the server, or we saw a message from the user
-     * @prop {Number} lastPresenceTs Timestamp (ms since the epoch) for when we last
-     *                received presence data for this user.  We can subtract
-     *                lastActiveAgo from this to approximate an absolute value for
-     *                when a user was last active.
-     * @prop {Boolean} currentlyActive Whether we should consider lastActiveAgo to be
-     *               an approximation and that the user should be seen as active 'now'
-     * @prop {Object} events The events describing this user.
-     * @prop {MatrixEvent} events.presence The m.presence event for this user.
+     * Construct a new User. A User must have an ID and can optionally have extra information associated with it.
+     * @param userId - Required. The ID of this user.
      */
     public constructor(public readonly userId: string) {
         super();
@@ -87,10 +164,12 @@ export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
      * Update this User with the given presence event. May fire "User.presence",
      * "User.avatarUrl" and/or "User.displayName" if this event updates this user's
      * properties.
-     * @param {MatrixEvent} event The <code>m.presence</code> event.
-     * @fires module:client~MatrixClient#event:"User.presence"
-     * @fires module:client~MatrixClient#event:"User.displayName"
-     * @fires module:client~MatrixClient#event:"User.avatarUrl"
+     * @param event - The `m.presence` event.
+     *
+     * @remarks
+     * Fires {@link UserEvent.Presence}
+     * Fires {@link UserEvent.DisplayName}
+     * Fires {@link UserEvent.AvatarUrl}
      */
     public setPresenceEvent(event: MatrixEvent): void {
         if (event.getType() !== "m.presence") {
@@ -142,7 +221,7 @@ export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
     /**
      * Manually set this user's display name. No event is emitted in response to this
      * as there is no underlying MatrixEvent to emit with.
-     * @param {string} name The new display name.
+     * @param name - The new display name.
      */
     public setDisplayName(name: string): void {
         const oldName = this.displayName;
@@ -155,7 +234,7 @@ export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
     /**
      * Manually set this user's non-disambiguated display name. No event is emitted
      * in response to this as there is no underlying MatrixEvent to emit with.
-     * @param {string} name The new display name.
+     * @param name - The new display name.
      */
     public setRawDisplayName(name?: string): void {
         this.rawDisplayName = name;
@@ -164,7 +243,7 @@ export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
     /**
      * Manually set this user's avatar URL. No event is emitted in response to this
      * as there is no underlying MatrixEvent to emit with.
-     * @param {string} url The new avatar URL.
+     * @param url - The new avatar URL.
      */
     public setAvatarUrl(url?: string): void {
         const oldUrl = this.avatarUrl;
@@ -185,7 +264,7 @@ export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
      * Get the timestamp when this User was last updated. This timestamp is
      * updated when this User receives a new Presence event which has updated a
      * property on this object. It is updated <i>before</i> firing events.
-     * @return {number} The timestamp
+     * @returns The timestamp
      */
     public getLastModifiedTime(): number {
         return this.modified;
@@ -194,65 +273,9 @@ export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
     /**
      * Get the absolute timestamp when this User was last known active on the server.
      * It is *NOT* accurate if this.currentlyActive is true.
-     * @return {number} The timestamp
+     * @returns The timestamp
      */
     public getLastActiveTs(): number {
         return this.lastPresenceTs - this.lastActiveAgo;
     }
 }
-
-/**
- * Fires whenever any user's lastPresenceTs changes,
- * ie. whenever any presence event is received for a user.
- * @event module:client~MatrixClient#"User.lastPresenceTs"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {User} user The user whose User.lastPresenceTs changed.
- * @example
- * matrixClient.on("User.lastPresenceTs", function(event, user){
- *   var newlastPresenceTs = user.lastPresenceTs;
- * });
- */
-
-/**
- * Fires whenever any user's presence changes.
- * @event module:client~MatrixClient#"User.presence"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {User} user The user whose User.presence changed.
- * @example
- * matrixClient.on("User.presence", function(event, user){
- *   var newPresence = user.presence;
- * });
- */
-
-/**
- * Fires whenever any user's currentlyActive changes.
- * @event module:client~MatrixClient#"User.currentlyActive"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {User} user The user whose User.currentlyActive changed.
- * @example
- * matrixClient.on("User.currentlyActive", function(event, user){
- *   var newCurrentlyActive = user.currentlyActive;
- * });
- */
-
-/**
- * Fires whenever any user's display name changes.
- * @event module:client~MatrixClient#"User.displayName"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {User} user The user whose User.displayName changed.
- * @example
- * matrixClient.on("User.displayName", function(event, user){
- *   var newName = user.displayName;
- * });
- */
-
-/**
- * Fires whenever any user's avatar URL changes.
- * @event module:client~MatrixClient#"User.avatarUrl"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {User} user The user whose User.avatarUrl changed.
- * @example
- * matrixClient.on("User.avatarUrl", function(event, user){
- *   var newUrl = user.avatarUrl;
- * });
- */
diff --git a/src/pushprocessor.ts b/src/pushprocessor.ts
index cc124682591..e6a30769256 100644
--- a/src/pushprocessor.ts
+++ b/src/pushprocessor.ts
@@ -38,10 +38,6 @@ import {
 } from "./@types/PushRules";
 import { EventType } from "./@types/event";
 
-/**
- * @module pushprocessor
- */
-
 const RULEKINDS_IN_ORDER = [
     PushRuleKind.Override,
     PushRuleKind.ContentSpecific,
@@ -116,25 +112,27 @@ const DEFAULT_UNDERRIDE_RULES: IPushRule[] = [
 ];
 
 export interface IActionsObject {
+    /** Whether this event should notify the user or not. */
     notify: boolean;
+    /** How this event should be notified. */
     tweaks: Partial<Record<TweakName, any>>;
 }
 
 export class PushProcessor {
     /**
      * Construct a Push Processor.
-     * @constructor
-     * @param {Object} client The Matrix client object to use
+     * @param client - The Matrix client object to use
      */
     public constructor(private readonly client: MatrixClient) {}
 
     /**
      * Convert a list of actions into a object with the actions as keys and their values
-     * eg. [ 'notify', { set_tweak: 'sound', value: 'default' } ]
-     *     becomes { notify: true, tweaks: { sound: 'default' } }
-     * @param {array} actionList The actions list
+     * @example
+     * eg. `[ 'notify', { set_tweak: 'sound', value: 'default' } ]`
+     *     becomes `{ notify: true, tweaks: { sound: 'default' } }`
+     * @param actionList - The actions list
      *
-     * @return {object} A object with key 'notify' (true or false) and an object of actions
+     * @returns A object with key 'notify' (true or false) and an object of actions
      */
     public static actionListToActionsObject(actionList: PushRuleAction[]): IActionsObject {
         const actionObj: IActionsObject = { notify: false, tweaks: {} };
@@ -155,8 +153,8 @@ export class PushProcessor {
      * Rewrites conditions on a client's push rules to match the defaults
      * where applicable. Useful for upgrading push rules to more strict
      * conditions when the server is falling behind on defaults.
-     * @param {object} incomingRules The client's existing push rules
-     * @returns {object} The rewritten rules
+     * @param incomingRules - The client's existing push rules
+     * @returns The rewritten rules
      */
     public static rewriteDefaultRules(incomingRules: IPushRules): IPushRules {
         let newRules: IPushRules = JSON.parse(JSON.stringify(incomingRules)); // deep clone
@@ -502,10 +500,6 @@ export class PushProcessor {
 
     /**
      * Get the user's push actions for the given event
-     *
-     * @param {module:models/event.MatrixEvent} ev
-     *
-     * @return {PushAction}
      */
     public actionsForEvent(ev: MatrixEvent): IActionsObject {
         return this.pushActionsForEventAndRulesets(ev, this.client.pushRules);
@@ -514,8 +508,8 @@ export class PushProcessor {
     /**
      * Get one of the users push rules by its ID
      *
-     * @param {string} ruleId The ID of the rule to search for
-     * @return {object} The push rule, or null if no such rule was found
+     * @param ruleId - The ID of the rule to search for
+     * @returns The push rule, or null if no such rule was found
      */
     public getPushRuleById(ruleId: string): IPushRule | null {
         for (const scope of ['global'] as const) {
@@ -532,15 +526,3 @@ export class PushProcessor {
         return null;
     }
 }
-
-/**
- * @typedef {Object} PushAction
- * @type {Object}
- * @property {boolean} notify Whether this event should notify the user or not.
- * @property {Object} tweaks How this event should be notified.
- * @property {boolean} tweaks.highlight Whether this event should be highlighted
- * on the UI.
- * @property {boolean} tweaks.sound Whether this notification should produce a
- * noise.
- */
-
diff --git a/src/realtime-callbacks.ts b/src/realtime-callbacks.ts
index 4677b0c1ed1..005e9816bc5 100644
--- a/src/realtime-callbacks.ts
+++ b/src/realtime-callbacks.ts
@@ -48,16 +48,17 @@ type Callback = {
 const callbackList: Callback[] = [];
 
 // var debuglog = logger.log.bind(logger);
+/* istanbul ignore next */
 const debuglog = function(...params: any[]): void {};
 
 /**
  * reimplementation of window.setTimeout, which will call the callback if
  * the wallclock time goes past the deadline.
  *
- * @param {function} func   callback to be called after a delay
- * @param {Number} delayMs  number of milliseconds to delay by
+ * @param func -   callback to be called after a delay
+ * @param delayMs -  number of milliseconds to delay by
  *
- * @return {Number} an identifier for this callback, which may be passed into
+ * @returns an identifier for this callback, which may be passed into
  *                   clearTimeout later.
  */
 export function setTimeout(func: (...params: any[]) => void, delayMs: number, ...params: any[]): number {
@@ -93,7 +94,7 @@ export function setTimeout(func: (...params: any[]) => void, delayMs: number, ..
 /**
  * reimplementation of window.clearTimeout, which mirrors setTimeout
  *
- * @param {Number} key   result from an earlier setTimeout call
+ * @param key -   result from an earlier setTimeout call
  */
 export function clearTimeout(key: number): void {
     if (callbackList.length === 0) {
diff --git a/src/rendezvous/MSC3906Rendezvous.ts b/src/rendezvous/MSC3906Rendezvous.ts
index a93d4c476ac..d4ed1bc1709 100644
--- a/src/rendezvous/MSC3906Rendezvous.ts
+++ b/src/rendezvous/MSC3906Rendezvous.ts
@@ -67,9 +67,9 @@ export class MSC3906Rendezvous {
     private _code?: string;
 
     /**
-     * @param channel The secure channel used for communication
-     * @param client The Matrix client in used on the device already logged in
-     * @param onFailure Callback for when the rendezvous fails
+     * @param channel - The secure channel used for communication
+     * @param client - The Matrix client in used on the device already logged in
+     * @param onFailure - Callback for when the rendezvous fails
      */
     public constructor(
         private channel: RendezvousChannel<MSC3906RendezvousPayload>,
@@ -217,7 +217,7 @@ export class MSC3906Rendezvous {
 
     /**
      * Verify the device and cross-sign it.
-     * @param timeout time in milliseconds to wait for device to come online
+     * @param timeout - time in milliseconds to wait for device to come online
      * @returns the new device info if the device was verified
      */
     public async verifyNewDeviceOnExistingDevice(
diff --git a/src/rendezvous/RendezvousChannel.ts b/src/rendezvous/RendezvousChannel.ts
index 9b1060304c9..f5c35217ff3 100644
--- a/src/rendezvous/RendezvousChannel.ts
+++ b/src/rendezvous/RendezvousChannel.ts
@@ -28,7 +28,7 @@ export interface RendezvousChannel<T> {
 
     /**
      * Send a payload via the channel.
-     * @param data payload to send
+     * @param data - payload to send
      */
     send(data: T): Promise<void>;
 
diff --git a/src/rendezvous/RendezvousTransport.ts b/src/rendezvous/RendezvousTransport.ts
index 231a0f1c48a..8721febffa0 100644
--- a/src/rendezvous/RendezvousTransport.ts
+++ b/src/rendezvous/RendezvousTransport.ts
@@ -41,7 +41,7 @@ export interface RendezvousTransport<T> {
 
   /**
    * Send data via the transport.
-   * @param data the data itself
+   * @param data - the data itself
    */
   send(data: T): Promise<void>;
 
@@ -52,7 +52,7 @@ export interface RendezvousTransport<T> {
 
   /**
    * Cancel the rendezvous. This will call `onCancelled()` if it is set.
-   * @param reason the reason for the cancellation/failure
+   * @param reason - the reason for the cancellation/failure
    */
   cancel(reason: RendezvousFailureReason): Promise<void>;
 }
diff --git a/src/room-hierarchy.ts b/src/room-hierarchy.ts
index c15f2ac56dc..3ed0205271a 100644
--- a/src/room-hierarchy.ts
+++ b/src/room-hierarchy.ts
@@ -14,10 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/**
- * @module room-hierarchy
- */
-
 import { Room } from "./models/room";
 import { IHierarchyRoom, IHierarchyRelation } from "./@types/spaces";
 import { MatrixClient } from "./client";
@@ -41,11 +37,10 @@ export class RoomHierarchy {
      *
      * A RoomHierarchy instance allows you to easily make use of the /hierarchy API and paginate it.
      *
-     * @param {Room} root the root of this hierarchy
-     * @param {number} pageSize the maximum number of rooms to return per page, can be overridden per load request.
-     * @param {number} maxDepth the maximum depth to traverse the hierarchy to
-     * @param {boolean} suggestedOnly whether to only return rooms with suggested=true.
-     * @constructor
+     * @param root - the root of this hierarchy
+     * @param pageSize - the maximum number of rooms to return per page, can be overridden per load request.
+     * @param maxDepth - the maximum depth to traverse the hierarchy to
+     * @param suggestedOnly - whether to only return rooms with suggested=true.
      */
     public constructor(
         public readonly root: Room,
diff --git a/src/scheduler.ts b/src/scheduler.ts
index 74bf7dd2580..d6cfef362cf 100644
--- a/src/scheduler.ts
+++ b/src/scheduler.ts
@@ -17,7 +17,6 @@ limitations under the License.
 /**
  * This is an internal module which manages queuing, scheduling and retrying
  * of requests.
- * @module scheduler
  */
 import * as utils from "./utils";
 import { logger } from './logger';
@@ -35,20 +34,13 @@ interface IQueueEntry<T> {
     attempts: number;
 }
 
-type ProcessFunction<T> = (event: MatrixEvent) => Promise<T>;
-
 /**
- * Construct a scheduler for Matrix. Requires
- * {@link module:scheduler~MatrixScheduler#setProcessFunction} to be provided
- * with a way of processing events.
- * @constructor
- * @param {module:scheduler~retryAlgorithm} retryAlgorithm Optional. The retry
- * algorithm to apply when determining when to try to send an event again.
- * Defaults to {@link module:scheduler~MatrixScheduler.RETRY_BACKOFF_RATELIMIT}.
- * @param {module:scheduler~queueAlgorithm} queueAlgorithm Optional. The queuing
- * algorithm to apply when determining which events should be sent before the
- * given event. Defaults to {@link module:scheduler~MatrixScheduler.QUEUE_MESSAGES}.
+ * The function to invoke to process (send) events in the queue.
+ * @param event - The event to send.
+ * @returns Resolved/rejected depending on the outcome of the request.
  */
+type ProcessFunction<T> = (event: MatrixEvent) => Promise<T>;
+
 // eslint-disable-next-line camelcase
 export class MatrixScheduler<T = ISendEventResponse> {
     /**
@@ -56,11 +48,8 @@ export class MatrixScheduler<T = ISendEventResponse> {
      * times of 2, 4, 8, and 16 seconds (30s total) after which we give up. If the
      * failure was due to a rate limited request, the time specified in the error is
      * waited before being retried.
-     * @param {MatrixEvent} event
-     * @param {Number} attempts Number of attempts that have been made, including the one that just failed (ie. starting at 1)
-     * @param {MatrixError} err
-     * @return {Number}
-     * @see module:scheduler~retryAlgorithm
+     * @param attempts - Number of attempts that have been made, including the one that just failed (ie. starting at 1)
+     * @see retryAlgorithm
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
     public static RETRY_BACKOFF_RATELIMIT(event: MatrixEvent | null, attempts: number, err: MatrixError): number {
@@ -90,11 +79,9 @@ export class MatrixScheduler<T = ISendEventResponse> {
     }
 
     /**
-     * Queues <code>m.room.message</code> events and lets other events continue
+     * Queues `m.room.message` events and lets other events continue
      * concurrently.
-     * @param {MatrixEvent} event
-     * @return {string}
-     * @see module:scheduler~queueAlgorithm
+     * @see queueAlgorithm
      */
     // eslint-disable-next-line @typescript-eslint/naming-convention
     public static QUEUE_MESSAGES(event: MatrixEvent): string | null {
@@ -116,16 +103,52 @@ export class MatrixScheduler<T = ISendEventResponse> {
     private activeQueues: string[] = [];
     private procFn: ProcessFunction<T> | null = null;
 
+    /**
+     * Construct a scheduler for Matrix. Requires
+     * {@link MatrixScheduler#setProcessFunction} to be provided
+     * with a way of processing events.
+     * @param retryAlgorithm - Optional. The retry
+     * algorithm to apply when determining when to try to send an event again.
+     * Defaults to {@link MatrixScheduler.RETRY_BACKOFF_RATELIMIT}.
+     * @param queueAlgorithm - Optional. The queuing
+     * algorithm to apply when determining which events should be sent before the
+     * given event. Defaults to {@link MatrixScheduler.QUEUE_MESSAGES}.
+     */
     public constructor(
+        /**
+         * The retry algorithm to apply when retrying events. To stop retrying, return
+         * `-1`. If this event was part of a queue, it will be removed from
+         * the queue.
+         * @param event - The event being retried.
+         * @param attempts - The number of failed attempts. This will always be \>= 1.
+         * @param err - The most recent error message received when trying
+         * to send this event.
+         * @returns The number of milliseconds to wait before trying again. If
+         * this is 0, the request will be immediately retried. If this is
+         * `-1`, the event will be marked as
+         * {@link EventStatus.NOT_SENT} and will not be retried.
+         */
         public readonly retryAlgorithm = MatrixScheduler.RETRY_BACKOFF_RATELIMIT,
+        /**
+         * The queuing algorithm to apply to events. This function must be idempotent as
+         * it may be called multiple times with the same event. All queues created are
+         * serviced in a FIFO manner. To send the event ASAP, return `null`
+         * which will not put this event in a queue. Events that fail to send that form
+         * part of a queue will be removed from the queue and the next event in the
+         * queue will be sent.
+         * @param event - The event to be sent.
+         * @returns The name of the queue to put the event into. If a queue with
+         * this name does not exist, it will be created. If this is `null`,
+         * the event is not put into a queue and will be sent concurrently.
+         */
         public readonly queueAlgorithm = MatrixScheduler.QUEUE_MESSAGES,
     ) {}
 
     /**
      * Retrieve a queue based on an event. The event provided does not need to be in
      * the queue.
-     * @param {MatrixEvent} event An event to get the queue for.
-     * @return {?Array<MatrixEvent>} A shallow copy of events in the queue or null.
+     * @param event - An event to get the queue for.
+     * @returns A shallow copy of events in the queue or null.
      * Modifying this array will not modify the list itself. Modifying events in
      * this array <i>will</i> modify the underlying event in the queue.
      * @see MatrixScheduler.removeEventFromQueue To remove an event from the queue.
@@ -143,8 +166,8 @@ export class MatrixScheduler<T = ISendEventResponse> {
     /**
      * Remove this event from the queue. The event is equal to another event if they
      * have the same ID returned from event.getId().
-     * @param {MatrixEvent} event The event to remove.
-     * @return {boolean} True if this event was removed.
+     * @param event - The event to remove.
+     * @returns True if this event was removed.
      */
     public removeEventFromQueue(event: MatrixEvent): boolean {
         const name = this.queueAlgorithm(event);
@@ -168,7 +191,7 @@ export class MatrixScheduler<T = ISendEventResponse> {
      * Set the process function. Required for events in the queue to be processed.
      * If set after events have been added to the queue, this will immediately start
      * processing them.
-     * @param {module:scheduler~processFn} fn The function that can process events
+     * @param fn - The function that can process events
      * in the queue.
      */
     public setProcessFunction(fn: ProcessFunction<T>): void {
@@ -178,8 +201,8 @@ export class MatrixScheduler<T = ISendEventResponse> {
 
     /**
      * Queue an event if it is required and start processing queues.
-     * @param {MatrixEvent} event The event that may be queued.
-     * @return {?Promise} A promise if the event was queued, which will be
+     * @param event - The event that may be queued.
+     * @returns A promise if the event was queued, which will be
      * resolved or rejected in due time, else null.
      */
     public queueEvent(event: MatrixEvent): Promise<T> | null {
@@ -283,46 +306,9 @@ export class MatrixScheduler<T = ISendEventResponse> {
     }
 }
 
+/* istanbul ignore next */
 function debuglog(...args: any[]): void {
     if (DEBUG) {
         logger.log(...args);
     }
 }
-
-/**
- * The retry algorithm to apply when retrying events. To stop retrying, return
- * <code>-1</code>. If this event was part of a queue, it will be removed from
- * the queue.
- * @callback retryAlgorithm
- * @param {MatrixEvent} event The event being retried.
- * @param {Number} attempts The number of failed attempts. This will always be
- * >= 1.
- * @param {MatrixError} err The most recent error message received when trying
- * to send this event.
- * @return {Number} The number of milliseconds to wait before trying again. If
- * this is 0, the request will be immediately retried. If this is
- * <code>-1</code>, the event will be marked as
- * {@link module:models/event.EventStatus.NOT_SENT} and will not be retried.
- */
-
-/**
- * The queuing algorithm to apply to events. This function must be idempotent as
- * it may be called multiple times with the same event. All queues created are
- * serviced in a FIFO manner. To send the event ASAP, return <code>null</code>
- * which will not put this event in a queue. Events that fail to send that form
- * part of a queue will be removed from the queue and the next event in the
- * queue will be sent.
- * @callback queueAlgorithm
- * @param {MatrixEvent} event The event to be sent.
- * @return {string} The name of the queue to put the event into. If a queue with
- * this name does not exist, it will be created. If this is <code>null</code>,
- * the event is not put into a queue and will be sent concurrently.
- */
-
-/**
- * The function to invoke to process (send) events in the queue.
- * @callback processFn
- * @param {MatrixEvent} event The event to send.
- * @return {Promise} Resolved/rejected depending on the outcome of the request.
- */
-
diff --git a/src/sliding-sync-sdk.ts b/src/sliding-sync-sdk.ts
index d103eb39bea..f9bddd87595 100644
--- a/src/sliding-sync-sdk.ts
+++ b/src/sliding-sync-sdk.ts
@@ -458,7 +458,7 @@ export class SlidingSyncSdk {
 
     /**
      * Sync rooms the user has left.
-     * @return {Promise} Resolved when they've been added to the store.
+     * @returns Resolved when they've been added to the store.
      */
     public async syncLeftRooms(): Promise<Room[]> {
         return []; // TODO
@@ -467,8 +467,8 @@ export class SlidingSyncSdk {
     /**
      * Peek into a room. This will result in the room in question being synced so it
      * is accessible via getRooms(). Live updates for the room will be provided.
-     * @param {string} roomId The room ID to peek into.
-     * @return {Promise} A promise which resolves once the room has been added to the
+     * @param roomId - The room ID to peek into.
+     * @returns A promise which resolves once the room has been added to the
      * store.
      */
     public async peek(_roomId: string): Promise<Room> {
@@ -485,8 +485,7 @@ export class SlidingSyncSdk {
 
     /**
      * Returns the current state of this sync object
-     * @see module:client~MatrixClient#event:"sync"
-     * @return {?String}
+     * @see MatrixClient#event:"sync"
      */
     public getSyncState(): SyncState | null {
         return this.syncState;
@@ -498,7 +497,6 @@ export class SlidingSyncSdk {
      * such data.
      * Sync errors, if available, are put in the 'error' key of
      * this object.
-     * @return {?Object}
      */
     public getSyncStateData(): ISyncStateData | null {
         return this.syncStateData ?? null;
@@ -765,12 +763,11 @@ export class SlidingSyncSdk {
 
     /**
      * Injects events into a room's model.
-     * @param {Room} room
-     * @param {MatrixEvent[]} stateEventList A list of state events. This is the state
+     * @param stateEventList - A list of state events. This is the state
      * at the *START* of the timeline list if it is supplied.
-     * @param {MatrixEvent[]} [timelineEventList] A list of timeline events. Lower index
+     * @param timelineEventList - A list of timeline events. Lower index
      * is earlier in time. Higher index is later.
-     * @param {number} numLive the number of events in timelineEventList which just happened,
+     * @param numLive - the number of events in timelineEventList which just happened,
      * supplied from the server.
      */
     public injectRoomEvents(
@@ -933,8 +930,8 @@ export class SlidingSyncSdk {
 
     /**
      * Sets the sync state and emits an event to say so
-     * @param {String} newState The new state string
-     * @param {Object} data Object of additional data to emit in the event
+     * @param newState - The new state string
+     * @param data - Object of additional data to emit in the event
      */
     private updateSyncState(newState: SyncState, data?: ISyncStateData): void {
         const old = this.syncState;
@@ -948,7 +945,7 @@ export class SlidingSyncSdk {
      * as appropriate.
      * This must be called after the room the events belong to has been stored.
      *
-     * @param {MatrixEvent[]} [timelineEventList] A list of timeline events. Lower index
+     * @param timelineEventList - A list of timeline events. Lower index
      * is earlier in time. Higher index is later.
      */
     private addNotifications(timelineEventList: MatrixEvent[]): void {
diff --git a/src/sliding-sync.ts b/src/sliding-sync.ts
index a3daf3af6bf..81a67f05e15 100644
--- a/src/sliding-sync.ts
+++ b/src/sliding-sync.ts
@@ -156,7 +156,7 @@ export enum SlidingSyncState {
 
 /**
  * Internal Class. SlidingList represents a single list in sliding sync. The list can have filters,
- * multiple sliding windows, and maintains the index->room_id mapping.
+ * multiple sliding windows, and maintains the index-\>room_id mapping.
  */
 class SlidingList {
     private list!: MSC3575List;
@@ -168,7 +168,7 @@ class SlidingList {
 
     /**
      * Construct a new sliding list.
-     * @param {MSC3575List} list The range, sort and filter values to use for this list.
+     * @param list - The range, sort and filter values to use for this list.
      */
     public constructor(list: MSC3575List) {
         this.replaceList(list);
@@ -177,7 +177,7 @@ class SlidingList {
     /**
      * Mark this list as modified or not. Modified lists will return sticky params with calls to getList.
      * This is useful for the first time the list is sent, or if the list has changed in some way.
-     * @param modified True to mark this list as modified so all sticky parameters will be re-sent.
+     * @param modified - True to mark this list as modified so all sticky parameters will be re-sent.
      */
     public setModified(modified: boolean): void {
         this.isModified = modified;
@@ -185,7 +185,7 @@ class SlidingList {
 
     /**
      * Update the list range for this list. Does not affect modified status as list ranges are non-sticky.
-     * @param newRanges The new ranges for the list
+     * @param newRanges - The new ranges for the list
      */
     public updateListRange(newRanges: number[][]): void {
         this.list.ranges = JSON.parse(JSON.stringify(newRanges));
@@ -193,7 +193,7 @@ class SlidingList {
 
     /**
      * Replace list parameters. All fields will be replaced with the new list parameters.
-     * @param list The new list parameters
+     * @param list - The new list parameters
      */
     public replaceList(list: MSC3575List): void {
         list.filters = list.filters || {};
@@ -213,7 +213,7 @@ class SlidingList {
 
     /**
      * Return a copy of the list suitable for a request body.
-     * @param {boolean} forceIncludeAllParams True to forcibly include all params even if the list
+     * @param forceIncludeAllParams - True to forcibly include all params even if the list
      * hasn't been modified. Callers may want to do this if they are modifying the list prior to calling
      * updateList.
      */
@@ -235,7 +235,7 @@ class SlidingList {
      *   a b c       d _ f   COMMAND: DELETE 7;
      *   e a b c       d f   COMMAND: INSERT 0 e;
      *   c=3 is wrong as we are not tracking it, ergo we need to see if `i` is in range else drop it
-     * @param i The index to check
+     * @param i - The index to check
      * @returns True if the index is within a sliding window
      */
     public isIndexInRange(i: number): boolean {
@@ -274,13 +274,13 @@ export interface Extension<Req extends {}, Res extends {}> {
     /**
      * A function which is called when the request JSON is being formed.
      * Returns the data to insert under this key.
-     * @param isInitial True when this is part of the initial request (send sticky params)
+     * @param isInitial - True when this is part of the initial request (send sticky params)
      * @returns The request JSON to send.
      */
     onRequest(isInitial: boolean): Req | undefined;
     /**
      * A function which is called when there is response JSON under this extension.
-     * @param data The response JSON under the extension name.
+     * @param data - The response JSON under the extension name.
      */
     onResponse(data: Res): void;
     /**
@@ -368,11 +368,11 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
 
     /**
      * Create a new sliding sync instance
-     * @param {string} proxyBaseUrl The base URL of the sliding sync proxy
-     * @param {MSC3575List[]} lists The lists to use for sliding sync.
-     * @param {MSC3575RoomSubscription} roomSubscriptionInfo The params to use for room subscriptions.
-     * @param {MatrixClient} client The client to use for /sync calls.
-     * @param {number} timeoutMS The number of milliseconds to wait for a response.
+     * @param proxyBaseUrl - The base URL of the sliding sync proxy
+     * @param lists - The lists to use for sliding sync.
+     * @param roomSubscriptionInfo - The params to use for room subscriptions.
+     * @param client - The client to use for /sync calls.
+     * @param timeoutMS - The number of milliseconds to wait for a response.
      */
     public constructor(
         private readonly proxyBaseUrl: string,
@@ -388,9 +388,9 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     /**
      * Add a custom room subscription, referred to by an arbitrary name. If a subscription with this
      * name already exists, it is replaced. No requests are sent by calling this method.
-     * @param name The name of the subscription. Only used to reference this subscription in
+     * @param name - The name of the subscription. Only used to reference this subscription in
      * useCustomSubscription.
-     * @param sub The subscription information.
+     * @param sub - The subscription information.
      */
     public addCustomSubscription(name: string, sub: MSC3575RoomSubscription): void {
         this.customSubscriptions.set(name, sub);
@@ -399,8 +399,8 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     /**
      * Use a custom subscription previously added via addCustomSubscription. No requests are sent
      * by calling this method. Use modifyRoomSubscriptions to resend subscription information.
-     * @param roomId The room to use the subscription in.
-     * @param name The name of the subscription. If this name is unknown, the default subscription
+     * @param roomId - The room to use the subscription in.
+     * @param name - The name of the subscription. If this name is unknown, the default subscription
      * will be used.
      */
     public useCustomSubscription(roomId: string, name: string): void {
@@ -419,7 +419,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
 
     /**
      * Get the room data for a list.
-     * @param index The list index
+     * @param index - The list index
      * @returns The list data which contains the rooms in this list
      */
     public getListData(index: number): {joinedCount: number, roomIndexToRoomId: Record<number, string>} | null {
@@ -435,7 +435,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     /**
      * Get the full list parameters for a list index. This function is provided for callers to use
      * in conjunction with setList to update fields on an existing list.
-     * @param index The list index to get the list for.
+     * @param index - The list index to get the list for.
      * @returns A copy of the list or undefined.
      */
     public getList(index: number): MSC3575List | null {
@@ -449,9 +449,9 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
      * Set new ranges for an existing list. Calling this function when _only_ the ranges have changed
      * is more efficient than calling setList(index,list) as this function won't resend sticky params,
      * whereas setList always will.
-     * @param index The list index to modify
-     * @param ranges The new ranges to apply.
-     * @return A promise which resolves to the transaction ID when it has been received down sync
+     * @param index - The list index to modify
+     * @param ranges - The new ranges to apply.
+     * @returns A promise which resolves to the transaction ID when it has been received down sync
      * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled
      * immediately after sending, in which case the action will be applied in the subsequent request)
      */
@@ -463,9 +463,9 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     /**
      * Add or replace a list. Calling this function will interrupt the /sync request to resend new
      * lists.
-     * @param index The index to modify
-     * @param list The new list parameters.
-     * @return A promise which resolves to the transaction ID when it has been received down sync
+     * @param index - The index to modify
+     * @param list - The new list parameters.
+     * @returns A promise which resolves to the transaction ID when it has been received down sync
      * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled
      * immediately after sending, in which case the action will be applied in the subsequent request)
      */
@@ -491,8 +491,8 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
      * Modify the room subscriptions for the sync API. Calling this function will interrupt the
      * /sync request to resend new subscriptions. If the /sync stream has not started, this will
      * prepare the room subscriptions for when start() is called.
-     * @param s The new desired room subscriptions.
-     * @return A promise which resolves to the transaction ID when it has been received down sync
+     * @param s - The new desired room subscriptions.
+     * @returns A promise which resolves to the transaction ID when it has been received down sync
      * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled
      * immediately after sending, in which case the action will be applied in the subsequent request)
      */
@@ -504,8 +504,8 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     /**
      * Modify which events to retrieve for room subscriptions. Invalidates all room subscriptions
      * such that they will be sent up afresh.
-     * @param rs The new room subscription fields to fetch.
-     * @return A promise which resolves to the transaction ID when it has been received down sync
+     * @param rs - The new room subscription fields to fetch.
+     * @returns A promise which resolves to the transaction ID when it has been received down sync
      * (or rejects with the transaction ID if the action was not applied e.g the request was cancelled
      * immediately after sending, in which case the action will be applied in the subsequent request)
      */
@@ -517,7 +517,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
 
     /**
      * Register an extension to send with the /sync request.
-     * @param ext The extension to register.
+     * @param ext - The extension to register.
      */
     public registerExtension(ext: Extension<any, any>): void {
         if (this.extensions[ext.name()]) {
@@ -552,8 +552,8 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
 
     /**
      * Invoke all attached room data listeners.
-     * @param {string} roomId The room which received some data.
-     * @param {object} roomData The raw sliding sync response JSON.
+     * @param roomId - The room which received some data.
+     * @param roomData - The raw sliding sync response JSON.
      */
     private invokeRoomDataListeners(roomId: string, roomData: MSC3575RoomData): void {
         if (!roomData.required_state) { roomData.required_state = []; }
@@ -563,9 +563,9 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
 
     /**
      * Invoke all attached lifecycle listeners.
-     * @param {SlidingSyncState} state The Lifecycle state
-     * @param {object} resp The raw sync response JSON
-     * @param {Error?} err Any error that occurred when making the request e.g. network errors.
+     * @param state - The Lifecycle state
+     * @param resp - The raw sync response JSON
+     * @param err - Any error that occurred when making the request e.g. network errors.
      */
     private invokeLifecycleListeners(
         state: SlidingSyncState,
diff --git a/src/store/index.ts b/src/store/index.ts
index 3edba926977..faf844f22d7 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -42,141 +42,133 @@ export interface IStore {
     // for when it falls back to being a memory store due to errors.
     on?: (event: EventEmitterEvents | "degraded", handler: (...args: any[]) => void) => void;
 
-    /** @return {Promise<boolean>} whether or not the database was newly created in this session. */
+    /** @returns whether or not the database was newly created in this session. */
     isNewlyCreated(): Promise<boolean>;
 
     /**
      * Get the sync token.
-     * @return {string}
      */
     getSyncToken(): string | null;
 
     /**
      * Set the sync token.
-     * @param {string} token
      */
     setSyncToken(token: string): void;
 
     /**
      * Store the given room.
-     * @param {Room} room The room to be stored. All properties must be stored.
+     * @param room - The room to be stored. All properties must be stored.
      */
     storeRoom(room: Room): void;
 
     /**
      * Retrieve a room by its' room ID.
-     * @param {string} roomId The room ID.
-     * @return {Room} The room or null.
+     * @param roomId - The room ID.
+     * @returns The room or null.
      */
     getRoom(roomId: string): Room | null;
 
     /**
      * Retrieve all known rooms.
-     * @return {Room[]} A list of rooms, which may be empty.
+     * @returns A list of rooms, which may be empty.
      */
     getRooms(): Room[];
 
     /**
      * Permanently delete a room.
-     * @param {string} roomId
      */
     removeRoom(roomId: string): void;
 
     /**
      * Retrieve a summary of all the rooms.
-     * @return {RoomSummary[]} A summary of each room.
+     * @returns A summary of each room.
      */
     getRoomSummaries(): RoomSummary[];
 
     /**
      * Store a User.
-     * @param {User} user The user to store.
+     * @param user - The user to store.
      */
     storeUser(user: User): void;
 
     /**
      * Retrieve a User by its' user ID.
-     * @param {string} userId The user ID.
-     * @return {User} The user or null.
+     * @param userId - The user ID.
+     * @returns The user or null.
      */
     getUser(userId: string): User | null;
 
     /**
      * Retrieve all known users.
-     * @return {User[]} A list of users, which may be empty.
+     * @returns A list of users, which may be empty.
      */
     getUsers(): User[];
 
     /**
      * Retrieve scrollback for this room.
-     * @param {Room} room The matrix room
-     * @param {number} limit The max number of old events to retrieve.
-     * @return {Array<Object>} An array of objects which will be at most 'limit'
+     * @param room - The matrix room
+     * @param limit - The max number of old events to retrieve.
+     * @returns An array of objects which will be at most 'limit'
      * length and at least 0. The objects are the raw event JSON.
      */
     scrollback(room: Room, limit: number): MatrixEvent[];
 
     /**
      * Store events for a room.
-     * @param {Room} room The room to store events for.
-     * @param {Array<MatrixEvent>} events The events to store.
-     * @param {string} token The token associated with these events.
-     * @param {boolean} toStart True if these are paginated results.
+     * @param room - The room to store events for.
+     * @param events - The events to store.
+     * @param token - The token associated with these events.
+     * @param toStart - True if these are paginated results.
      */
     storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void;
 
     /**
      * Store a filter.
-     * @param {Filter} filter
      */
     storeFilter(filter: Filter): void;
 
     /**
      * Retrieve a filter.
-     * @param {string} userId
-     * @param {string} filterId
-     * @return {?Filter} A filter or null.
+     * @returns A filter or null.
      */
     getFilter(userId: string, filterId: string): Filter | null;
 
     /**
      * Retrieve a filter ID with the given name.
-     * @param {string} filterName The filter name.
-     * @return {?string} The filter ID or null.
+     * @param filterName - The filter name.
+     * @returns The filter ID or null.
      */
     getFilterIdByName(filterName: string): string | null;
 
     /**
      * Set a filter name to ID mapping.
-     * @param {string} filterName
-     * @param {string} filterId
      */
     setFilterIdByName(filterName: string, filterId?: string): void;
 
     /**
      * Store user-scoped account data events
-     * @param {Array<MatrixEvent>} events The events to store.
+     * @param events - The events to store.
      */
     storeAccountDataEvents(events: MatrixEvent[]): void;
 
     /**
      * Get account data event by event type
-     * @param {string} eventType The event type being queried
+     * @param eventType - The event type being queried
      */
     getAccountData(eventType: EventType | string): MatrixEvent | undefined;
 
     /**
      * setSyncData does nothing as there is no backing data store.
      *
-     * @param {Object} syncData The sync data
-     * @return {Promise} An immediately resolved promise.
+     * @param syncData - The sync data
+     * @returns An immediately resolved promise.
      */
     setSyncData(syncData: ISyncResponse): Promise<void>;
 
     /**
      * We never want to save because we have nothing to save to.
      *
-     * @return {boolean} If the store wants to save
+     * @returns If the store wants to save
      */
     wantsSave(): boolean;
 
@@ -187,19 +179,19 @@ export interface IStore {
 
     /**
      * Startup does nothing.
-     * @return {Promise} An immediately resolved promise.
+     * @returns An immediately resolved promise.
      */
     startup(): Promise<void>;
 
     /**
-     * @return {Promise} Resolves with a sync response to restore the
+     * @returns Promise which resolves with a sync response to restore the
      * client state to where it was at the last save, or null if there
      * is no saved sync data.
      */
     getSavedSync(): Promise<ISavedSync | null>;
 
     /**
-     * @return {Promise} If there is a saved sync, the nextBatch token
+     * @returns If there is a saved sync, the nextBatch token
      * for this sync, otherwise null.
      */
     getSavedSyncToken(): Promise<string | null>;
@@ -207,16 +199,15 @@ export interface IStore {
     /**
      * Delete all data from this store. Does nothing since this store
      * doesn't store anything.
-     * @return {Promise} An immediately resolved promise.
+     * @returns An immediately resolved promise.
      */
     deleteAllData(): Promise<void>;
 
     /**
      * Returns the out-of-band membership events for this room that
      * were previously loaded.
-     * @param {string} roomId
-     * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
-     * @returns {null} in case the members for this room haven't been stored yet
+     * @returns the events, potentially an empty array if OOB loading didn't yield any new members
+     * @returns in case the members for this room haven't been stored yet
      */
     getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null>;
 
@@ -224,9 +215,8 @@ export interface IStore {
      * Stores the out-of-band membership events for this room. Note that
      * it still makes sense to store an empty array as the OOB status for the room is
      * marked as fetched, and getOutOfBandMembers will return an empty array instead of null
-     * @param {string} roomId
-     * @param {event[]} membershipEvents the membership events to store
-     * @returns {Promise} when all members have been stored
+     * @param membershipEvents - the membership events to store
+     * @returns when all members have been stored
      */
     setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void>;
 
diff --git a/src/store/indexeddb-local-backend.ts b/src/store/indexeddb-local-backend.ts
index 2b94af25600..fe61f11df37 100644
--- a/src/store/indexeddb-local-backend.ts
+++ b/src/store/indexeddb-local-backend.ts
@@ -51,12 +51,12 @@ const VERSION = DB_MIGRATIONS.length;
 
 /**
  * Helper method to collect results from a Cursor and promiseify it.
- * @param {ObjectStore|Index} store The store to perform openCursor on.
- * @param {IDBKeyRange=} keyRange Optional key range to apply on the cursor.
- * @param {Function} resultMapper A function which is repeatedly called with a
+ * @param store - The store to perform openCursor on.
+ * @param keyRange - Optional key range to apply on the cursor.
+ * @param resultMapper - A function which is repeatedly called with a
  * Cursor.
  * Return the data you want to keep.
- * @return {Promise<T[]>} Resolves to an array of whatever you returned from
+ * @returns Promise which resolves to an array of whatever you returned from
  * resultMapper.
  */
 function selectQuery<T>(
@@ -134,11 +134,10 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * Does the actual reading from and writing to the indexeddb
      *
      * Construct a new Indexed Database store backend. This requires a call to
-     * <code>connect()</code> before this store can be used.
-     * @constructor
-     * @param {Object} indexedDB The Indexed DB interface e.g
-     * <code>window.indexedDB</code>
-     * @param {string=} dbName Optional database name. The same name must be used
+     * `connect()` before this store can be used.
+     * @param indexedDB - The Indexed DB interface e.g
+     * `window.indexedDB`
+     * @param dbName - Optional database name. The same name must be used
      * to open the same database.
      */
     public constructor(private readonly indexedDB: IDBFactory, dbName = "default") {
@@ -149,7 +148,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
     /**
      * Attempt to connect to the database. This can fail if the user does not
      * grant permission.
-     * @return {Promise} Resolves if successfully connected.
+     * @returns Promise which resolves if successfully connected.
      */
     public connect(): Promise<void> {
         if (!this.disconnected) {
@@ -195,14 +194,14 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
         });
     }
 
-    /** @return {boolean} whether or not the database was newly created in this session. */
+    /** @returns whether or not the database was newly created in this session. */
     public isNewlyCreated(): Promise<boolean> {
         return Promise.resolve(this._isNewlyCreated);
     }
 
     /**
      * Having connected, load initial data from the database and prepare for use
-     * @return {Promise} Resolves on success
+     * @returns Promise which resolves on success
      */
     private init(): Promise<unknown> {
         return Promise.all([
@@ -223,9 +222,8 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
     /**
      * Returns the out-of-band membership events for this room that
      * were previously loaded.
-     * @param {string} roomId
-     * @returns {Promise<event[]>} the events, potentially an empty array if OOB loading didn't yield any new members
-     * @returns {null} in case the members for this room haven't been stored yet
+     * @returns the events, potentially an empty array if OOB loading didn't yield any new members
+     * @returns in case the members for this room haven't been stored yet
      */
     public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
         return new Promise<IStateEventWithRoomId[] | null>((resolve, reject) => {
@@ -273,8 +271,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * Stores the out-of-band membership events for this room. Note that
      * it still makes sense to store an empty array as the OOB status for the room is
      * marked as fetched, and getOutOfBandMembers will return an empty array instead of null
-     * @param {string} roomId
-     * @param {event[]} membershipEvents the membership events to store
+     * @param membershipEvents - the membership events to store
      */
     public async setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
         logger.log(`LL: backend about to store ${membershipEvents.length}` +
@@ -339,7 +336,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
     /**
      * Clear the entire database. This should be used when logging out of a client
      * to prevent mixing data between accounts.
-     * @return {Promise} Resolved when the database is cleared.
+     * @returns Resolved when the database is cleared.
      */
     public clearDatabase(): Promise<void> {
         return new Promise((resolve) => {
@@ -366,11 +363,11 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
     }
 
     /**
-     * @param {boolean=} copy If false, the data returned is from internal
+     * @param copy - If false, the data returned is from internal
      * buffers and must not be mutated. Otherwise, a copy is made before
      * returning such that the data can be safely mutated. Default: true.
      *
-     * @return {Promise} Resolves with a sync response to restore the
+     * @returns Promise which resolves with a sync response to restore the
      * client state to where it was at the last save, or null if there
      * is no saved sync data.
      */
@@ -421,9 +418,9 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
 
     /**
      * Persist rooms /sync data along with the next batch token.
-     * @param {string} nextBatch The next_batch /sync value.
-     * @param {Object} roomsData The 'rooms' /sync data from a SyncAccumulator
-     * @return {Promise} Resolves if the data was persisted.
+     * @param nextBatch - The next_batch /sync value.
+     * @param roomsData - The 'rooms' /sync data from a SyncAccumulator
+     * @returns Promise which resolves if the data was persisted.
      */
     private persistSyncData(
         nextBatch: string,
@@ -447,8 +444,8 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
     /**
      * Persist a list of account data events. Events with the same 'type' will
      * be replaced.
-     * @param {Object[]} accountData An array of raw user-scoped account data events
-     * @return {Promise} Resolves if the events were persisted.
+     * @param accountData - An array of raw user-scoped account data events
+     * @returns Promise which resolves if the events were persisted.
      */
     private persistAccountData(accountData: IMinimalEvent[]): Promise<void> {
         return utils.promiseTry<void>(() => {
@@ -466,8 +463,8 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * Users with the same 'userId' will be replaced.
      * Presence events should be the event in its raw form (not the Event
      * object)
-     * @param {Object[]} tuples An array of [userid, event] tuples
-     * @return {Promise} Resolves if the users were persisted.
+     * @param tuples - An array of [userid, event] tuples
+     * @returns Promise which resolves if the users were persisted.
      */
     private persistUserPresenceEvents(tuples: UserTuple[]): Promise<void> {
         return utils.promiseTry<void>(() => {
@@ -487,7 +484,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * Load all user presence events from the database. This is not cached.
      * FIXME: It would probably be more sensible to store the events in the
      * sync.
-     * @return {Promise<Object[]>} A list of presence events in their raw form.
+     * @returns A list of presence events in their raw form.
      */
     public getUserPresenceEvents(): Promise<UserTuple[]> {
         return utils.promiseTry<UserTuple[]>(() => {
@@ -501,7 +498,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
 
     /**
      * Load all the account data events from the database. This is not cached.
-     * @return {Promise<Object[]>} A list of raw global account events.
+     * @returns A list of raw global account events.
      */
     private loadAccountData(): Promise<IMinimalEvent[]> {
         logger.log(`LocalIndexedDBStoreBackend: loading account data...`);
@@ -519,7 +516,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
 
     /**
      * Load the sync data from the database.
-     * @return {Promise<Object>} An object with "roomsData" and "nextBatch" keys.
+     * @returns An object with "roomsData" and "nextBatch" keys.
      */
     private loadSyncData(): Promise<ISyncData> {
         logger.log(`LocalIndexedDBStoreBackend: loading sync data...`);
diff --git a/src/store/indexeddb-remote-backend.ts b/src/store/indexeddb-remote-backend.ts
index 1ca6fc03a38..05909b0e3f5 100644
--- a/src/store/indexeddb-remote-backend.ts
+++ b/src/store/indexeddb-remote-backend.ts
@@ -36,10 +36,9 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * worker.
      *
      * Construct a new Indexed Database store backend. This requires a call to
-     * <code>connect()</code> before this store can be used.
-     * @constructor
-     * @param {Function} workerFactory Factory which produces a Worker
-     * @param {string=} dbName Optional database name. The same name must be used
+     * `connect()` before this store can be used.
+     * @param workerFactory - Factory which produces a Worker
+     * @param dbName - Optional database name. The same name must be used
      * to open the same database.
      */
     public constructor(
@@ -50,7 +49,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     /**
      * Attempt to connect to the database. This can fail if the user does not
      * grant permission.
-     * @return {Promise} Resolves if successfully connected.
+     * @returns Promise which resolves if successfully connected.
      */
     public connect(): Promise<void> {
         return this.ensureStarted().then(() => this.doCmd('connect'));
@@ -59,19 +58,19 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     /**
      * Clear the entire database. This should be used when logging out of a client
      * to prevent mixing data between accounts.
-     * @return {Promise} Resolved when the database is cleared.
+     * @returns Resolved when the database is cleared.
      */
     public clearDatabase(): Promise<void> {
         return this.ensureStarted().then(() => this.doCmd('clearDatabase'));
     }
 
-    /** @return {Promise<boolean>} whether or not the database was newly created in this session. */
+    /** @returns whether or not the database was newly created in this session. */
     public isNewlyCreated(): Promise<boolean> {
         return this.doCmd('isNewlyCreated');
     }
 
     /**
-     * @return {Promise} Resolves with a sync response to restore the
+     * @returns Promise which resolves with a sync response to restore the
      * client state to where it was at the last save, or null if there
      * is no saved sync data.
      */
@@ -94,9 +93,8 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     /**
      * Returns the out-of-band membership events for this room that
      * were previously loaded.
-     * @param {string} roomId
-     * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
-     * @returns {null} in case the members for this room haven't been stored yet
+     * @returns the events, potentially an empty array if OOB loading didn't yield any new members
+     * @returns in case the members for this room haven't been stored yet
      */
     public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
         return this.doCmd('getOutOfBandMembers', [roomId]);
@@ -106,9 +104,8 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * Stores the out-of-band membership events for this room. Note that
      * it still makes sense to store an empty array as the OOB status for the room is
      * marked as fetched, and getOutOfBandMembers will return an empty array instead of null
-     * @param {string} roomId
-     * @param {event[]} membershipEvents the membership events to store
-     * @returns {Promise} when all members have been stored
+     * @param membershipEvents - the membership events to store
+     * @returns when all members have been stored
      */
     public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
         return this.doCmd('setOutOfBandMembers', [roomId, membershipEvents]);
@@ -128,7 +125,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
 
     /**
      * Load all user presence events from the database. This is not cached.
-     * @return {Promise<Object[]>} A list of presence events in their raw form.
+     * @returns A list of presence events in their raw form.
      */
     public getUserPresenceEvents(): Promise<UserTuple[]> {
         return this.doCmd('getUserPresenceEvents');
diff --git a/src/store/indexeddb-store-worker.ts b/src/store/indexeddb-store-worker.ts
index 57e7da983be..a9bc2abcd07 100644
--- a/src/store/indexeddb-store-worker.ts
+++ b/src/store/indexeddb-store-worker.ts
@@ -27,12 +27,14 @@ interface ICmd {
  * This class lives in the webworker and drives a LocalIndexedDBStoreBackend
  * controlled by messages from the main process.
  *
+ * @example
  * It should be instantiated by a web worker script provided by the application
  * in a script, for example:
- *
+ * ```
  * import {IndexedDBStoreWorker} from 'matrix-js-sdk/lib/indexeddb-worker.js';
  * const remoteWorker = new IndexedDBStoreWorker(postMessage);
  * onmessage = remoteWorker.onMessage;
+ * ```
  *
  * Note that it is advisable to import this class by referencing the file directly to
  * avoid a dependency on the whole js-sdk.
@@ -42,7 +44,7 @@ export class IndexedDBStoreWorker {
     private backend?: LocalIndexedDBStoreBackend;
 
     /**
-     * @param {function} postMessage The web worker postMessage function that
+     * @param postMessage - The web worker postMessage function that
      * should be used to communicate back to the main script.
      */
     public constructor(private readonly postMessage: InstanceType<typeof Worker>["postMessage"]) {}
@@ -51,7 +53,7 @@ export class IndexedDBStoreWorker {
      * Passes a message event from the main script into the class. This method
      * can be directly assigned to the web worker `onmessage` variable.
      *
-     * @param {Object} ev The message event
+     * @param ev - The message event
      */
     public onMessage = (ev: MessageEvent): void => {
         const msg: ICmd = ev.data;
diff --git a/src/store/indexeddb.ts b/src/store/indexeddb.ts
index 55f8261faa8..656049f2b27 100644
--- a/src/store/indexeddb.ts
+++ b/src/store/indexeddb.ts
@@ -32,7 +32,6 @@ import { IStoredClientOpts } from "../client";
 
 /**
  * This is an internal module. See {@link IndexedDBStore} for the public class.
- * @module store/indexeddb
  */
 
 // If this value is too small we'll be writing very often which will cause
@@ -43,8 +42,11 @@ import { IStoredClientOpts } from "../client";
 const WRITE_DELAY_MS = 1000 * 60 * 5; // once every 5 minutes
 
 interface IOpts extends IBaseOpts {
+    /** The Indexed DB interface e.g. `window.indexedDB` */
     indexedDB: IDBFactory;
+    /** Optional database name. The same name must be used to open the same database. */
     dbName?: string;
+    /** Optional factory to spin up a Worker to execute the IDB transactions within. */
     workerFactory?: () => Worker;
 }
 
@@ -57,6 +59,10 @@ export class IndexedDBStore extends MemoryStore {
         return LocalIndexedDBStoreBackend.exists(indexedDB, dbName);
     }
 
+    /**
+     * The backend instance.
+     * Call through to this API if you need to perform specific indexeddb actions like deleting the database.
+     */
     public readonly backend: IIndexedDBBackend;
 
     private startedUp = false;
@@ -74,10 +80,10 @@ export class IndexedDBStore extends MemoryStore {
      * the contents of the store to an IndexedDB backend.
      *
      * All data is still kept in-memory but can be loaded from disk by calling
-     * <code>startup()</code>. This can make startup times quicker as a complete
+     * `startup()`. This can make startup times quicker as a complete
      * sync from the server is not required. This does not reduce memory usage as all
-     * the data is eagerly fetched when <code>startup()</code> is called.
-     * <pre>
+     * the data is eagerly fetched when `startup()` is called.
+     * ```
      * let opts = { indexedDB: window.indexedDB, localStorage: window.localStorage };
      * let store = new IndexedDBStore(opts);
      * await store.startup(); // load from indexed db
@@ -90,24 +96,9 @@ export class IndexedDBStore extends MemoryStore {
      *         console.log("Started up, now with go faster stripes!");
      *     }
      * });
-     * </pre>
+     * ```
      *
-     * @constructor
-     * @extends MemoryStore
-     * @param {Object} opts Options object.
-     * @param {Object} opts.indexedDB The Indexed DB interface e.g.
-     * <code>window.indexedDB</code>
-     * @param {string=} opts.dbName Optional database name. The same name must be used
-     * to open the same database.
-     * @param {string=} opts.workerScript Optional URL to a script to invoke a web
-     * worker with to run IndexedDB queries on the web worker. The IndexedDbStoreWorker
-     * class is provided for this purpose and requires the application to provide a
-     * trivial wrapper script around it.
-     * @param {Object=} opts.workerApi The webWorker API object. If omitted, the global Worker
-     * object will be used if it exists.
-     * @prop {IndexedDBStoreBackend} backend The backend instance. Call through to
-     * this API if you need to perform specific indexeddb actions like deleting the
-     * database.
+     * @param opts - Options object.
      */
     public constructor(opts: IOpts) {
         super(opts);
@@ -126,7 +117,7 @@ export class IndexedDBStore extends MemoryStore {
     public on = this.emitter.on.bind(this.emitter);
 
     /**
-     * @return {Promise} Resolved when loaded from indexed db.
+     * @returns Resolved when loaded from indexed db.
      */
     public startup(): Promise<void> {
         if (this.startedUp) {
@@ -152,7 +143,7 @@ export class IndexedDBStore extends MemoryStore {
     }
 
     /**
-     * @return {Promise} Resolves with a sync response to restore the
+     * @returns Promise which resolves with a sync response to restore the
      * client state to where it was at the last save, or null if there
      * is no saved sync data.
      */
@@ -160,13 +151,13 @@ export class IndexedDBStore extends MemoryStore {
         return this.backend.getSavedSync();
     }, "getSavedSync");
 
-    /** @return {Promise<boolean>} whether or not the database was newly created in this session. */
+    /** @returns whether or not the database was newly created in this session. */
     public isNewlyCreated = this.degradable((): Promise<boolean> => {
         return this.backend.isNewlyCreated();
     }, "isNewlyCreated");
 
     /**
-     * @return {Promise} If there is a saved sync, the nextBatch token
+     * @returns If there is a saved sync, the nextBatch token
      * for this sync, otherwise null.
      */
     public getSavedSyncToken = this.degradable((): Promise<string | null> => {
@@ -175,7 +166,7 @@ export class IndexedDBStore extends MemoryStore {
 
     /**
      * Delete all data from this store.
-     * @return {Promise} Resolves if the data was deleted from the database.
+     * @returns Promise which resolves if the data was deleted from the database.
      */
     public deleteAllData = this.degradable((): Promise<void> => {
         super.deleteAllData();
@@ -193,7 +184,7 @@ export class IndexedDBStore extends MemoryStore {
      * not could change between calling this function and calling
      * save().
      *
-     * @return {boolean} True if calling save() will actually save
+     * @returns True if calling save() will actually save
      *     (at the time this function is called).
      */
     public wantsSave(): boolean {
@@ -204,8 +195,8 @@ export class IndexedDBStore extends MemoryStore {
     /**
      * Possibly write data to the database.
      *
-     * @param {boolean} force True to force a save to happen
-     * @return {Promise} Promise resolves after the write completes
+     * @param force - True to force a save to happen
+     * @returns Promise resolves after the write completes
      *     (or immediately if no write is performed)
      */
     public save(force = false): Promise<void> {
@@ -241,9 +232,8 @@ export class IndexedDBStore extends MemoryStore {
     /**
      * Returns the out-of-band membership events for this room that
      * were previously loaded.
-     * @param {string} roomId
-     * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
-     * @returns {null} in case the members for this room haven't been stored yet
+     * @returns the events, potentially an empty array if OOB loading didn't yield any new members
+     * @returns in case the members for this room haven't been stored yet
      */
     public getOutOfBandMembers = this.degradable((roomId: string): Promise<IStateEventWithRoomId[] | null> => {
         return this.backend.getOutOfBandMembers(roomId);
@@ -253,9 +243,8 @@ export class IndexedDBStore extends MemoryStore {
      * Stores the out-of-band membership events for this room. Note that
      * it still makes sense to store an empty array as the OOB status for the room is
      * marked as fetched, and getOutOfBandMembers will return an empty array instead of null
-     * @param {string} roomId
-     * @param {event[]} membershipEvents the membership events to store
-     * @returns {Promise} when all members have been stored
+     * @param membershipEvents - the membership events to store
+     * @returns when all members have been stored
      */
     public setOutOfBandMembers = this.degradable(
         (roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> => {
@@ -287,9 +276,9 @@ export class IndexedDBStore extends MemoryStore {
      * When IndexedDB fails via any of these paths, we degrade this back to a `MemoryStore`
      * in place so that the current operation and all future ones are in-memory only.
      *
-     * @param {Function} func The degradable work to do.
-     * @param {String} fallback The method name for fallback.
-     * @returns {Function} A wrapped member function.
+     * @param func - The degradable work to do.
+     * @param fallback - The method name for fallback.
+     * @returns A wrapped member function.
      */
     private degradable<A extends Array<any>, R = void>(
         func: DegradableFn<A, R>,
@@ -368,8 +357,8 @@ export class IndexedDBStore extends MemoryStore {
 }
 
 /**
- * @param {string} roomId ID of the current room
- * @returns {string} Storage key to retrieve pending events
+ * @param roomId - ID of the current room
+ * @returns Storage key to retrieve pending events
  */
 function pendingEventsKey(roomId: string): string {
     return `mx_pending_events_${roomId}`;
diff --git a/src/store/memory.ts b/src/store/memory.ts
index 1fcb6b0c865..c698b93955f 100644
--- a/src/store/memory.ts
+++ b/src/store/memory.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * This is an internal module. See {@link MemoryStore} for the public class.
- * @module store/memory
  */
 
 import { EventType } from "../@types/event";
@@ -43,16 +42,10 @@ function isValidFilterId(filterId?: string | number | null): boolean {
 }
 
 export interface IOpts {
+    /** The local storage instance to persist some forms of data such as tokens. Rooms will NOT be stored. */
     localStorage?: Storage;
 }
 
-/**
- * Construct a new in-memory data store for the Matrix Client.
- * @constructor
- * @param {Object=} opts Config options
- * @param {Storage} opts.localStorage The local storage instance to persist
- * some forms of data such as tokens. Rooms will NOT be stored.
- */
 export class MemoryStore implements IStore {
     private rooms: Record<string, Room> = {}; // roomId: Room
     private users: Record<string, User> = {}; // userId: User
@@ -69,26 +62,30 @@ export class MemoryStore implements IStore {
     private pendingToDeviceBatches: IndexedToDeviceBatch[] = [];
     private nextToDeviceBatchId = 0;
 
+    /**
+     * Construct a new in-memory data store for the Matrix Client.
+     * @param opts - Config options
+     */
     public constructor(opts: IOpts = {}) {
         this.localStorage = opts.localStorage;
     }
 
     /**
      * Retrieve the token to stream from.
-     * @return {string} The token or null.
+     * @returns The token or null.
      */
     public getSyncToken(): string | null {
         return this.syncToken;
     }
 
-    /** @return {Promise<boolean>} whether or not the database was newly created in this session. */
+    /** @returns whether or not the database was newly created in this session. */
     public isNewlyCreated(): Promise<boolean> {
         return Promise.resolve(true);
     }
 
     /**
      * Set the token to stream from.
-     * @param {string} token The token to stream from.
+     * @param token - The token to stream from.
      */
     public setSyncToken(token: string): void {
         this.syncToken = token;
@@ -96,7 +93,7 @@ export class MemoryStore implements IStore {
 
     /**
      * Store the given room.
-     * @param {Room} room The room to be stored. All properties must be stored.
+     * @param room - The room to be stored. All properties must be stored.
      */
     public storeRoom(room: Room): void {
         this.rooms[room.roomId] = room;
@@ -112,9 +109,6 @@ export class MemoryStore implements IStore {
     /**
      * Called when a room member in a room being tracked by this store has been
      * updated.
-     * @param {MatrixEvent} event
-     * @param {RoomState} state
-     * @param {RoomMember} member
      */
     private onRoomMember = (event: MatrixEvent | null, state: RoomState, member: RoomMember): void => {
         if (member.membership === "invite") {
@@ -138,8 +132,8 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve a room by its' room ID.
-     * @param {string} roomId The room ID.
-     * @return {Room} The room or null.
+     * @param roomId - The room ID.
+     * @returns The room or null.
      */
     public getRoom(roomId: string): Room | null {
         return this.rooms[roomId] || null;
@@ -147,7 +141,7 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve all known rooms.
-     * @return {Room[]} A list of rooms, which may be empty.
+     * @returns A list of rooms, which may be empty.
      */
     public getRooms(): Room[] {
         return Object.values(this.rooms);
@@ -155,7 +149,6 @@ export class MemoryStore implements IStore {
 
     /**
      * Permanently delete a room.
-     * @param {string} roomId
      */
     public removeRoom(roomId: string): void {
         if (this.rooms[roomId]) {
@@ -166,7 +159,7 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve a summary of all the rooms.
-     * @return {RoomSummary[]} A summary of each room.
+     * @returns A summary of each room.
      */
     public getRoomSummaries(): RoomSummary[] {
         return Object.values(this.rooms).map(function(room) {
@@ -176,7 +169,7 @@ export class MemoryStore implements IStore {
 
     /**
      * Store a User.
-     * @param {User} user The user to store.
+     * @param user - The user to store.
      */
     public storeUser(user: User): void {
         this.users[user.userId] = user;
@@ -184,8 +177,8 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve a User by its' user ID.
-     * @param {string} userId The user ID.
-     * @return {User} The user or null.
+     * @param userId - The user ID.
+     * @returns The user or null.
      */
     public getUser(userId: string): User | null {
         return this.users[userId] || null;
@@ -193,7 +186,7 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve all known users.
-     * @return {User[]} A list of users, which may be empty.
+     * @returns A list of users, which may be empty.
      */
     public getUsers(): User[] {
         return Object.values(this.users);
@@ -201,9 +194,9 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve scrollback for this room.
-     * @param {Room} room The matrix room
-     * @param {number} limit The max number of old events to retrieve.
-     * @return {Array<Object>} An array of objects which will be at most 'limit'
+     * @param room - The matrix room
+     * @param limit - The max number of old events to retrieve.
+     * @returns An array of objects which will be at most 'limit'
      * length and at least 0. The objects are the raw event JSON.
      */
     public scrollback(room: Room, limit: number): MatrixEvent[] {
@@ -212,10 +205,10 @@ export class MemoryStore implements IStore {
 
     /**
      * Store events for a room. The events have already been added to the timeline
-     * @param {Room} room The room to store events for.
-     * @param {Array<MatrixEvent>} events The events to store.
-     * @param {string} token The token associated with these events.
-     * @param {boolean} toStart True if these are paginated results.
+     * @param room - The room to store events for.
+     * @param events - The events to store.
+     * @param token - The token associated with these events.
+     * @param toStart - True if these are paginated results.
      */
     public storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void {
         // no-op because they've already been added to the room instance.
@@ -223,7 +216,6 @@ export class MemoryStore implements IStore {
 
     /**
      * Store a filter.
-     * @param {Filter} filter
      */
     public storeFilter(filter: Filter): void {
         if (!filter?.userId || !filter?.filterId) return;
@@ -235,9 +227,7 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve a filter.
-     * @param {string} userId
-     * @param {string} filterId
-     * @return {?Filter} A filter or null.
+     * @returns A filter or null.
      */
     public getFilter(userId: string, filterId: string): Filter | null {
         if (!this.filters[userId] || !this.filters[userId][filterId]) {
@@ -248,8 +238,8 @@ export class MemoryStore implements IStore {
 
     /**
      * Retrieve a filter ID with the given name.
-     * @param {string} filterName The filter name.
-     * @return {?string} The filter ID or null.
+     * @param filterName - The filter name.
+     * @returns The filter ID or null.
      */
     public getFilterIdByName(filterName: string): string | null {
         if (!this.localStorage) {
@@ -272,8 +262,6 @@ export class MemoryStore implements IStore {
 
     /**
      * Set a filter name to ID mapping.
-     * @param {string} filterName
-     * @param {string} filterId
      */
     public setFilterIdByName(filterName: string, filterId?: string): void {
         if (!this.localStorage) {
@@ -293,7 +281,7 @@ export class MemoryStore implements IStore {
      * Store user-scoped account data events.
      * N.B. that account data only allows a single event per type, so multiple
      * events with the same type will replace each other.
-     * @param {Array<MatrixEvent>} events The events to store.
+     * @param events - The events to store.
      */
     public storeAccountDataEvents(events: MatrixEvent[]): void {
         events.forEach((event) => {
@@ -303,8 +291,8 @@ export class MemoryStore implements IStore {
 
     /**
      * Get account data event by event type
-     * @param {string} eventType The event type being queried
-     * @return {?MatrixEvent} the user account_data event of given type, if any
+     * @param eventType - The event type being queried
+     * @returns the user account_data event of given type, if any
      */
     public getAccountData(eventType: EventType | string): MatrixEvent | undefined {
         return this.accountData[eventType];
@@ -313,8 +301,8 @@ export class MemoryStore implements IStore {
     /**
      * setSyncData does nothing as there is no backing data store.
      *
-     * @param {Object} syncData The sync data
-     * @return {Promise} An immediately resolved promise.
+     * @param syncData - The sync data
+     * @returns An immediately resolved promise.
      */
     public setSyncData(syncData: ISyncResponse): Promise<void> {
         return Promise.resolve();
@@ -323,7 +311,7 @@ export class MemoryStore implements IStore {
     /**
      * We never want to save becase we have nothing to save to.
      *
-     * @return {boolean} If the store wants to save
+     * @returns If the store wants to save
      */
     public wantsSave(): boolean {
         return false;
@@ -331,21 +319,21 @@ export class MemoryStore implements IStore {
 
     /**
      * Save does nothing as there is no backing data store.
-     * @param {bool} force True to force a save (but the memory
+     * @param force - True to force a save (but the memory
      *     store still can't save anything)
      */
     public save(force: boolean): void {}
 
     /**
      * Startup does nothing as this store doesn't require starting up.
-     * @return {Promise} An immediately resolved promise.
+     * @returns An immediately resolved promise.
      */
     public startup(): Promise<void> {
         return Promise.resolve();
     }
 
     /**
-     * @return {Promise} Resolves with a sync response to restore the
+     * @returns Promise which resolves with a sync response to restore the
      * client state to where it was at the last save, or null if there
      * is no saved sync data.
      */
@@ -354,7 +342,7 @@ export class MemoryStore implements IStore {
     }
 
     /**
-     * @return {Promise} If there is a saved sync, the nextBatch token
+     * @returns If there is a saved sync, the nextBatch token
      * for this sync, otherwise null.
      */
     public getSavedSyncToken(): Promise<string | null> {
@@ -363,7 +351,7 @@ export class MemoryStore implements IStore {
 
     /**
      * Delete all data from this store.
-     * @return {Promise} An immediately resolved promise.
+     * @returns An immediately resolved promise.
      */
     public deleteAllData(): Promise<void> {
         this.rooms = {
@@ -387,9 +375,8 @@ export class MemoryStore implements IStore {
     /**
      * Returns the out-of-band membership events for this room that
      * were previously loaded.
-     * @param {string} roomId
-     * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
-     * @returns {null} in case the members for this room haven't been stored yet
+     * @returns the events, potentially an empty array if OOB loading didn't yield any new members
+     * @returns in case the members for this room haven't been stored yet
      */
     public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
         return Promise.resolve(this.oobMembers[roomId] || null);
@@ -399,9 +386,8 @@ export class MemoryStore implements IStore {
      * Stores the out-of-band membership events for this room. Note that
      * it still makes sense to store an empty array as the OOB status for the room is
      * marked as fetched, and getOutOfBandMembers will return an empty array instead of null
-     * @param {string} roomId
-     * @param {event[]} membershipEvents the membership events to store
-     * @returns {Promise} when all members have been stored
+     * @param membershipEvents - the membership events to store
+     * @returns when all members have been stored
      */
     public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
         this.oobMembers[roomId] = membershipEvents;
diff --git a/src/store/stub.ts b/src/store/stub.ts
index 74234393879..445f9e8ff27 100644
--- a/src/store/stub.ts
+++ b/src/store/stub.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * This is an internal module.
- * @module store/stub
  */
 
 import { EventType } from "../@types/event";
@@ -33,20 +32,18 @@ import { IStoredClientOpts } from "../client";
 
 /**
  * Construct a stub store. This does no-ops on most store methods.
- * @constructor
  */
 export class StubStore implements IStore {
     public readonly accountData = {}; // stub
     private fromToken: string | null = null;
 
-    /** @return {Promise<boolean>} whether or not the database was newly created in this session. */
+    /** @returns whether or not the database was newly created in this session. */
     public isNewlyCreated(): Promise<boolean> {
         return Promise.resolve(true);
     }
 
     /**
      * Get the sync token.
-     * @return {string}
      */
     public getSyncToken(): string | null {
         return this.fromToken;
@@ -54,7 +51,6 @@ export class StubStore implements IStore {
 
     /**
      * Set the sync token.
-     * @param {string} token
      */
     public setSyncToken(token: string): void {
         this.fromToken = token;
@@ -62,14 +58,11 @@ export class StubStore implements IStore {
 
     /**
      * No-op.
-     * @param {Room} room
      */
     public storeRoom(room: Room): void {}
 
     /**
      * No-op.
-     * @param {string} roomId
-     * @return {null}
      */
     public getRoom(roomId: string): Room | null {
         return null;
@@ -77,7 +70,7 @@ export class StubStore implements IStore {
 
     /**
      * No-op.
-     * @return {Array} An empty array.
+     * @returns An empty array.
      */
     public getRooms(): Room[] {
         return [];
@@ -85,7 +78,6 @@ export class StubStore implements IStore {
 
     /**
      * Permanently delete a room.
-     * @param {string} roomId
      */
     public removeRoom(roomId: string): void {
         return;
@@ -93,7 +85,7 @@ export class StubStore implements IStore {
 
     /**
      * No-op.
-     * @return {Array} An empty array.
+     * @returns An empty array.
      */
     public getRoomSummaries(): RoomSummary[] {
         return [];
@@ -101,14 +93,11 @@ export class StubStore implements IStore {
 
     /**
      * No-op.
-     * @param {User} user
      */
     public storeUser(user: User): void {}
 
     /**
      * No-op.
-     * @param {string} userId
-     * @return {null}
      */
     public getUser(userId: string): User | null {
         return null;
@@ -116,7 +105,6 @@ export class StubStore implements IStore {
 
     /**
      * No-op.
-     * @return {User[]}
      */
     public getUsers(): User[] {
         return [];
@@ -124,9 +112,6 @@ export class StubStore implements IStore {
 
     /**
      * No-op.
-     * @param {Room} room
-     * @param {number} limit
-     * @return {Array}
      */
     public scrollback(room: Room, limit: number): MatrixEvent[] {
         return [];
@@ -134,24 +119,21 @@ export class StubStore implements IStore {
 
     /**
      * Store events for a room.
-     * @param {Room} room The room to store events for.
-     * @param {Array<MatrixEvent>} events The events to store.
-     * @param {string} token The token associated with these events.
-     * @param {boolean} toStart True if these are paginated results.
+     * @param room - The room to store events for.
+     * @param events - The events to store.
+     * @param token - The token associated with these events.
+     * @param toStart - True if these are paginated results.
      */
     public storeEvents(room: Room, events: MatrixEvent[], token: string | null, toStart: boolean): void {}
 
     /**
      * Store a filter.
-     * @param {Filter} filter
      */
     public storeFilter(filter: Filter): void {}
 
     /**
      * Retrieve a filter.
-     * @param {string} userId
-     * @param {string} filterId
-     * @return {?Filter} A filter or null.
+     * @returns A filter or null.
      */
     public getFilter(userId: string, filterId: string): Filter | null {
         return null;
@@ -159,8 +141,8 @@ export class StubStore implements IStore {
 
     /**
      * Retrieve a filter ID with the given name.
-     * @param {string} filterName The filter name.
-     * @return {?string} The filter ID or null.
+     * @param filterName - The filter name.
+     * @returns The filter ID or null.
      */
     public getFilterIdByName(filterName: string): string | null {
         return null;
@@ -168,20 +150,18 @@ export class StubStore implements IStore {
 
     /**
      * Set a filter name to ID mapping.
-     * @param {string} filterName
-     * @param {string} filterId
      */
     public setFilterIdByName(filterName: string, filterId?: string): void {}
 
     /**
      * Store user-scoped account data events
-     * @param {Array<MatrixEvent>} events The events to store.
+     * @param events - The events to store.
      */
     public storeAccountDataEvents(events: MatrixEvent[]): void {}
 
     /**
      * Get account data event by event type
-     * @param {string} eventType The event type being queried
+     * @param eventType - The event type being queried
      */
     public getAccountData(eventType: EventType | string): MatrixEvent | undefined {
         return undefined;
@@ -190,8 +170,8 @@ export class StubStore implements IStore {
     /**
      * setSyncData does nothing as there is no backing data store.
      *
-     * @param {Object} syncData The sync data
-     * @return {Promise} An immediately resolved promise.
+     * @param syncData - The sync data
+     * @returns An immediately resolved promise.
      */
     public setSyncData(syncData: ISyncResponse): Promise<void> {
         return Promise.resolve();
@@ -200,7 +180,7 @@ export class StubStore implements IStore {
     /**
      * We never want to save because we have nothing to save to.
      *
-     * @return {boolean} If the store wants to save
+     * @returns If the store wants to save
      */
     public wantsSave(): boolean {
         return false;
@@ -213,14 +193,14 @@ export class StubStore implements IStore {
 
     /**
      * Startup does nothing.
-     * @return {Promise} An immediately resolved promise.
+     * @returns An immediately resolved promise.
      */
     public startup(): Promise<void> {
         return Promise.resolve();
     }
 
     /**
-     * @return {Promise} Resolves with a sync response to restore the
+     * @returns Promise which resolves with a sync response to restore the
      * client state to where it was at the last save, or null if there
      * is no saved sync data.
      */
@@ -229,7 +209,7 @@ export class StubStore implements IStore {
     }
 
     /**
-     * @return {Promise} If there is a saved sync, the nextBatch token
+     * @returns If there is a saved sync, the nextBatch token
      * for this sync, otherwise null.
      */
     public getSavedSyncToken(): Promise<string | null> {
@@ -239,7 +219,7 @@ export class StubStore implements IStore {
     /**
      * Delete all data from this store. Does nothing since this store
      * doesn't store anything.
-     * @return {Promise} An immediately resolved promise.
+     * @returns An immediately resolved promise.
      */
     public deleteAllData(): Promise<void> {
         return Promise.resolve();
diff --git a/src/sync-accumulator.ts b/src/sync-accumulator.ts
index f383cb98a4a..13f87ecc06e 100644
--- a/src/sync-accumulator.ts
+++ b/src/sync-accumulator.ts
@@ -16,7 +16,6 @@ limitations under the License.
 
 /**
  * This is an internal module. See {@link SyncAccumulator} for the public class.
- * @module sync-accumulator
  */
 
 import { logger } from './logger';
@@ -28,6 +27,13 @@ import { MAIN_ROOM_TIMELINE, ReceiptContent, ReceiptType } from "./@types/read_r
 import { UNREAD_THREAD_NOTIFICATIONS } from './@types/sync';
 
 interface IOpts {
+    /**
+     * The ideal maximum number of timeline entries to keep in the sync response.
+     * This is best-effort, as clients do not always have a back-pagination token for each event,
+     * so it's possible there may be slightly *less* than this value. There will never be more.
+     * This cannot be 0 or else it makes it impossible to scroll back in a room.
+     * Default: 50.
+     */
     maxTimelineEntries?: number;
 }
 
@@ -211,15 +217,6 @@ export class SyncAccumulator {
     // streaming from without losing events.
     private nextBatch: string | null = null;
 
-    /**
-     * @param {Object} opts
-     * @param {Number=} opts.maxTimelineEntries The ideal maximum number of
-     * timeline entries to keep in the sync response. This is best-effort, as
-     * clients do not always have a back-pagination token for each event, so
-     * it's possible there may be slightly *less* than this value. There will
-     * never be more. This cannot be 0 or else it makes it impossible to scroll
-     * back in a room. Default: 50.
-     */
     public constructor(private readonly opts: IOpts = {}) {
         this.opts.maxTimelineEntries = this.opts.maxTimelineEntries || 50;
     }
@@ -242,8 +239,8 @@ export class SyncAccumulator {
 
     /**
      * Accumulate incremental /sync room data.
-     * @param {Object} syncResponse the complete /sync JSON
-     * @param {boolean} fromDatabase True if the sync response is one saved to the database
+     * @param syncResponse - the complete /sync JSON
+     * @param fromDatabase - True if the sync response is one saved to the database
      */
     private accumulateRooms(syncResponse: ISyncResponse, fromDatabase = false): void {
         if (!syncResponse.rooms) {
@@ -531,8 +528,8 @@ export class SyncAccumulator {
      * represents all room data that should be stored. This should be paired
      * with the sync token which represents the most recent /sync response
      * provided to accumulate().
-     * @param {boolean} forDatabase True to generate a sync to be saved to storage
-     * @return {Object} An object with a "nextBatch", "roomsData" and "accountData"
+     * @param forDatabase - True to generate a sync to be saved to storage
+     * @returns An object with a "nextBatch", "roomsData" and "accountData"
      * keys.
      * The "nextBatch" key is a string which represents at what point in the
      * /sync stream the accumulator reached. This token should be used when
diff --git a/src/sync.ts b/src/sync.ts
index c97ba35401d..38325ca8340 100644
--- a/src/sync.ts
+++ b/src/sync.ts
@@ -106,6 +106,7 @@ function getFilterName(userId: string, suffix?: string): string {
     return `FILTER_SYNC_${userId}` + (suffix ? "_" + suffix : "");
 }
 
+/* istanbul ignore next */
 function debuglog(...params: any[]): void {
     if (!DEBUG) return;
     logger.log(...params);
@@ -117,9 +118,27 @@ interface ISyncOptions {
 }
 
 export interface ISyncStateData {
+    /**
+     * The matrix error if `state=ERROR`.
+     */
     error?: Error;
+    /**
+     * The 'since' token passed to /sync.
+     *    `null` for the first successful sync since this client was
+     *    started. Only present if `state=PREPARED` or
+     *    `state=SYNCING`.
+     */
     oldSyncToken?: string;
+    /**
+     * The 'next_batch' result from /sync, which
+     *    will become the 'since' token for the next call to /sync. Only present if
+     *    `state=PREPARED</code> or <code>state=SYNCING`.
+     */
     nextSyncToken?: string;
+    /**
+     * True if we are working our way through a
+     *    backlog of events after connecting. Only present if `state=SYNCING`.
+     */
     catchingUp?: boolean;
     fromCache?: boolean;
 }
@@ -146,21 +165,6 @@ type WrappedRoom<T> = T & {
     isBrandNewRoom: boolean;
 };
 
-/**
- * <b>Internal class - unstable.</b>
- * Construct an entity which is able to sync with a homeserver.
- * @constructor
- * @param {MatrixClient} client The matrix client instance to use.
- * @param {Object} opts Config options
- * @param {module:crypto=} opts.crypto Crypto manager
- * @param {Function=} opts.canResetEntireTimeline A function which is called
- * with a room ID and returns a boolean. It should return 'true' if the SDK can
- * SAFELY remove events from this room. It may not be safe to remove events if
- * there are other references to the timelines for this room.
- * Default: returns false.
- * @param {Boolean=} opts.disablePresence True to perform syncing without automatically
- * updating presence.
- */
 export class SyncApi {
     private _peekRoom: Optional<Room> = null;
     private currentSyncRequest?: Promise<ISyncResponse>;
@@ -175,6 +179,12 @@ export class SyncApi {
     private failedSyncCount = 0; // Number of consecutive failed /sync requests
     private storeIsInvalid = false; // flag set if the store needs to be cleared before we can start
 
+    /**
+     * Construct an entity which is able to sync with a homeserver.
+     * @param client - The matrix client instance to use.
+     * @param opts - Config options
+     * @internal
+     */
     public constructor(private readonly client: MatrixClient, private readonly opts: Partial<IStoredClientOpts> = {}) {
         this.opts.initialSyncLimit = this.opts.initialSyncLimit ?? 8;
         this.opts.resolveInvitesToProfiles = this.opts.resolveInvitesToProfiles || false;
@@ -196,10 +206,6 @@ export class SyncApi {
         }
     }
 
-    /**
-     * @param {string} roomId
-     * @return {Room}
-     */
     public createRoom(roomId: string): Room {
         const room = _createAndReEmitRoom(this.client, roomId, this.opts);
 
@@ -214,9 +220,9 @@ export class SyncApi {
      * new historical messages imported by MSC2716 `/batch_send` somewhere in
      * the room and we need to throw away the timeline to make sure the
      * historical messages are shown when we paginate `/messages` again.
-     * @param {Room} room The room where the marker event was sent
-     * @param {MatrixEvent} markerEvent The new marker event
-     * @param {IMarkerFoundOptions} setStateOptions When `timelineWasEmpty` is set
+     * @param room - The room where the marker event was sent
+     * @param markerEvent - The new marker event
+     * @param setStateOptions - When `timelineWasEmpty` is set
      * as `true`, the given marker event will be ignored
     */
     private onMarkerStateEvent(
@@ -279,7 +285,7 @@ export class SyncApi {
 
     /**
      * Sync rooms the user has left.
-     * @return {Promise} Resolved when they've been added to the store.
+     * @returns Resolved when they've been added to the store.
      */
     public async syncLeftRooms(): Promise<Room[]> {
         const client = this.client;
@@ -350,8 +356,8 @@ export class SyncApi {
     /**
      * Peek into a room. This will result in the room in question being synced so it
      * is accessible via getRooms(). Live updates for the room will be provided.
-     * @param {string} roomId The room ID to peek into.
-     * @return {Promise} A promise which resolves once the room has been added to the
+     * @param roomId - The room ID to peek into.
+     * @returns A promise which resolves once the room has been added to the
      * store.
      */
     public peek(roomId: string): Promise<Room> {
@@ -430,8 +436,7 @@ export class SyncApi {
 
     /**
      * Do a peek room poll.
-     * @param {Room} peekRoom
-     * @param {string?} token from= token
+     * @param token - from= token
      */
     private peekPoll(peekRoom: Room, token?: string): void {
         if (this._peekRoom !== peekRoom) {
@@ -494,8 +499,7 @@ export class SyncApi {
 
     /**
      * Returns the current state of this sync object
-     * @see module:client~MatrixClient#event:"sync"
-     * @return {?String}
+     * @see MatrixClient#event:"sync"
      */
     public getSyncState(): SyncState | null {
         return this.syncState;
@@ -507,7 +511,6 @@ export class SyncApi {
      * such data.
      * Sync errors, if available, are put in the 'error' key of
      * this object.
-     * @return {?Object}
      */
     public getSyncStateData(): ISyncStateData | null {
         return this.syncStateData ?? null;
@@ -526,8 +529,8 @@ export class SyncApi {
 
     /**
      * Is the lazy loading option different than in previous session?
-     * @param {boolean} lazyLoadMembers current options for lazy loading
-     * @return {boolean} whether or not the option has changed compared to the previous session */
+     * @param lazyLoadMembers - current options for lazy loading
+     * @returns whether or not the option has changed compared to the previous session */
     private async wasLazyLoadingToggled(lazyLoadMembers = false): Promise<boolean> {
         // assume it was turned off before
         // if we don't know any better
@@ -758,7 +761,7 @@ export class SyncApi {
     /**
      * Retry a backed off syncing request immediately. This should only be used when
      * the user <b>explicitly</b> attempts to retry their lost connection.
-     * @return {boolean} True if this resulted in a request being retried.
+     * @returns True if this resulted in a request being retried.
      */
     public retryImmediately(): boolean {
         if (!this.connectionReturnedDefer) {
@@ -769,7 +772,7 @@ export class SyncApi {
     }
     /**
      * Process a single set of cached sync data.
-     * @param {Object} savedSync a saved sync that was persisted by a store. This
+     * @param savedSync - a saved sync that was persisted by a store. This
      * should have been acquired via client.store.getSavedSync().
      */
     private async syncFromCache(savedSync: ISavedSync): Promise<void> {
@@ -811,9 +814,6 @@ export class SyncApi {
 
     /**
      * Invoke me to do /sync calls
-     * @param {Object} syncOptions
-     * @param {string} syncOptions.filterId
-     * @param {boolean} syncOptions.hasSyncedBefore
      */
     private async doSync(syncOptions: ISyncOptions): Promise<void> {
         while (this.running) {
@@ -1023,8 +1023,8 @@ export class SyncApi {
      * Process data returned from a sync response and propagate it
      * into the model objects
      *
-     * @param {Object} syncEventData Object containing sync tokens associated with this sync
-     * @param {Object} data The response from /sync
+     * @param syncEventData - Object containing sync tokens associated with this sync
+     * @param data - The response from /sync
      */
     private async processSyncResponse(syncEventData: ISyncStateData, data: ISyncResponse): Promise<void> {
         const client = this.client;
@@ -1490,10 +1490,10 @@ export class SyncApi {
 
     /**
      * Starts polling the connectivity check endpoint
-     * @param {number} delay How long to delay until the first poll.
+     * @param delay - How long to delay until the first poll.
      *        defaults to a short, randomised interval (to prevent
      *        tight-looping if /versions succeeds but /sync etc. fail).
-     * @return {promise} which resolves once the connection returns
+     * @returns which resolves once the connection returns
      */
     private startKeepAlives(delay?: number): Promise<boolean> {
         if (delay === undefined) {
@@ -1521,7 +1521,7 @@ export class SyncApi {
      * On failure, schedules a call back to itself. On success, resolves
      * this.connectionReturnedDefer.
      *
-     * @param {boolean} connDidFail True if a connectivity failure has been detected. Optional.
+     * @param connDidFail - True if a connectivity failure has been detected. Optional.
      */
     private pokeKeepAlive(connDidFail = false): void {
         const success = (): void => {
@@ -1568,10 +1568,6 @@ export class SyncApi {
         });
     }
 
-    /**
-     * @param {Object} obj
-     * @return {Object[]}
-     */
     private mapSyncResponseToRoomArray<T extends ILeftRoom | IJoinedRoom | IInvitedRoom>(
         obj: Record<string, T>,
     ): Array<WrappedRoom<T>> {
@@ -1593,12 +1589,6 @@ export class SyncApi {
         });
     }
 
-    /**
-     * @param {Object} obj
-     * @param {Room} room
-     * @param {boolean} decrypt
-     * @return {MatrixEvent[]}
-     */
     private mapSyncEventsFormat(
         obj: IInviteState | ITimeline | IEphemeral,
         room?: Room,
@@ -1618,7 +1608,6 @@ export class SyncApi {
     }
 
     /**
-     * @param {Room} room
      */
     private resolveInvites(room: Room): void {
         if (!room || !this.opts.resolveInvitesToProfiles) {
@@ -1662,12 +1651,11 @@ export class SyncApi {
 
     /**
      * Injects events into a room's model.
-     * @param {Room} room
-     * @param {MatrixEvent[]} stateEventList A list of state events. This is the state
+     * @param stateEventList - A list of state events. This is the state
      * at the *START* of the timeline list if it is supplied.
-     * @param {MatrixEvent[]} [timelineEventList] A list of timeline events, including threaded. Lower index
+     * @param timelineEventList - A list of timeline events, including threaded. Lower index
      * is earlier in time. Higher index is later.
-     * @param {boolean} fromCache whether the sync response came from cache
+     * @param fromCache - whether the sync response came from cache
      */
     public async injectRoomEvents(
         room: Room,
@@ -1743,8 +1731,7 @@ export class SyncApi {
      * as appropriate.
      * This must be called after the room the events belong to has been stored.
      *
-     * @param {Room} room
-     * @param {MatrixEvent[]} [timelineEventList] A list of timeline events. Lower index
+     * @param timelineEventList - A list of timeline events. Lower index
      * is earlier in time. Higher index is later.
      */
     private processEventsForNotifs(room: Room, timelineEventList: MatrixEvent[]): void {
@@ -1759,9 +1746,6 @@ export class SyncApi {
         }
     }
 
-    /**
-     * @return {string}
-     */
     private getGuestFilter(): string {
         // Dev note: This used to be conditional to return a filter of 20 events maximum, but
         // the condition never went to the other branch. This is now hardcoded.
@@ -1770,8 +1754,8 @@ export class SyncApi {
 
     /**
      * Sets the sync state and emits an event to say so
-     * @param {String} newState The new state string
-     * @param {Object} data Object of additional data to emit in the event
+     * @param newState - The new state string
+     * @param data - Object of additional data to emit in the event
      */
     private updateSyncState(newState: SyncState, data?: ISyncStateData): void {
         const old = this.syncState;
diff --git a/src/timeline-window.ts b/src/timeline-window.ts
index 5498600a99c..2d0c9da15de 100644
--- a/src/timeline-window.ts
+++ b/src/timeline-window.ts
@@ -14,8 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-/** @module timeline-window */
-
 import { Optional } from "matrix-events-sdk";
 
 import { Direction, EventTimeline } from './models/event-timeline';
@@ -25,23 +23,28 @@ import { EventTimelineSet } from "./models/event-timeline-set";
 import { MatrixEvent } from "./models/event";
 
 /**
- * @private
+ * @internal
  */
 const DEBUG = false;
 
 /**
- * @private
+ * @internal
  */
+/* istanbul ignore next */
 const debuglog = DEBUG ? logger.log.bind(logger) : function(): void {};
 
 /**
  * the number of times we ask the server for more events before giving up
  *
- * @private
+ * @internal
  */
 const DEFAULT_PAGINATE_LOOP_LIMIT = 5;
 
 interface IOpts {
+    /**
+     * Maximum number of events to keep in the window. If more events are retrieved via pagination requests,
+     * excess events will be dropped from the other end of the window.
+     */
     windowLimit?: number;
 }
 
@@ -58,31 +61,22 @@ export class TimelineWindow {
     /**
      * Construct a TimelineWindow.
      *
-     * <p>This abstracts the separate timelines in a Matrix {@link
-        * module:models/room|Room} into a single iterable thing. It keeps track of
-     * the start and endpoints of the window, which can be advanced with the help
+     * <p>This abstracts the separate timelines in a Matrix {@link Room} into a single iterable thing.
+     * It keeps track of the start and endpoints of the window, which can be advanced with the help
      * of pagination requests.
      *
-     * <p>Before the window is useful, it must be initialised by calling {@link
-        * module:timeline-window~TimelineWindow#load|load}.
+     * <p>Before the window is useful, it must be initialised by calling {@link TimelineWindow#load}.
      *
      * <p>Note that the window will not automatically extend itself when new events
-     * are received from /sync; you should arrange to call {@link
-        * module:timeline-window~TimelineWindow#paginate|paginate} on {@link
-        * module:client~MatrixClient.event:"Room.timeline"|Room.timeline} events.
+     * are received from /sync; you should arrange to call {@link TimelineWindow#paginate}
+     * on {@link RoomEvent.Timeline} events.
      *
-     * @param {MatrixClient} client   MatrixClient to be used for context/pagination
+     * @param client -   MatrixClient to be used for context/pagination
      *   requests.
      *
-     * @param {EventTimelineSet} timelineSet  The timelineSet to track
-     *
-     * @param {Object} [opts] Configuration options for this window
+     * @param timelineSet -  The timelineSet to track
      *
-     * @param {number} [opts.windowLimit = 1000] maximum number of events to keep
-     *    in the window. If more events are retrieved via pagination requests,
-     *    excess events will be dropped from the other end of the window.
-     *
-     * @constructor
+     * @param opts - Configuration options for this window
      */
     public constructor(
         private readonly client: MatrixClient,
@@ -95,11 +89,9 @@ export class TimelineWindow {
     /**
      * Initialise the window to point at a given event, or the live timeline
      *
-     * @param {string} [initialEventId]   If given, the window will contain the
+     * @param initialEventId -   If given, the window will contain the
      *    given event
-     * @param {number} [initialWindowSize = 20]   Size of the initial window
-     *
-     * @return {Promise}
+     * @param initialWindowSize -   Size of the initial window
      */
     public load(initialEventId?: string, initialWindowSize = 20): Promise<void> {
         // given an EventTimeline, find the event we were looking for, and initialise our
@@ -148,11 +140,11 @@ export class TimelineWindow {
     /**
      * Get the TimelineIndex of the window in the given direction.
      *
-     * @param {string} direction   EventTimeline.BACKWARDS to get the TimelineIndex
+     * @param direction -   EventTimeline.BACKWARDS to get the TimelineIndex
      * at the start of the window; EventTimeline.FORWARDS to get the TimelineIndex at
      * the end.
      *
-     * @return {TimelineIndex} The requested timeline index if one exists, null
+     * @returns The requested timeline index if one exists, null
      * otherwise.
      */
     public getTimelineIndex(direction: Direction): TimelineIndex | null {
@@ -169,11 +161,11 @@ export class TimelineWindow {
      * Try to extend the window using events that are already in the underlying
      * TimelineIndex.
      *
-     * @param {string} direction   EventTimeline.BACKWARDS to try extending it
+     * @param direction -   EventTimeline.BACKWARDS to try extending it
      *   backwards; EventTimeline.FORWARDS to try extending it forwards.
-     * @param {number} size   number of events to try to extend by.
+     * @param size -   number of events to try to extend by.
      *
-     * @return {boolean} true if the window was extended, false otherwise.
+     * @returns true if the window was extended, false otherwise.
      */
     public extend(direction: Direction, size: number): boolean {
         const tl = this.getTimelineIndex(direction);
@@ -209,10 +201,10 @@ export class TimelineWindow {
      * necessarily mean that there are more events available in that direction at
      * this time.
      *
-     * @param {string} direction   EventTimeline.BACKWARDS to check if we can
+     * @param direction -   EventTimeline.BACKWARDS to check if we can
      *   paginate backwards; EventTimeline.FORWARDS to check if we can go forwards
      *
-     * @return {boolean} true if we can paginate in the given direction
+     * @returns true if we can paginate in the given direction
      */
     public canPaginate(direction: Direction): boolean {
         const tl = this.getTimelineIndex(direction);
@@ -240,23 +232,23 @@ export class TimelineWindow {
     /**
      * Attempt to extend the window
      *
-     * @param {string} direction   EventTimeline.BACKWARDS to extend the window
+     * @param direction -   EventTimeline.BACKWARDS to extend the window
      *    backwards (towards older events); EventTimeline.FORWARDS to go forwards.
      *
-     * @param {number} size   number of events to try to extend by. If fewer than this
+     * @param size -   number of events to try to extend by. If fewer than this
      *    number are immediately available, then we return immediately rather than
      *    making an API call.
      *
-     * @param {boolean} [makeRequest = true] whether we should make API calls to
+     * @param makeRequest - whether we should make API calls to
      *    fetch further events if we don't have any at all. (This has no effect if
      *    the room already knows about additional events in the relevant direction,
      *    even if there are fewer than 'size' of them, as we will just return those
      *    we already know about.)
      *
-     * @param {number} [requestLimit = 5] limit for the number of API requests we
+     * @param requestLimit - limit for the number of API requests we
      *    should make.
      *
-     * @return {Promise} Resolves to a boolean which is true if more events
+     * @returns Promise which resolves to a boolean which is true if more events
      *    were successfully retrieved.
      */
     public async paginate(
@@ -330,8 +322,8 @@ export class TimelineWindow {
     /**
      * Remove `delta` events from the start or end of the timeline.
      *
-     * @param {number}  delta           number of events to remove from the timeline
-     * @param {boolean} startOfTimeline if events should be removed from the start
+     * @param delta - number of events to remove from the timeline
+     * @param startOfTimeline - if events should be removed from the start
      *     of the timeline.
      */
     public unpaginate(delta: number, startOfTimeline: boolean): void {
@@ -368,7 +360,7 @@ export class TimelineWindow {
     /**
      * Get a list of the events currently in the window
      *
-     * @return {MatrixEvent[]} the events in the window
+     * @returns the events in the window
      */
     public getEvents(): MatrixEvent[] {
         if (!this.start) {
@@ -419,12 +411,8 @@ export class TimelineWindow {
 }
 
 /**
- * a thing which contains a timeline reference, and an index into it.
- *
- * @constructor
- * @param {EventTimeline} timeline
- * @param {number} index
- * @private
+ * A thing which contains a timeline reference, and an index into it.
+ * @internal
  */
 export class TimelineIndex {
     public pendingPaginate?: Promise<boolean>;
@@ -433,7 +421,7 @@ export class TimelineIndex {
     public constructor(public timeline: EventTimeline, public index: number) {}
 
     /**
-     * @return {number} the minimum possible value for the index in the current
+     * @returns the minimum possible value for the index in the current
      *    timeline
      */
     public minIndex(): number {
@@ -441,7 +429,7 @@ export class TimelineIndex {
     }
 
     /**
-     * @return {number} the maximum possible value for the index in the current
+     * @returns the maximum possible value for the index in the current
      *    timeline (exclusive - ie, it actually returns one more than the index
      *    of the last element).
      */
@@ -452,8 +440,8 @@ export class TimelineIndex {
     /**
      * Try move the index forward, or into the neighbouring timeline
      *
-     * @param {number} delta  number of events to advance by
-     * @return {number} number of events successfully advanced by
+     * @param delta -  number of events to advance by
+     * @returns number of events successfully advanced by
      */
     public advance(delta: number): number {
         if (!delta) {
@@ -512,8 +500,8 @@ export class TimelineIndex {
     /**
      * Try move the index backwards, or into the neighbouring timeline
      *
-     * @param {number} delta  number of events to retreat by
-     * @return {number} number of events successfully retreated by
+     * @param delta -  number of events to retreat by
+     * @returns number of events successfully retreated by
      */
     public retreat(delta: number): number {
         return this.advance(delta * -1) * -1;
diff --git a/src/utils.ts b/src/utils.ts
index ef6af6b0668..8cf248c783d 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -17,7 +17,6 @@ limitations under the License.
 
 /**
  * This is an internal module.
- * @module utils
  */
 
 import unhomoglyph from "unhomoglyph";
@@ -33,7 +32,7 @@ const interns = new Map<string, string>();
 /**
  * Internalises a string, reusing a known pointer or storing the pointer
  * if needed for future strings.
- * @param str The string to internalise.
+ * @param str - The string to internalise.
  * @returns The internalised string.
  */
 export function internaliseString(str: string): string {
@@ -55,9 +54,9 @@ export function internaliseString(str: string): string {
 /**
  * Encode a dictionary of query parameters.
  * Omits any undefined/null values.
- * @param {Object} params A dict of key/values to encode e.g.
- * {"foo": "bar", "baz": "taz"}
- * @return {string} The encoded string e.g. foo=bar&baz=taz
+ * @param params - A dict of key/values to encode e.g.
+ * `{"foo": "bar", "baz": "taz"}`
+ * @returns The encoded string e.g. foo=bar&baz=taz
  */
 export function encodeParams(params: QueryDict, urlSearchParams?: URLSearchParams): URLSearchParams {
     const searchParams = urlSearchParams ?? new URLSearchParams();
@@ -79,9 +78,6 @@ export type QueryDict = Record<string, string[] | string | number | boolean | un
 
 /**
  * Replace a stable parameter with the unstable naming for params
- * @param stable
- * @param unstable
- * @param dict
  */
 export function replaceParam(
     stable: string,
@@ -98,9 +94,9 @@ export function replaceParam(
 
 /**
  * Decode a query string in `application/x-www-form-urlencoded` format.
- * @param {string} query A query string to decode e.g.
+ * @param query - A query string to decode e.g.
  * foo=bar&via=server1&server2
- * @return {Object} The decoded object, if any keys occurred multiple times
+ * @returns The decoded object, if any keys occurred multiple times
  * then the value will be an array of strings, else it will be an array.
  * This behaviour matches Node's qs.parse but is built on URLSearchParams
  * for native web compatibility
@@ -118,10 +114,10 @@ export function decodeParams(query: string): Record<string, string | string[]> {
 /**
  * Encodes a URI according to a set of template variables. Variables will be
  * passed through encodeURIComponent.
- * @param {string} pathTemplate The path with template variables e.g. '/foo/$bar'.
- * @param {Object} variables The key/value pairs to replace the template
- * variables with. E.g. { "$bar": "baz" }.
- * @return {string} The result of replacing all template variables e.g. '/foo/baz'.
+ * @param pathTemplate - The path with template variables e.g. '/foo/$bar'.
+ * @param variables - The key/value pairs to replace the template
+ * variables with. E.g. `{ "$bar": "baz" }`.
+ * @returns The result of replacing all template variables e.g. '/foo/baz'.
  */
 export function encodeUri(pathTemplate: string, variables: Record<string, Optional<string>>): string {
     for (const key in variables) {
@@ -142,12 +138,12 @@ export function encodeUri(pathTemplate: string, variables: Record<string, Option
 /**
  * The removeElement() method removes the first element in the array that
  * satisfies (returns true) the provided testing function.
- * @param {Array} array The array.
- * @param {Function} fn Function to execute on each value in the array, with the
- * function signature <code>fn(element, index, array)</code>. Return true to
+ * @param array - The array.
+ * @param fn - Function to execute on each value in the array, with the
+ * function signature `fn(element, index, array)`. Return true to
  * remove this element and break.
- * @param {boolean} reverse True to search in reverse order.
- * @return {boolean} True if an element was removed.
+ * @param reverse - True to search in reverse order.
+ * @returns True if an element was removed.
  */
 export function removeElement<T>(
     array: T[],
@@ -175,8 +171,8 @@ export function removeElement<T>(
 
 /**
  * Checks if the given thing is a function.
- * @param {*} value The thing to check.
- * @return {boolean} True if it is a function.
+ * @param value - The thing to check.
+ * @returns True if it is a function.
  */
 export function isFunction(value: any): boolean {
     return Object.prototype.toString.call(value) === "[object Function]";
@@ -184,8 +180,8 @@ export function isFunction(value: any): boolean {
 
 /**
  * Checks that the given object has the specified keys.
- * @param {Object} obj The object to check.
- * @param {string[]} keys The list of keys that 'obj' must have.
+ * @param obj - The object to check.
+ * @param keys - The list of keys that 'obj' must have.
  * @throws If the object is missing keys.
  */
 // note using 'keys' here would shadow the 'keys' function defined above
@@ -200,8 +196,8 @@ export function checkObjectHasKeys(obj: object, keys: string[]): void {
 /**
  * Deep copy the given object. The object MUST NOT have circular references and
  * MUST NOT have functions.
- * @param {Object} obj The object to deep copy.
- * @return {Object} A copy of the object without any references to the original.
+ * @param obj - The object to deep copy.
+ * @returns A copy of the object without any references to the original.
  */
 export function deepCopy<T>(obj: T): T {
     return JSON.parse(JSON.stringify(obj));
@@ -210,10 +206,10 @@ export function deepCopy<T>(obj: T): T {
 /**
  * Compare two objects for equality. The objects MUST NOT have circular references.
  *
- * @param {Object} x The first object to compare.
- * @param {Object} y The second object to compare.
+ * @param x - The first object to compare.
+ * @param y - The second object to compare.
  *
- * @return {boolean} true if the two objects are equal
+ * @returns true if the two objects are equal
  */
 export function deepCompare(x: any, y: any): boolean {
     // Inspired by
@@ -290,8 +286,8 @@ export function deepCompare(x: any, y: any): boolean {
  * sorts the result by key, recursively. The input object must
  * ensure it does not have loops. If the input is not an object
  * then it will be returned as-is.
- * @param {*} obj The object to get entries of
- * @returns {Array} The entries, sorted by key.
+ * @param obj - The object to get entries of
+ * @returns The entries, sorted by key.
  */
 export function deepSortedObjectEntries(obj: any): [string, any][] {
     if (typeof(obj) !== "object") return obj;
@@ -313,8 +309,8 @@ export function deepSortedObjectEntries(obj: any): [string, any][] {
 /**
  * Returns whether the given value is a finite number without type-coercion
  *
- * @param {*} value the value to test
- * @return {boolean} whether or not value is a finite number without type-coercion
+ * @param value - the value to test
+ * @returns whether or not value is a finite number without type-coercion
  */
 export function isNumber(value: any): value is number {
     return typeof value === 'number' && isFinite(value);
@@ -323,8 +319,8 @@ export function isNumber(value: any): value is number {
 /**
  * Removes zero width chars, diacritics and whitespace from the string
  * Also applies an unhomoglyph on the string, to prevent similar looking chars
- * @param {string} str the string to remove hidden characters from
- * @return {string} a string with the hidden characters removed
+ * @param str - the string to remove hidden characters from
+ * @returns a string with the hidden characters removed
  */
 export function removeHiddenChars(str: string): string {
     if (typeof str === "string") {
@@ -335,7 +331,6 @@ export function removeHiddenChars(str: string): string {
 
 /**
  * Removes the direction override characters from a string
- * @param {string} input
  * @returns string with chars removed
  */
 export function removeDirectionOverrideChars(str: string): string {
@@ -466,9 +461,9 @@ export async function chunkPromises<T>(fns: (() => Promise<T>)[], chunkSize: num
  * a promise which throws/rejects on error, otherwise the retry will assume the request
  * succeeded. The promise chain returned will contain the successful promise. The given function
  * should always return a new promise.
- * @param {Function} promiseFn The function to call to get a fresh promise instance. Takes an
+ * @param promiseFn - The function to call to get a fresh promise instance. Takes an
  * attempt count as an argument, for logging/debugging purposes.
- * @returns {Promise<T>} The promise for the retried operation.
+ * @returns The promise for the retried operation.
  */
 export function simpleRetryOperation<T>(promiseFn: (attempt: number) => Promise<T>): Promise<T> {
     return promiseRetry((attempt: number) => {
@@ -503,10 +498,10 @@ export const DEFAULT_ALPHABET = ((): string => {
  * padded at the end with the first character in the alphabet.
  *
  * This is intended for use with string averaging.
- * @param {string} s The string to pad.
- * @param {number} n The length to pad to.
- * @param {string} alphabet The alphabet to use as a single string.
- * @returns {string} The padded string.
+ * @param s - The string to pad.
+ * @param n - The length to pad to.
+ * @param alphabet - The alphabet to use as a single string.
+ * @returns The padded string.
  */
 export function alphabetPad(s: string, n: number, alphabet = DEFAULT_ALPHABET): string {
     return s.padEnd(n, alphabet[0]);
@@ -516,9 +511,9 @@ export function alphabetPad(s: string, n: number, alphabet = DEFAULT_ALPHABET):
  * Converts a baseN number to a string, where N is the alphabet's length.
  *
  * This is intended for use with string averaging.
- * @param {bigint} n The baseN number.
- * @param {string} alphabet The alphabet to use as a single string.
- * @returns {string} The baseN number encoded as a string from the alphabet.
+ * @param n - The baseN number.
+ * @param alphabet - The alphabet to use as a single string.
+ * @returns The baseN number encoded as a string from the alphabet.
  */
 export function baseToString(n: bigint, alphabet = DEFAULT_ALPHABET): string {
     // Developer note: the stringToBase() function offsets the character set by 1 so that repeated
@@ -550,9 +545,9 @@ export function baseToString(n: bigint, alphabet = DEFAULT_ALPHABET): string {
  * Converts a string to a baseN number, where N is the alphabet's length.
  *
  * This is intended for use with string averaging.
- * @param {string} s The string to convert to a number.
- * @param {string} alphabet The alphabet to use as a single string.
- * @returns {bigint} The baseN number.
+ * @param s - The string to convert to a number.
+ * @param alphabet - The alphabet to use as a single string.
+ * @returns The baseN number.
  */
 export function stringToBase(s: string, alphabet = DEFAULT_ALPHABET): bigint {
     const len = BigInt(alphabet.length);
@@ -584,10 +579,10 @@ export function stringToBase(s: string, alphabet = DEFAULT_ALPHABET): bigint {
  * Averages two strings, returning the midpoint between them. This is accomplished by
  * converting both to baseN numbers (where N is the alphabet's length) then averaging
  * those before re-encoding as a string.
- * @param {string} a The first string.
- * @param {string} b The second string.
- * @param {string} alphabet The alphabet to use as a single string.
- * @returns {string} The midpoint between the strings, as a string.
+ * @param a - The first string.
+ * @param b - The second string.
+ * @param alphabet - The alphabet to use as a single string.
+ * @returns The midpoint between the strings, as a string.
  */
 export function averageBetweenStrings(a: string, b: string, alphabet = DEFAULT_ALPHABET): string {
     const padN = Math.max(a.length, b.length);
@@ -608,9 +603,9 @@ export function averageBetweenStrings(a: string, b: string, alphabet = DEFAULT_A
  * Finds the next string using the alphabet provided. This is done by converting the
  * string to a baseN number, where N is the alphabet's length, then adding 1 before
  * converting back to a string.
- * @param {string} s The string to start at.
- * @param {string} alphabet The alphabet to use as a single string.
- * @returns {string} The string which follows the input string.
+ * @param s - The string to start at.
+ * @param alphabet - The alphabet to use as a single string.
+ * @returns The string which follows the input string.
  */
 export function nextString(s: string, alphabet = DEFAULT_ALPHABET): string {
     return baseToString(stringToBase(s, alphabet) + BigInt(1), alphabet);
@@ -620,9 +615,9 @@ export function nextString(s: string, alphabet = DEFAULT_ALPHABET): string {
  * Finds the previous string using the alphabet provided. This is done by converting the
  * string to a baseN number, where N is the alphabet's length, then subtracting 1 before
  * converting back to a string.
- * @param {string} s The string to start at.
- * @param {string} alphabet The alphabet to use as a single string.
- * @returns {string} The string which precedes the input string.
+ * @param s - The string to start at.
+ * @param alphabet - The alphabet to use as a single string.
+ * @returns The string which precedes the input string.
  */
 export function prevString(s: string, alphabet = DEFAULT_ALPHABET): string {
     return baseToString(stringToBase(s, alphabet) - BigInt(1), alphabet);
@@ -630,9 +625,9 @@ export function prevString(s: string, alphabet = DEFAULT_ALPHABET): string {
 
 /**
  * Compares strings lexicographically as a sort-safe function.
- * @param {string} a The first (reference) string.
- * @param {string} b The second (compare) string.
- * @returns {number} Negative if the reference string is before the compare string;
+ * @param a - The first (reference) string.
+ * @param b - The second (compare) string.
+ * @returns Negative if the reference string is before the compare string;
  * positive if the reference string is after; and zero if equal.
  */
 export function lexicographicCompare(a: string, b: string): number {
@@ -650,8 +645,8 @@ export function lexicographicCompare(a: string, b: string): number {
 const collator = new Intl.Collator();
 /**
  * Performant language-sensitive string comparison
- * @param a the first string to compare
- * @param b the second string to compare
+ * @param a - the first string to compare
+ * @param b - the second string to compare
  */
 export function compare(a: string, b: string): number {
     return collator.compare(a, b);
@@ -661,8 +656,6 @@ export function compare(a: string, b: string): number {
  * This function is similar to Object.assign() but it assigns recursively and
  * allows you to ignore nullish values from the source
  *
- * @param {Object} target
- * @param {Object} source
  * @returns the target object
  */
 export function recursivelyAssign<T1 extends T2, T2 extends Record<string, any>>(
@@ -701,7 +694,7 @@ export function isSupportedReceiptType(receiptType: string): boolean {
 
 /**
  * Determines whether two maps are equal.
- * @param eq The equivalence relation to compare values by. Defaults to strict equality.
+ * @param eq - The equivalence relation to compare values by. Defaults to strict equality.
  */
 export function mapsEqual<K, V>(x: Map<K, V>, y: Map<K, V>, eq = (v1: V, v2: V): boolean => v1 === v2): boolean {
     if (x.size !== y.size) return false;
diff --git a/src/webrtc/audioContext.ts b/src/webrtc/audioContext.ts
index 0e08574b8c8..7cf3ed3f66e 100644
--- a/src/webrtc/audioContext.ts
+++ b/src/webrtc/audioContext.ts
@@ -22,7 +22,7 @@ let refCount = 0;
  * It's highly recommended to reuse this AudioContext rather than creating your
  * own, because multiple AudioContexts can be problematic in some browsers.
  * Make sure to call releaseContext when you're done using it.
- * @returns {AudioContext} The shared AudioContext
+ * @returns The shared AudioContext
  */
 export const acquireContext = (): AudioContext => {
     if (audioContext === null) audioContext = new AudioContext();
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index 7d303af4a5c..c9bcac1124c 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -19,7 +19,6 @@ limitations under the License.
 
 /**
  * This is an internal module. See {@link createNewMatrixCall} for the public API.
- * @module webrtc/call
  */
 
 import { v4 as uuidv4 } from "uuid";
@@ -54,29 +53,19 @@ import { GroupCallUnknownDeviceError } from './groupCall';
 import { IScreensharingOpts } from "./mediaHandler";
 import { MatrixError } from "../http-api";
 
-// events: hangup, error(err), replaced(call), state(state, oldState)
-
-/**
- * Fires whenever an error occurs when call.js encounters an issue with setting up the call.
- * <p>
- * The error given will have a code equal to either `MatrixCall.ERR_LOCAL_OFFER_FAILED` or
- * `MatrixCall.ERR_NO_USER_MEDIA`. `ERR_LOCAL_OFFER_FAILED` is emitted when the local client
- * fails to create an offer. `ERR_NO_USER_MEDIA` is emitted when the user has denied access
- * to their audio/video hardware.
- *
- * @event module:webrtc/call~MatrixCall#"error"
- * @param {Error} err The error raised by MatrixCall.
- * @example
- * matrixCall.on("error", function(err){
- *   console.error(err.code, err);
- * });
- */
-
 interface CallOpts {
+    // The room ID for this call.
     roomId?: string;
     invitee?: string;
+    // The Matrix Client instance to send events to.
     client: MatrixClient;
+    /**
+     * Whether relay through TURN should be forced.
+     * @deprecated use opts.forceTURN when creating the matrix client
+     * since it's only possible to set this option on outbound calls.
+     */
     forceTURN?: boolean;
+    // A list of TURN servers.
     turnServers?: Array<TurnServer>;
     opponentDeviceId?: string;
     opponentSessionId?: string;
@@ -320,17 +309,6 @@ function getTransceiverKey(purpose: SDPStreamMetadataPurpose, kind: TransceiverK
     return purpose + ':' + kind;
 }
 
-/**
- * Construct a new Matrix Call.
- * @constructor
- * @param {Object} opts Config options.
- * @param {string} opts.roomId The room ID for this call.
- * @param {Object} opts.webRtc The WebRTC globals from the browser.
- * @param {boolean} opts.forceTURN whether relay through TURN should be forced.
- * @param {Object} opts.URL The URL global.
- * @param {Array<Object>} opts.turnServers Optional. A list of TURN servers.
- * @param {MatrixClient} opts.client The Matrix Client instance to send events to.
- */
 export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap> {
     public roomId?: string;
     public callId: string;
@@ -405,6 +383,10 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     private opponentSessionId?: string;
     public groupCallId?: string;
 
+    /**
+     * Construct a new Matrix Call.
+     * @param opts - Config options.
+     */
     public constructor(opts: CallOpts) {
         super();
 
@@ -450,8 +432,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Create a datachannel using this call's peer connection.
-     * @param label A human readable label for this datachannel
-     * @param options An object providing configuration options for the data channel.
+     * @param label - A human readable label for this datachannel
+     * @param options - An object providing configuration options for the data channel.
      */
     public createDataChannel(label: string, options: RTCDataChannelInit | undefined): RTCDataChannel {
         const dataChannel = this.peerConn!.createDataChannel(label, options);
@@ -557,7 +539,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Returns an array of all CallFeeds
-     * @returns {Array<CallFeed>} CallFeeds
+     * @returns CallFeeds
      */
     public getFeeds(): Array<CallFeed> {
         return this.feeds;
@@ -565,7 +547,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Returns an array of all local CallFeeds
-     * @returns {Array<CallFeed>} local CallFeeds
+     * @returns local CallFeeds
      */
     public getLocalFeeds(): Array<CallFeed> {
         return this.feeds.filter((feed) => feed.isLocal());
@@ -573,7 +555,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Returns an array of all remote CallFeeds
-     * @returns {Array<CallFeed>} remote CallFeeds
+     * @returns remote CallFeeds
      */
     public getRemoteFeeds(): Array<CallFeed> {
         return this.feeds.filter((feed) => !feed.isLocal());
@@ -605,7 +587,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Generates and returns localSDPStreamMetadata
-     * @returns {SDPStreamMetadata} localSDPStreamMetadata
+     * @returns localSDPStreamMetadata
      */
     private getLocalSDPStreamMetadata(updateStreamIds = false): SDPStreamMetadata {
         const metadata: SDPStreamMetadata = {};
@@ -626,7 +608,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     /**
      * Returns true if there are no incoming feeds,
      * otherwise returns false
-     * @returns {boolean} no incoming feeds
+     * @returns no incoming feeds
      */
     public noIncomingFeeds(): boolean {
         return !this.feeds.some((feed) => !feed.isLocal());
@@ -747,8 +729,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Pushes supplied feed to the call
-     * @param {CallFeed} callFeed to push
-     * @param {boolean} addToPeerConnection whether to add the tracks to the peer connection
+     * @param callFeed - to push
+     * @param addToPeerConnection - whether to add the tracks to the peer connection
      */
     public pushLocalFeed(callFeed: CallFeed, addToPeerConnection = true): void {
         if (this.feeds.some((feed) => callFeed.stream.id === feed.stream.id)) {
@@ -820,7 +802,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     /**
      * Removes local call feed from the call and its tracks from the peer
      * connection
-     * @param callFeed to remove
+     * @param callFeed - to remove
      */
     public removeLocalFeed(callFeed: CallFeed): void {
         const audioTransceiverKey = getTransceiverKey(callFeed.purpose, "audio");
@@ -894,7 +876,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Configure this call from an invite event. Used by MatrixClient.
-     * @param {MatrixEvent} event The m.call.invite event
+     * @param event - The m.call.invite event
      */
     public async initWithInvite(event: MatrixEvent): Promise<void> {
         const invite = event.getContent<MCallInviteNegotiate>();
@@ -970,7 +952,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Configure this call from a hangup or reject event. Used by MatrixClient.
-     * @param {MatrixEvent} event The m.call.hangup event
+     * @param event - The m.call.hangup event
      */
     public initWithHangup(event: MatrixEvent): void {
         // perverse as it may seem, sometimes we want to instantiate a call with a
@@ -1069,7 +1051,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     /**
      * Replace this call with a new call, e.g. for glare resolution. Used by
      * MatrixClient.
-     * @param {MatrixCall} newCall The new call.
+     * @param newCall - The new call.
      */
     public replacedBy(newCall: MatrixCall): void {
         logger.debug(`Call ${this.callId} replaced by ${newCall.callId}`);
@@ -1091,8 +1073,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Hangup a call.
-     * @param {string} reason The reason why the call is being hung up.
-     * @param {boolean} suppressEvent True to suppress emitting an event.
+     * @param reason - The reason why the call is being hung up.
+     * @param suppressEvent - True to suppress emitting an event.
      */
     public hangup(reason: CallErrorCode, suppressEvent: boolean): void {
         if (this.callHasEnded()) return;
@@ -1135,8 +1117,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Adds an audio and/or video track - upgrades the call
-     * @param {boolean} audio should add an audio track
-     * @param {boolean} video should add an video track
+     * @param audio - should add an audio track
+     * @param video - should add an video track
      */
     private async upgradeCall(
         audio: boolean, video: boolean,
@@ -1164,7 +1146,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Returns true if this.remoteSDPStreamMetadata is defined, otherwise returns false
-     * @returns {boolean} can screenshare
+     * @returns can screenshare
      */
     public opponentSupportsSDPStreamMetadata(): boolean {
         return Boolean(this.remoteSDPStreamMetadata);
@@ -1172,7 +1154,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * If there is a screensharing stream returns true, otherwise returns false
-     * @returns {boolean} is screensharing
+     * @returns is screensharing
      */
     public isScreensharing(): boolean {
         return Boolean(this.localScreensharingStream);
@@ -1180,9 +1162,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Starts/stops screensharing
-     * @param enabled the desired screensharing state
-     * @param {string} desktopCapturerSourceId optional id of the desktop capturer source to use
-     * @returns {boolean} new screensharing state
+     * @param enabled - the desired screensharing state
+     * @param desktopCapturerSourceId - optional id of the desktop capturer source to use
+     * @returns new screensharing state
      */
     public async setScreensharingEnabled(enabled: boolean, opts?: IScreensharingOpts): Promise<boolean> {
         // Skip if there is nothing to do
@@ -1233,9 +1215,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     /**
      * Starts/stops screensharing
      * Should be used ONLY if the opponent doesn't support SDPStreamMetadata
-     * @param enabled the desired screensharing state
-     * @param {string} desktopCapturerSourceId optional id of the desktop capturer source to use
-     * @returns {boolean} new screensharing state
+     * @param enabled - the desired screensharing state
+     * @param desktopCapturerSourceId - optional id of the desktop capturer source to use
+     * @returns new screensharing state
      */
     private async setScreensharingEnabledWithoutMetadataSupport(
         enabled: boolean, opts?: IScreensharingOpts,
@@ -1277,7 +1259,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Replaces/adds the tracks from the passed stream to the localUsermediaStream
-     * @param {MediaStream} stream to use a replacement for the local usermedia stream
+     * @param stream - to use a replacement for the local usermedia stream
      */
     public async updateLocalUsermediaStream(
         stream: MediaStream, forceAudio = false, forceVideo = false,
@@ -1346,7 +1328,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Set whether our outbound video should be muted or not.
-     * @param {boolean} muted True to mute the outbound video.
+     * @param muted - True to mute the outbound video.
      * @returns the new mute state
      */
     public async setLocalVideoMuted(muted: boolean): Promise<boolean> {
@@ -1371,7 +1353,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      * If there are multiple video tracks, <i>all</i> of the tracks need to be muted
      * for this to return true. This means if there are no video tracks, this will
      * return true.
-     * @return {Boolean} True if the local preview video is muted, else false
+     * @returns True if the local preview video is muted, else false
      * (including if the call is not set up yet).
      */
     public isLocalVideoMuted(): boolean {
@@ -1380,7 +1362,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Set whether the microphone should be muted or not.
-     * @param {boolean} muted True to mute the mic.
+     * @param muted - True to mute the mic.
      * @returns the new mute state
      */
     public async setMicrophoneMuted(muted: boolean): Promise<boolean> {
@@ -1405,7 +1387,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      * If there are multiple audio tracks, <i>all</i> of the tracks need to be muted
      * for this to return true. This means if there are no audio tracks, this will
      * return true.
-     * @return {Boolean} True if the mic is muted, else false (including if the call
+     * @returns True if the mic is muted, else false (including if the call
      * is not set up yet).
      */
     public isMicrophoneMuted(): boolean {
@@ -1459,7 +1441,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Sends a DTMF digit to the other party
-     * @param digit The digit (nb. string - '#' and '*' are dtmf too)
+     * @param digit - The digit (nb. string - '#' and '*' are dtmf too)
      */
     public sendDtmfDigit(digit: string): void {
         for (const sender of this.peerConn!.getSenders()) {
@@ -1678,7 +1660,6 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Internal
-     * @param {Object} event
      */
     private gotLocalIceCandidate = (event: RTCPeerConnectionIceEvent): void => {
         if (event.candidate) {
@@ -1752,7 +1733,6 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Used by MatrixClient.
-     * @param {Object} msg
      */
     public async onAnswerReceived(event: MatrixEvent): Promise<void> {
         const content = event.getContent<MCallAnswer>();
@@ -2258,10 +2238,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     };
 
     /**
-     * Internal
-     * @param {string} eventType
-     * @param {Object} content
-     * @return {Promise}
+     * @internal
      */
     private async sendVoipEvent(eventType: string, content: object): Promise<void> {
         const realContent = Object.assign({}, content, {
@@ -2321,7 +2298,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Queue a candidate to be sent
-     * @param content The candidate to queue up, or null if candidates have finished being generated
+     * @param content - The candidate to queue up, or null if candidates have finished being generated
      *                and end-of-candidates should be signalled
      */
     private queueCandidate(content: RTCIceCandidate | null): void {
@@ -2615,7 +2592,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     /**
      * Place a call to this room with call feed.
-     * @param {CallFeed[]} callFeeds to use
+     * @param callFeeds - to use
      * @throws if you have not specified a listener for 'error' events.
      * @throws if have passed audio=false.
      */
@@ -2772,13 +2749,10 @@ export function supportsMatrixCall(): boolean {
  * Use client.createCall()
  *
  * Create a new Matrix call for the browser.
- * @param {MatrixClient} client The client instance to use.
- * @param {string} roomId The room the call is in.
- * @param {Object?} options DEPRECATED optional options map.
- * @param {boolean} options.forceTURN DEPRECATED whether relay through TURN should be
- * forced. This option is deprecated - use opts.forceTURN when creating the matrix client
- * since it's only possible to set this option on outbound calls.
- * @return {MatrixCall} the call or null if the browser doesn't support calling.
+ * @param client - The client instance to use.
+ * @param roomId - The room the call is in.
+ * @param options - DEPRECATED optional options map.
+ * @returns the call or null if the browser doesn't support calling.
  */
 export function createNewMatrixCall(
     client: MatrixClient,
diff --git a/src/webrtc/callEventHandler.ts b/src/webrtc/callEventHandler.ts
index 02cbe2d84d3..281b29b0e65 100644
--- a/src/webrtc/callEventHandler.ts
+++ b/src/webrtc/callEventHandler.ts
@@ -32,6 +32,16 @@ export enum CallEventHandlerEvent {
 }
 
 export type CallEventHandlerEventHandlerMap = {
+    /**
+     * Fires whenever an incoming call arrives.
+     * @param call - The incoming call.
+     * @example
+     * ```
+     * matrixClient.on("Call.incoming", function(call){
+     *   call.answer(); // auto-answer
+     * });
+     * ```
+     */
     [CallEventHandlerEvent.Incoming]: (call: MatrixCall) => void;
 };
 
diff --git a/src/webrtc/callFeed.ts b/src/webrtc/callFeed.ts
index 14abc30d22a..3ed84a58620 100644
--- a/src/webrtc/callFeed.ts
+++ b/src/webrtc/callFeed.ts
@@ -189,7 +189,7 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
 
     /**
      * Returns true if CallFeed is local, otherwise returns false
-     * @returns {boolean} is local?
+     * @returns is local?
      */
     public isLocal(): boolean {
         return this.userId === this.client.getUserId()
@@ -199,7 +199,7 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
     /**
      * Returns true if audio is muted or if there are no audio
      * tracks, otherwise returns false
-     * @returns {boolean} is audio muted?
+     * @returns is audio muted?
      */
     public isAudioMuted(): boolean {
         return this.stream.getAudioTracks().length === 0 || this.audioMuted;
@@ -208,7 +208,7 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
     /**
      * Returns true video is muted or if there are no video
      * tracks, otherwise returns false
-     * @returns {boolean} is video muted?
+     * @returns is video muted?
      */
     public isVideoMuted(): boolean {
         // We assume only one video track
@@ -224,7 +224,7 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
      * The stream will be different and new stream as remore parties are
      * concerned, but this can be used for convenience locally to set up
      * volume listeners automatically on the new stream etc.
-     * @param newStream new stream with which to replace the current one
+     * @param newStream - new stream with which to replace the current one
      */
     public setNewStream(newStream: MediaStream): void {
         this.updateStream(this.stream, newStream);
@@ -233,8 +233,8 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
     /**
      * Set one or both of feed's internal audio and video video mute state
      * Either value may be null to leave it as-is
-     * @param audioMuted is the feed's audio muted?
-     * @param videoMuted is the feed's video muted?
+     * @param audioMuted - is the feed's audio muted?
+     * @param videoMuted - is the feed's video muted?
      */
     public setAudioVideoMuted(audioMuted: boolean | null, videoMuted: boolean | null): void {
         if (audioMuted !== null) {
@@ -249,7 +249,7 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
 
     /**
      * Starts emitting volume_changed events where the emitter value is in decibels
-     * @param enabled emit volume changes
+     * @param enabled - emit volume changes
      */
     public measureVolumeActivity(enabled: boolean): void {
         if (enabled) {
diff --git a/src/webrtc/groupCall.ts b/src/webrtc/groupCall.ts
index 5941b6a3728..51e1a0a7835 100644
--- a/src/webrtc/groupCall.ts
+++ b/src/webrtc/groupCall.ts
@@ -63,6 +63,21 @@ export type GroupCallEventHandlerMap = {
     ) => void;
     [GroupCallEvent.LocalMuteStateChanged]: (audioMuted: boolean, videoMuted: boolean) => void;
     [GroupCallEvent.ParticipantsChanged]: (participants: Map<RoomMember, Map<string, ParticipantState>>) => void;
+    /**
+     * Fires whenever an error occurs when call.js encounters an issue with setting up the call.
+     * <p>
+     * The error given will have a code equal to either `MatrixCall.ERR_LOCAL_OFFER_FAILED` or
+     * `MatrixCall.ERR_NO_USER_MEDIA`. `ERR_LOCAL_OFFER_FAILED` is emitted when the local client
+     * fails to create an offer. `ERR_NO_USER_MEDIA` is emitted when the user has denied access
+     * to their audio/video hardware.
+     * @param err - The error raised by MatrixCall.
+     * @example
+     * ```
+     * matrixCall.on("error", function(err){
+     *   console.error(err.code, err);
+     * });
+     * ```
+     */
     [GroupCallEvent.Error]: (error: GroupCallError) => void;
 };
 
@@ -302,7 +317,7 @@ export class GroupCall extends TypedEventEmitter<
 
     /**
      * Executes the given callback on all calls in this group call.
-     * @param f The callback.
+     * @param f - The callback.
      */
     public forEachCall(f: (call: MatrixCall) => void): void {
         for (const deviceMap of this.calls.values()) {
@@ -512,8 +527,8 @@ export class GroupCall extends TypedEventEmitter<
 
     /**
      * Sets the mute state of the local participants's microphone.
-     * @param {boolean} muted Whether to mute the microphone
-     * @returns {Promise<boolean>} Whether muting/unmuting was successful
+     * @param muted - Whether to mute the microphone
+     * @returns Whether muting/unmuting was successful
      */
     public async setMicrophoneMuted(muted: boolean): Promise<boolean> {
         // hasAudioDevice can block indefinitely if the window has lost focus,
@@ -575,8 +590,8 @@ export class GroupCall extends TypedEventEmitter<
 
     /**
      * Sets the mute state of the local participants's video.
-     * @param {boolean} muted Whether to mute the video
-     * @returns {Promise<boolean>} Whether muting/unmuting was successful
+     * @param muted - Whether to mute the video
+     * @returns Whether muting/unmuting was successful
      */
     public async setLocalVideoMuted(muted: boolean): Promise<boolean> {
         // hasAudioDevice can block indefinitely if the window has lost focus,
@@ -733,8 +748,8 @@ export class GroupCall extends TypedEventEmitter<
     /**
      * Determines whether a given participant expects us to call them (versus
      * them calling us).
-     * @param userId The participant's user ID.
-     * @param deviceId The participant's device ID.
+     * @param userId - The participant's user ID.
+     * @param deviceId - The participant's device ID.
      * @returns Whether we need to place an outgoing call to the participant.
      */
     private wantsOutgoingCall(userId: string, deviceId: string): boolean {
@@ -1249,9 +1264,9 @@ export class GroupCall extends TypedEventEmitter<
 
     /**
      * Updates the local user's member state with the devices returned by the given function.
-     * @param fn A function from the current devices to the new devices. If it
+     * @param fn - A function from the current devices to the new devices. If it
      *   returns null, the update will be skipped.
-     * @param keepAlive Whether the request should outlive the window.
+     * @param keepAlive - Whether the request should outlive the window.
      */
     private async updateDevices(
         fn: (devices: IGroupCallRoomMemberDevice[]) => IGroupCallRoomMemberDevice[] | null,
diff --git a/src/webrtc/mediaHandler.ts b/src/webrtc/mediaHandler.ts
index c7c84876bf9..46943ae386a 100644
--- a/src/webrtc/mediaHandler.ts
+++ b/src/webrtc/mediaHandler.ts
@@ -67,7 +67,7 @@ export class MediaHandler extends TypedEventEmitter<
 
     /**
      * Set an audio input device to use for MatrixCalls
-     * @param {string} deviceId the identifier for the device
+     * @param deviceId - the identifier for the device
      * undefined treated as unset
      */
     public async setAudioInput(deviceId: string): Promise<void> {
@@ -81,7 +81,7 @@ export class MediaHandler extends TypedEventEmitter<
 
     /**
      * Set audio settings for MatrixCalls
-     * @param {AudioSettings} opts audio options to set
+     * @param opts - audio options to set
      */
     public async setAudioSettings(opts: AudioSettings): Promise<void> {
         logger.info("Setting audio settings to", opts);
@@ -92,7 +92,7 @@ export class MediaHandler extends TypedEventEmitter<
 
     /**
      * Set a video input device to use for MatrixCalls
-     * @param {string} deviceId the identifier for the device
+     * @param deviceId - the identifier for the device
      * undefined treated as unset
      */
     public async setVideoInput(deviceId: string): Promise<void> {
@@ -106,8 +106,8 @@ export class MediaHandler extends TypedEventEmitter<
 
     /**
      * Set media input devices to use for MatrixCalls
-     * @param {string} audioInput the identifier for the audio device
-     * @param {string} videoInput the identifier for the video device
+     * @param audioInput - the identifier for the audio device
+     * @param videoInput - the identifier for the video device
      * undefined treated as unset
      */
     public async setMediaInputs(audioInput: string, videoInput: string): Promise<void> {
@@ -191,10 +191,10 @@ export class MediaHandler extends TypedEventEmitter<
     }
 
     /**
-     * @param audio should have an audio track
-     * @param video should have a video track
-     * @param reusable is allowed to be reused by the MediaHandler
-     * @returns {MediaStream} based on passed parameters
+     * @param audio - should have an audio track
+     * @param video - should have a video track
+     * @param reusable - is allowed to be reused by the MediaHandler
+     * @returns based on passed parameters
      */
     public async getUserMediaStream(audio: boolean, video: boolean, reusable = true): Promise<MediaStream> {
         const shouldRequestAudio = audio && await this.hasAudioDevice();
@@ -296,9 +296,9 @@ export class MediaHandler extends TypedEventEmitter<
     }
 
     /**
-     * @param desktopCapturerSourceId sourceId for Electron DesktopCapturer
-     * @param reusable is allowed to be reused by the MediaHandler
-     * @returns {MediaStream} based on passed parameters
+     * @param desktopCapturerSourceId - sourceId for Electron DesktopCapturer
+     * @param reusable - is allowed to be reused by the MediaHandler
+     * @returns based on passed parameters
      */
     public async getScreensharingStream(opts: IScreensharingOpts = {}, reusable = true): Promise<MediaStream> {
         let stream: MediaStream;
diff --git a/yarn.lock b/yarn.lock
index b96adf0ef9a..9a2f147943c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1093,6 +1093,15 @@
     uuid "8.3.2"
     xml "1.0.1"
 
+"@es-joy/jsdoccomment@~0.36.1":
+  version "0.36.1"
+  resolved "https://registry.yarnpkg.com/@es-joy/jsdoccomment/-/jsdoccomment-0.36.1.tgz#c37db40da36e4b848da5fd427a74bae3b004a30f"
+  integrity sha512-922xqFsTpHs6D0BUiG4toiyPOMc8/jafnWKxz1KWgS4XzKPy2qXf1Pe6UFuNSCQqt6tOuhAWXBNuuyUhJmw9Vg==
+  dependencies:
+    comment-parser "1.3.1"
+    esquery "^1.4.0"
+    jsdoc-type-pratt-parser "~3.1.0"
+
 "@eslint-community/eslint-utils@^4.1.0":
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.1.2.tgz#14ca568ddaa291dd19a4a54498badc18c6cfab78"
@@ -1427,6 +1436,21 @@
   version "3.2.14"
   resolved "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz#acd96c00a881d0f462e1f97a56c73742c8dbc984"
 
+"@microsoft/tsdoc-config@0.16.2":
+  version "0.16.2"
+  resolved "https://registry.yarnpkg.com/@microsoft/tsdoc-config/-/tsdoc-config-0.16.2.tgz#b786bb4ead00d54f53839a458ce626c8548d3adf"
+  integrity sha512-OGiIzzoBLgWWR0UdRJX98oYO+XKGf7tiK4Zk6tQ/E4IJqGCe7dvkTvgDZV5cFJUzLGDOjeAXrnZoA6QkVySuxw==
+  dependencies:
+    "@microsoft/tsdoc" "0.14.2"
+    ajv "~6.12.6"
+    jju "~1.4.0"
+    resolve "~1.19.0"
+
+"@microsoft/tsdoc@0.14.2":
+  version "0.14.2"
+  resolved "https://registry.yarnpkg.com/@microsoft/tsdoc/-/tsdoc-0.14.2.tgz#c3ec604a0b54b9a9b87e9735dfc59e1a5da6a5fb"
+  integrity sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==
+
 "@nicolo-ribaudo/chokidar-2@2.1.8-no-fsevents.3":
   version "2.1.8-no-fsevents.3"
   resolved "https://registry.yarnpkg.com/@nicolo-ribaudo/chokidar-2/-/chokidar-2-2.1.8-no-fsevents.3.tgz#323d72dd25103d0c4fbdce89dadf574a787b1f9b"
@@ -1781,7 +1805,7 @@
   dependencies:
     "@types/yargs-parser" "*"
 
-"@typescript-eslint/eslint-plugin@^5.6.0":
+"@typescript-eslint/eslint-plugin@^5.45.0":
   version "5.45.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.45.0.tgz#ffa505cf961d4844d38cfa19dcec4973a6039e41"
   integrity sha512-CXXHNlf0oL+Yg021cxgOdMHNTXD17rHkq7iW6RFHoybdFgQBjU3yIXhhcPpGwr1CjZlo6ET8C6tzX5juQoXeGA==
@@ -1796,7 +1820,7 @@
     semver "^7.3.7"
     tsutils "^3.21.0"
 
-"@typescript-eslint/parser@^5.6.0":
+"@typescript-eslint/parser@^5.45.0":
   version "5.45.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.45.0.tgz#b18a5f6b3cf1c2b3e399e9d2df4be40d6b0ddd0e"
   integrity sha512-brvs/WSM4fKUmF5Ot/gEve6qYiCMjm6w4HkHPfS6ZNmxTS0m0iNN4yOChImaCkqc1hRwFGqUyanMXuGal6oyyQ==
@@ -1948,7 +1972,7 @@ agent-base@6:
   dependencies:
     debug "4"
 
-ajv@^6.10.0, ajv@^6.12.4:
+ajv@^6.10.0, ajv@^6.12.4, ajv@~6.12.6:
   version "6.12.6"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
@@ -2757,6 +2781,11 @@ commander@^4.0.1:
   resolved "https://registry.yarnpkg.com/commander/-/commander-4.1.1.tgz#9fd602bd936294e9e9ef46a3f4d6964044b18068"
   integrity sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==
 
+comment-parser@1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/comment-parser/-/comment-parser-1.3.1.tgz#3d7ea3adaf9345594aedee6563f422348f165c1b"
+  integrity sha512-B52sN2VNghyq5ofvUsqZjmk6YkihBX5vMSChmSK9v4ShjKf3Vk5Xcmgpw4o+iIgtrnM/u5FiMpz9VKb8lpBveA==
+
 commondir@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
@@ -3338,11 +3367,32 @@ eslint-plugin-import@^2.26.0:
     resolve "^1.22.0"
     tsconfig-paths "^3.14.1"
 
+eslint-plugin-jsdoc@^39.6.4:
+  version "39.6.4"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-39.6.4.tgz#b940aebd3eea26884a0d341785d2dc3aba6a38a7"
+  integrity sha512-fskvdLCfwmPjHb6e+xNGDtGgbF8X7cDwMtVLAP2WwSf9Htrx68OAx31BESBM1FAwsN2HTQyYQq7m4aW4Q4Nlag==
+  dependencies:
+    "@es-joy/jsdoccomment" "~0.36.1"
+    comment-parser "1.3.1"
+    debug "^4.3.4"
+    escape-string-regexp "^4.0.0"
+    esquery "^1.4.0"
+    semver "^7.3.8"
+    spdx-expression-parse "^3.0.1"
+
 eslint-plugin-matrix-org@^0.8.0:
   version "0.8.0"
   resolved "https://registry.yarnpkg.com/eslint-plugin-matrix-org/-/eslint-plugin-matrix-org-0.8.0.tgz#daa1396900a8cb1c1d88f1a370e45fc32482cd9e"
   integrity sha512-/Poz/F8lXYDsmQa29iPSt+kO+Jn7ArvRdq10g0CCk8wbRS0sb2zb6fvd9xL1BgR5UDQL771V0l8X32etvY5yKA==
 
+eslint-plugin-tsdoc@^0.2.17:
+  version "0.2.17"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-tsdoc/-/eslint-plugin-tsdoc-0.2.17.tgz#27789495bbd8778abbf92db1707fec2ed3dfe281"
+  integrity sha512-xRmVi7Zx44lOBuYqG8vzTXuL6IdGOeF9nHX17bjJ8+VE6fsxpdGem0/SBTmAwgYMKYB1WBkqRJVQ+n8GK041pA==
+  dependencies:
+    "@microsoft/tsdoc" "0.14.2"
+    "@microsoft/tsdoc-config" "0.16.2"
+
 eslint-plugin-unicorn@^45.0.0:
   version "45.0.1"
   resolved "https://registry.yarnpkg.com/eslint-plugin-unicorn/-/eslint-plugin-unicorn-45.0.1.tgz#2307f4620502fd955c819733ce1276bed705b736"
@@ -4156,7 +4206,7 @@ is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.7:
   resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.7.tgz#3bc2a85ea742d9e36205dcacdd72ca1fdc51b055"
   integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==
 
-is-core-module@^2.10.0, is-core-module@^2.8.1, is-core-module@^2.9.0:
+is-core-module@^2.1.0, is-core-module@^2.10.0, is-core-module@^2.8.1, is-core-module@^2.9.0:
   version "2.11.0"
   resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.11.0.tgz#ad4cb3e3863e814523c96f3f58d26cc570ff0144"
   integrity sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==
@@ -4809,6 +4859,11 @@ jest@^29.0.0:
     import-local "^3.0.2"
     jest-cli "^29.3.1"
 
+jju@~1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/jju/-/jju-1.4.0.tgz#a3abe2718af241a2b2904f84a625970f389ae32a"
+  integrity sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==
+
 js-sdsl@^4.1.4:
   version "4.1.5"
   resolved "https://registry.yarnpkg.com/js-sdsl/-/js-sdsl-4.1.5.tgz#1ff1645e6b4d1b028cd3f862db88c9d887f26e2a"
@@ -4839,6 +4894,11 @@ js-yaml@^4.1.0:
   dependencies:
     argparse "^2.0.1"
 
+jsdoc-type-pratt-parser@~3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-3.1.0.tgz#a4a56bdc6e82e5865ffd9febc5b1a227ff28e67e"
+  integrity sha512-MgtD0ZiCDk9B+eI73BextfRrVQl0oyzRG8B2BjORts6jbunj4ScKPcyXGTbB6eXL4y9TzxCm6hyeLq/2ASzNdw==
+
 jsdom@^20.0.0:
   version "20.0.2"
   resolved "https://registry.yarnpkg.com/jsdom/-/jsdom-20.0.2.tgz#65ccbed81d5e877c433f353c58bb91ff374127db"
@@ -5568,7 +5628,7 @@ path-key@^3.0.0, path-key@^3.1.0:
   resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
-path-parse@^1.0.7:
+path-parse@^1.0.6, path-parse@^1.0.7:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
   integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
@@ -6119,6 +6179,14 @@ resolve@^1.1.4, resolve@^1.1.6, resolve@^1.10.0, resolve@^1.14.2, resolve@^1.17.
     path-parse "^1.0.7"
     supports-preserve-symlinks-flag "^1.0.0"
 
+resolve@~1.19.0:
+  version "1.19.0"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.19.0.tgz#1af5bf630409734a067cae29318aac7fa29a267c"
+  integrity sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==
+  dependencies:
+    is-core-module "^2.1.0"
+    path-parse "^1.0.6"
+
 retry@^0.13.1:
   version "0.13.1"
   resolved "https://registry.yarnpkg.com/retry/-/retry-0.13.1.tgz#185b1587acf67919d63b357349e03537b2484658"
@@ -6344,7 +6412,7 @@ spdx-exceptions@^2.1.0:
   resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d"
   integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==
 
-spdx-expression-parse@^3.0.0:
+spdx-expression-parse@^3.0.0, spdx-expression-parse@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679"
   integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==

From 16d791b0386203db9d9650768548de97f8e81245 Mon Sep 17 00:00:00 2001
From: Germain <germains@element.io>
Date: Thu, 8 Dec 2022 09:54:10 +0000
Subject: [PATCH 31/60] Cache read receipts for unknown threads (#2953)

---
 spec/integ/matrix-client-syncing.spec.ts | 53 +++++++++++++++++++++++-
 src/models/room.ts                       | 36 ++++++++++++----
 2 files changed, 80 insertions(+), 9 deletions(-)

diff --git a/spec/integ/matrix-client-syncing.spec.ts b/spec/integ/matrix-client-syncing.spec.ts
index 5ddcb0aa01c..94e2361d7fe 100644
--- a/spec/integ/matrix-client-syncing.spec.ts
+++ b/spec/integ/matrix-client-syncing.spec.ts
@@ -33,8 +33,9 @@ import {
     IJoinedRoom,
     IStateEvent,
     IMinimalEvent,
-    NotificationCountType, IEphemeral,
+    NotificationCountType, IEphemeral, Room,
 } from "../../src";
+import { ReceiptType } from '../../src/@types/read_receipts';
 import { UNREAD_THREAD_NOTIFICATIONS } from '../../src/@types/sync';
 import * as utils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
@@ -1312,7 +1313,8 @@ describe("MatrixClient syncing", () => {
                 join: {
                     [roomOne]: {
                         ephemeral: {
-                            events: [],
+                            events: [
+                            ],
                         } as IEphemeral,
                         timeline: {
                             events: [
@@ -1397,6 +1399,9 @@ describe("MatrixClient syncing", () => {
             rooms: {
                 join: {
                     [roomOne]: {
+                        ephemeral: {
+                            events: [],
+                        },
                         timeline: {
                             events: [
                                 utils.mkMessage({
@@ -1455,6 +1460,50 @@ describe("MatrixClient syncing", () => {
                 expect(room!.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight)).toBe(2);
             });
         });
+
+        it("caches unknown threads receipts and replay them when the thread is created", async () => {
+            const THREAD_ID = "$unknownthread:localhost";
+
+            const receipt = {
+                type: "m.receipt",
+                room_id: "!foo:bar",
+                content: {
+                    "$event1:localhost": {
+                        [ReceiptType.Read]: {
+                            "@alice:localhost": { ts: 666, thread_id: THREAD_ID },
+                        },
+                    },
+                },
+            };
+            syncData.rooms.join[roomOne].ephemeral.events = [receipt];
+
+            httpBackend!.when("GET", "/sync").respond(200, syncData);
+            client!.startClient();
+
+            return Promise.all([
+                httpBackend!.flushAllExpected(),
+                awaitSyncEvent(),
+            ]).then(() => {
+                const room = client?.getRoom(roomOne);
+                expect(room).toBeInstanceOf(Room);
+
+                expect(room?.cachedThreadReadReceipts.has(THREAD_ID)).toBe(true);
+
+                const thread = room!.createThread(THREAD_ID, undefined, [], true);
+
+                expect(room?.cachedThreadReadReceipts.has(THREAD_ID)).toBe(false);
+
+                const receipt = thread.getReadReceiptForUserId("@alice:localhost");
+
+                expect(receipt).toStrictEqual({
+                    "data": {
+                        "thread_id": "$unknownthread:localhost",
+                        "ts": 666,
+                    },
+                    "eventId": "$event1:localhost",
+                });
+            });
+        });
     });
 
     describe("of a room", () => {
diff --git a/src/models/room.ts b/src/models/room.ts
index 48de9a58c1b..95c33614c74 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -311,6 +311,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     private txnToEvent: Record<string, MatrixEvent> = {}; // Pending in-flight requests { string: MatrixEvent }
     private notificationCounts: NotificationCount = {};
     private readonly threadNotifications = new Map<string, NotificationCount>();
+    public readonly cachedThreadReadReceipts = new Map<string, { event: MatrixEvent, synthetic: boolean }[]>();
     private readonly timelineSets: EventTimelineSet[];
     public readonly threadsTimelineSets: EventTimelineSet[] = [];
     // any filtered timeline sets we're maintaining for this room
@@ -2146,6 +2147,16 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             this.updateThreadRootEvents(thread, toStartOfTimeline, false);
         }
 
+        // Pulling all the cached thread read receipts we've discovered when we
+        // did an initial sync, and applying them to the thread now that it exists
+        // on the client side
+        if (this.cachedThreadReadReceipts.has(threadId)) {
+            for (const { event, synthetic } of this.cachedThreadReadReceipts.get(threadId)!) {
+                this.addReceipt(event, synthetic);
+            }
+            this.cachedThreadReadReceipts.delete(threadId);
+        }
+
         this.emit(ThreadEvent.New, thread, toStartOfTimeline);
 
         return thread;
@@ -2727,13 +2738,24 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                     const receiptDestination: Thread | this | undefined = receiptForMainTimeline
                         ? this
                         : this.threads.get(receipt.thread_id ?? "");
-                    receiptDestination?.addReceiptToStructure(
-                        eventId,
-                        receiptType as ReceiptType,
-                        userId,
-                        receipt,
-                        synthetic,
-                    );
+
+                    if (receiptDestination) {
+                        receiptDestination.addReceiptToStructure(
+                            eventId,
+                            receiptType as ReceiptType,
+                            userId,
+                            receipt,
+                            synthetic,
+                        );
+                    } else {
+                        // The thread does not exist locally, keep the read receipt
+                        // in a cache locally, and re-apply  the `addReceipt` logic
+                        // when the thread is created
+                        this.cachedThreadReadReceipts.set(receipt.thread_id!, [
+                            ...(this.cachedThreadReadReceipts.get(receipt.thread_id!) ?? []),
+                            { event, synthetic },
+                        ]);
+                    }
                 });
             });
         });

From 224e592701003eb3ba4800bbb9e136e3cb317a0c Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Thu, 8 Dec 2022 10:43:20 +0000
Subject: [PATCH 32/60] Fix `examples/browser/browserTest.js` (#2952)

This seems to have been broken for ages
---
 examples/browser/README.md      | 4 ++--
 examples/browser/browserTest.js | 8 ++------
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/examples/browser/README.md b/examples/browser/README.md
index 1253d80009c..45c1d20217c 100644
--- a/examples/browser/README.md
+++ b/examples/browser/README.md
@@ -1,9 +1,9 @@
 To try it out, **you must build the SDK first** and then host this folder:
 
 ```
- $ npm run build
+ $ yarn build
  $ cd examples/browser
- $ python -m SimpleHTTPServer 8003
+ $ python -m http.server 8003
 ```
 
 Then visit ``http://localhost:8003``.
diff --git a/examples/browser/browserTest.js b/examples/browser/browserTest.js
index e6623b382b6..891dd176b06 100644
--- a/examples/browser/browserTest.js
+++ b/examples/browser/browserTest.js
@@ -1,11 +1,7 @@
 console.log("Loading browser sdk");
 
-var client = matrixcs.createClient("https://matrix.org");
-client.publicRooms(function (err, data) {
-    if (err) {
-	   console.error("err %s", JSON.stringify(err));
-       return;
-    }
+var client = matrixcs.createClient({baseUrl: "https://matrix.org"});
+client.publicRooms().then(function (data) {
     console.log("data %s [...]", JSON.stringify(data).substring(0, 100));
     console.log("Congratulations! The SDK is working on the browser!");
     var result = document.getElementById("result");

From 39cf212628ec008a3c9c38eac165a5ff2a8e25c7 Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Thu, 8 Dec 2022 11:53:38 +0000
Subject: [PATCH 33/60] Expose a new 'userHasCrossSigningKeys' method (#2950)

---
 spec/unit/crypto/cross-signing.spec.ts | 66 +++++++++++++++++++++++++-
 src/client.ts                          | 13 +++++
 src/crypto/index.ts                    | 13 +++++
 3 files changed, 91 insertions(+), 1 deletion(-)

diff --git a/spec/unit/crypto/cross-signing.spec.ts b/spec/unit/crypto/cross-signing.spec.ts
index fe5b37eb206..99ad5d0dafe 100644
--- a/spec/unit/crypto/cross-signing.spec.ts
+++ b/spec/unit/crypto/cross-signing.spec.ts
@@ -23,7 +23,7 @@ import HttpBackend from "matrix-mock-request";
 import * as olmlib from "../../../src/crypto/olmlib";
 import { MatrixError } from '../../../src/http-api';
 import { logger } from '../../../src/logger';
-import { ICrossSigningKey, ICreateClientOpts, ISignedKey } from '../../../src/client';
+import { ICrossSigningKey, ICreateClientOpts, ISignedKey, MatrixClient } from '../../../src/client';
 import { CryptoEvent, IBootstrapCrossSigningOpts } from '../../../src/crypto';
 import { IDevice } from '../../../src/crypto/deviceinfo';
 import { TestClient } from '../../TestClient';
@@ -1137,3 +1137,67 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 });
+
+describe("userHasCrossSigningKeys", function() {
+    if (!global.Olm) {
+        return;
+    }
+
+    beforeAll(() => {
+        return global.Olm.init();
+    });
+
+    let aliceClient: MatrixClient;
+    let httpBackend: HttpBackend;
+    beforeEach(async () => {
+        const testClient = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
+        aliceClient = testClient.client;
+        httpBackend = testClient.httpBackend;
+    });
+
+    afterEach(() => {
+        aliceClient.stopClient();
+    });
+
+    it("should download devices and return true if one is a cross-signing key", async () => {
+        httpBackend
+            .when("POST", "/keys/query")
+            .respond(200, {
+                "master_keys": {
+                    "@alice:example.com": {
+                        user_id: "@alice:example.com",
+                        usage: ["master"],
+                        keys: {
+                            "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
+                            "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
+                        },
+                    },
+                },
+            });
+
+        let result: boolean;
+        await Promise.all([
+            httpBackend.flush("/keys/query"),
+            aliceClient.userHasCrossSigningKeys().then((res) => {result = res;}),
+        ]);
+        expect(result!).toBeTruthy();
+    });
+
+    it("should download devices and return false if there is no cross-signing key", async () => {
+        httpBackend
+            .when("POST", "/keys/query")
+            .respond(200, {});
+
+        let result: boolean;
+        await Promise.all([
+            httpBackend.flush("/keys/query"),
+            aliceClient.userHasCrossSigningKeys().then((res) => {result = res;}),
+        ]);
+        expect(result!).toBeFalsy();
+    });
+
+    it("throws an error if crypto is disabled", () => {
+        aliceClient.crypto = undefined;
+        expect(() => aliceClient.userHasCrossSigningKeys()).toThrowError("encryption disabled");
+    });
+});
diff --git a/src/client.ts b/src/client.ts
index fba259a5671..ce44d32fd66 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -2473,6 +2473,19 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         this.crypto.prepareToEncrypt(room);
     }
 
+    /**
+     * Checks if the user has previously published cross-signing keys
+     *
+     * This means downloading the devicelist for the user and checking if the list includes
+     * the cross-signing pseudo-device.
+     */
+    public userHasCrossSigningKeys(): Promise<boolean> {
+        if (!this.crypto) {
+            throw new Error("End-to-end encryption disabled");
+        }
+        return this.crypto.userHasCrossSigningKeys();
+    }
+
     /**
      * Checks whether cross signing:
      * - is enabled on this account and trusted by this device
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 65b43a635a0..9191522da25 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -718,6 +718,19 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         }
     }
 
+    /**
+     * Checks if the user has previously published cross-signing keys
+     *
+     * This means downloading the devicelist for the user and checking if the list includes
+     * the cross-signing pseudo-device.
+     *
+     * @internal
+     */
+    public async userHasCrossSigningKeys(): Promise<boolean> {
+        await this.downloadKeys([this.userId]);
+        return this.deviceList.getStoredCrossSigningForUser(this.userId) !== null;
+    }
+
     /**
      * Checks whether cross signing:
      * - is enabled on this account and trusted by this device

From ae849fdd46cd556e9916fadaff625b961e8c1403 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=A0imon=20Brandner?= <simon.bra.ag@gmail.com>
Date: Thu, 8 Dec 2022 19:51:05 +0100
Subject: [PATCH 34/60] Minor VoIP stack improvements (#2946)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Add `IGroupCallRoomState`

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Export values into `const`s

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Add `should correctly emit LengthChanged`

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Add `ICE disconnected timeout`

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Improve typing

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Don't cast `getContent()`

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Use `Date.now()` for call length

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Type fix

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>
---
 spec/test-utils/webrtc.ts     |  4 +++
 spec/unit/webrtc/call.spec.ts | 46 +++++++++++++++++++++++++++++++++++
 src/webrtc/call.ts            | 19 +++++++++------
 src/webrtc/groupCall.ts       | 28 ++++++++++++++-------
 4 files changed, 81 insertions(+), 16 deletions(-)

diff --git a/spec/test-utils/webrtc.ts b/spec/test-utils/webrtc.ts
index c2f1a0b25a3..84d1f4868f4 100644
--- a/spec/test-utils/webrtc.ts
+++ b/spec/test-utils/webrtc.ts
@@ -115,12 +115,14 @@ export class MockRTCPeerConnection {
 
     private negotiationNeededListener?: () => void;
     public iceCandidateListener?: (e: RTCPeerConnectionIceEvent) => void;
+    public iceConnectionStateChangeListener?: () => void;
     public onTrackListener?: (e: RTCTrackEvent) => void;
     public needsNegotiation = false;
     public readyToNegotiate: Promise<void>;
     private onReadyToNegotiate?: () => void;
     public localDescription: RTCSessionDescription;
     public signalingState: RTCSignalingState = "stable";
+    public iceConnectionState: RTCIceConnectionState = "connected";
     public transceivers: MockRTCRtpTransceiver[] = [];
 
     public static triggerAllNegotiations(): void {
@@ -156,6 +158,8 @@ export class MockRTCPeerConnection {
             this.negotiationNeededListener = listener;
         } else if (type == 'icecandidate') {
             this.iceCandidateListener = listener;
+        } else if (type === 'iceconnectionstatechange') {
+            this.iceConnectionStateChangeListener = listener;
         } else if (type == 'track') {
             this.onTrackListener = listener;
         }
diff --git a/spec/unit/webrtc/call.spec.ts b/spec/unit/webrtc/call.spec.ts
index 1d4f9f03401..eb5d4c18e80 100644
--- a/spec/unit/webrtc/call.spec.ts
+++ b/spec/unit/webrtc/call.spec.ts
@@ -1458,4 +1458,50 @@ describe('Call', function() {
             expect(call.hasPeerConnection).toBe(true);
         });
     });
+
+    it("should correctly emit LengthChanged", async () => {
+        const advanceByArray = [2, 3, 5];
+        const lengthChangedListener = jest.fn();
+
+        jest.useFakeTimers();
+        call.addListener(CallEvent.LengthChanged, lengthChangedListener);
+        await fakeIncomingCall(client, call, "1");
+        (call.peerConn as unknown as MockRTCPeerConnection).iceConnectionStateChangeListener!();
+
+        let hasAdvancedBy = 0;
+        for (const advanceBy of advanceByArray) {
+            jest.advanceTimersByTime(advanceBy * 1000);
+            hasAdvancedBy += advanceBy;
+
+            expect(lengthChangedListener).toHaveBeenCalledTimes(hasAdvancedBy);
+            expect(lengthChangedListener).toBeCalledWith(hasAdvancedBy);
+        }
+    });
+
+    describe("ICE disconnected timeout", () => {
+        let mockPeerConn: MockRTCPeerConnection;
+
+        beforeEach(async () => {
+            jest.useFakeTimers();
+            jest.spyOn(call, "hangup");
+
+            await fakeIncomingCall(client, call, "1");
+
+            mockPeerConn = (call.peerConn as unknown as MockRTCPeerConnection);
+            mockPeerConn.iceConnectionState = "disconnected";
+            mockPeerConn.iceConnectionStateChangeListener!();
+        });
+
+        it("should hang up after being disconnected for 30 seconds", () => {
+            jest.advanceTimersByTime(31 * 1000);
+            expect(call.hangup).toHaveBeenCalledWith(CallErrorCode.IceFailed, false);
+        });
+
+        it("should not hangup if we've managed to re-connect", () => {
+            mockPeerConn.iceConnectionState = "connected";
+            mockPeerConn.iceConnectionStateChangeListener!();
+            jest.advanceTimersByTime(31 * 1000);
+            expect(call.hangup).not.toHaveBeenCalled();
+        });
+    });
 });
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index c9bcac1124c..0d1af81a369 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -253,7 +253,11 @@ const VOIP_PROTO_VERSION = "1";
 const FALLBACK_ICE_SERVER = 'stun:turn.matrix.org';
 
 /** The length of time a call can be ringing for. */
-const CALL_TIMEOUT_MS = 60000;
+const CALL_TIMEOUT_MS = 60 * 1000; // ms
+/** The time after which we increment callLength */
+const CALL_LENGTH_INTERVAL = 1000; // ms
+/** The time after which we end the call, if ICE got disconnected */
+const ICE_DISCONNECTED_TIMEOUT = 30 * 1000; // ms
 
 export class CallError extends Error {
     public readonly code: string;
@@ -376,7 +380,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     private remoteSDPStreamMetadata?: SDPStreamMetadata;
 
     private callLengthInterval?: ReturnType<typeof setInterval>;
-    private callLength = 0;
+    private callStartTime?: number;
 
     private opponentDeviceId?: string;
     private opponentDeviceInfo?: DeviceInfo;
@@ -2083,11 +2087,12 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             clearTimeout(this.iceDisconnectedTimeout);
             this.state = CallState.Connected;
 
-            if (!this.callLengthInterval) {
+            if (!this.callLengthInterval && !this.callStartTime) {
+                this.callStartTime = Date.now();
+
                 this.callLengthInterval = setInterval(() => {
-                    this.callLength++;
-                    this.emit(CallEvent.LengthChanged, this.callLength);
-                }, 1000);
+                    this.emit(CallEvent.LengthChanged, Math.round((Date.now() - this.callStartTime!) / 1000));
+                }, CALL_LENGTH_INTERVAL);
             }
         } else if (this.peerConn?.iceConnectionState == 'failed') {
             // Firefox for Android does not yet have support for restartIce()
@@ -2104,7 +2109,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             this.iceDisconnectedTimeout = setTimeout(() => {
                 logger.info(`Hanging up call ${this.callId} (ICE disconnected for too long)`);
                 this.hangup(CallErrorCode.IceFailed, false);
-            }, 30 * 1000);
+            }, ICE_DISCONNECTED_TIMEOUT);
             this.state = CallState.Connecting;
         }
 
diff --git a/src/webrtc/groupCall.ts b/src/webrtc/groupCall.ts
index 51e1a0a7835..58281b0e9eb 100644
--- a/src/webrtc/groupCall.ts
+++ b/src/webrtc/groupCall.ts
@@ -121,9 +121,17 @@ export interface IGroupCallDataChannelOptions {
     protocol: string;
 }
 
+export interface IGroupCallRoomState {
+    "m.intent": GroupCallIntent;
+    "m.type": GroupCallType;
+    "io.element.ptt"?: boolean;
+    // TODO: Specify data-channels
+    "dataChannelsEnabled"?: boolean;
+    "dataChannelOptions"?: IGroupCallDataChannelOptions;
+}
+
 export interface IGroupCallRoomMemberFeed {
     purpose: SDPStreamMetadataPurpose;
-    // TODO: Sources for adaptive bitrate
 }
 
 export interface IGroupCallRoomMemberDevice {
@@ -228,17 +236,19 @@ export class GroupCall extends TypedEventEmitter<
         this.client.groupCallEventHandler!.groupCalls.set(this.room.roomId, this);
         this.client.emit(GroupCallEventHandlerEvent.Outgoing, this);
 
+        const groupCallState: IGroupCallRoomState = {
+            "m.intent": this.intent,
+            "m.type": this.type,
+            "io.element.ptt": this.isPtt,
+            // TODO: Specify data-channels better
+            "dataChannelsEnabled": this.dataChannelsEnabled,
+            "dataChannelOptions": this.dataChannelsEnabled ? this.dataChannelOptions : undefined,
+        };
+
         await this.client.sendStateEvent(
             this.room.roomId,
             EventType.GroupCallPrefix,
-            {
-                "m.intent": this.intent,
-                "m.type": this.type,
-                "io.element.ptt": this.isPtt,
-                // TODO: Specify datachannels
-                "dataChannelsEnabled": this.dataChannelsEnabled,
-                "dataChannelOptions": this.dataChannelOptions,
-            },
+            groupCallState,
             this.groupCallId,
         );
 

From 08a9073bd58708494d918fbba8a3e3443cdc8118 Mon Sep 17 00:00:00 2001
From: Michael Weimann <michaelw@matrix.org>
Date: Fri, 9 Dec 2022 09:34:01 +0100
Subject: [PATCH 35/60] Add prettier

---
 .eslintrc.js    |  2 --
 .prettierignore | 20 ++++++++++++++++++++
 .prettierrc.js  |  1 +
 package.json    |  8 +++++---
 yarn.lock       | 15 ++++++++++++---
 5 files changed, 38 insertions(+), 8 deletions(-)
 create mode 100644 .prettierignore
 create mode 100644 .prettierrc.js

diff --git a/.eslintrc.js b/.eslintrc.js
index c1cc4dc4caa..c73e8a44d3f 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -36,8 +36,6 @@ module.exports = {
         }],
         "arrow-parens": "off",
         "prefer-promise-reject-errors": "off",
-        "quotes": "off",
-        "indent": "off",
         "no-constant-condition": "off",
         "no-async-promise-executor": "off",
         // We use a `logger` intermediary module
diff --git a/.prettierignore b/.prettierignore
new file mode 100644
index 00000000000..4e86facef78
--- /dev/null
+++ b/.prettierignore
@@ -0,0 +1,20 @@
+/_docs
+.DS_Store
+
+/.npmrc
+/*.log
+package-lock.json
+.lock-wscript
+build/Release
+coverage
+lib-cov
+out
+/dist
+/lib
+
+# version file and tarball created by `npm pack` / `yarn pack`
+/git-revision.txt
+/matrix-js-sdk-*.tgz
+
+.vscode
+.vscode/
diff --git a/.prettierrc.js b/.prettierrc.js
new file mode 100644
index 00000000000..6a17910f1a0
--- /dev/null
+++ b/.prettierrc.js
@@ -0,0 +1 @@
+module.exports = require("eslint-plugin-matrix-org/.prettierrc.js");
diff --git a/package.json b/package.json
index 2685e5d2830..331033b47de 100644
--- a/package.json
+++ b/package.json
@@ -18,8 +18,8 @@
     "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
     "gendoc": "typedoc",
     "lint": "yarn lint:types && yarn lint:js",
-    "lint:js": "eslint --max-warnings 0 src spec",
-    "lint:js-fix": "eslint --fix src spec",
+    "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
+    "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
     "lint:types": "tsc --noEmit",
     "test": "jest",
     "test:watch": "jest --watch",
@@ -99,10 +99,11 @@
     "domexception": "^4.0.0",
     "eslint": "8.28.0",
     "eslint-config-google": "^0.14.0",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-import-resolver-typescript": "^3.5.1",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-jsdoc": "^39.6.4",
-    "eslint-plugin-matrix-org": "^0.8.0",
+    "eslint-plugin-matrix-org": "https://github.com/matrix-org/eslint-plugin-matrix-org.git#weeman1337/prettier",
     "eslint-plugin-tsdoc": "^0.2.17",
     "eslint-plugin-unicorn": "^45.0.0",
     "exorcist": "^2.0.0",
@@ -112,6 +113,7 @@
     "jest-localstorage-mock": "^2.4.6",
     "jest-mock": "^29.0.0",
     "matrix-mock-request": "^2.5.0",
+    "prettier": "2.8.0",
     "rimraf": "^3.0.2",
     "terser": "^5.5.1",
     "tsify": "^5.0.2",
diff --git a/yarn.lock b/yarn.lock
index 9a2f147943c..d562f256aee 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3320,6 +3320,11 @@ eslint-config-google@^0.14.0:
   resolved "https://registry.yarnpkg.com/eslint-config-google/-/eslint-config-google-0.14.0.tgz#4f5f8759ba6e11b424294a219dbfa18c508bcc1a"
   integrity sha512-WsbX4WbjuMvTdeVL6+J3rK1RGhCTqjsFjX7UMSMgZiyxxaNLkoJENbrGExzERFeoTpGw3F3FypTiWAP9ZXzkEw==
 
+eslint-config-prettier@^8.5.0:
+  version "8.5.0"
+  resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-8.5.0.tgz#5a81680ec934beca02c7b1a61cf8ca34b66feab1"
+  integrity sha512-obmWKLUNCnhtQRKc+tmnYuQl0pFU1ibYJQ5BGhTVB08bHe9wC8qUeG7c08dj9XX+AuPj1YSGSQIHl1pnDHZR0Q==
+
 eslint-import-resolver-node@^0.3.6:
   version "0.3.6"
   resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.6.tgz#4048b958395da89668252001dbd9eca6b83bacbd"
@@ -3380,10 +3385,9 @@ eslint-plugin-jsdoc@^39.6.4:
     semver "^7.3.8"
     spdx-expression-parse "^3.0.1"
 
-eslint-plugin-matrix-org@^0.8.0:
+"eslint-plugin-matrix-org@https://github.com/matrix-org/eslint-plugin-matrix-org.git#weeman1337/prettier":
   version "0.8.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-matrix-org/-/eslint-plugin-matrix-org-0.8.0.tgz#daa1396900a8cb1c1d88f1a370e45fc32482cd9e"
-  integrity sha512-/Poz/F8lXYDsmQa29iPSt+kO+Jn7ArvRdq10g0CCk8wbRS0sb2zb6fvd9xL1BgR5UDQL771V0l8X32etvY5yKA==
+  resolved "https://github.com/matrix-org/eslint-plugin-matrix-org.git#4c5e82dc6daa70b5d71ca8f8a55ff2e2cb6f802e"
 
 eslint-plugin-tsdoc@^0.2.17:
   version "0.2.17"
@@ -5703,6 +5707,11 @@ prelude-ls@~1.1.2:
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
   integrity sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==
 
+prettier@2.8.0:
+  version "2.8.0"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.0.tgz#c7df58393c9ba77d6fba3921ae01faf994fb9dc9"
+  integrity sha512-9Lmg8hTFZKG0Asr/kW9Bp8tJjRVluO8EJQVfY2T7FMw9T5jy4I/Uvx0Rca/XWf50QQ1/SS48+6IJWnrb+2yemA==
+
 pretty-format@^28.1.3:
   version "28.1.3"
   resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-28.1.3.tgz#c9fba8cedf99ce50963a11b27d982a9ae90970d5"

From 349c2c2587c2885bb69eda4aa078b5383724cf5e Mon Sep 17 00:00:00 2001
From: Michael Weimann <michaelw@matrix.org>
Date: Fri, 9 Dec 2022 09:38:20 +0100
Subject: [PATCH 36/60] Apply prettier formatting

---
 .babelrc                                      |   15 +-
 .eslintrc.js                                  |  156 +-
 .github/PULL_REQUEST_TEMPLATE.md              |    6 +-
 .github/renovate.json                         |    6 +-
 .github/workflows/backport.yml                |   52 +-
 .github/workflows/docs-pr-netlify.yaml        |   56 +-
 .github/workflows/notify-downstream.yaml      |   44 +-
 .github/workflows/pull_request.yaml           |  164 +-
 .github/workflows/release-npm.yml             |   66 +-
 .github/workflows/release.yml                 |  108 +-
 .github/workflows/sonarcloud.yml              |   88 +-
 .github/workflows/sonarqube.yml               |   74 +-
 .github/workflows/static_analysis.yml         |  112 +-
 .github/workflows/tests.yml                   |  100 +-
 .github/workflows/upgrade_dependencies.yml    |   64 +-
 CHANGELOG.md                                  | 8015 +++++++++--------
 CONTRIBUTING.md                               |    4 +-
 README.md                                     |  295 +-
 docs/storage-notes.md                         |   54 +-
 examples/browser/README.md                    |    2 +-
 examples/browser/browserTest.js               |    2 +-
 examples/browser/index.html                   |   31 +-
 .../olm-device-export-import.html             |   99 +-
 .../olm-device-export-import.js               |  115 +-
 examples/node/README.md                       |    3 +-
 examples/node/app.js                          |  292 +-
 examples/node/package.json                    |   24 +-
 examples/voip/README.md                       |    2 +-
 examples/voip/browserTest.js                  |   49 +-
 examples/voip/index.html                      |   40 +-
 package.json                                  |  284 +-
 scripts/switch_package_to_release.js          |   12 +-
 spec/TestClient.ts                            |   86 +-
 spec/browserify/sync-browserify.spec.ts       |    8 +-
 spec/integ/devicelist-integ.spec.ts           |  472 +-
 spec/integ/matrix-client-crypto.spec.ts       |  175 +-
 .../integ/matrix-client-event-emitter.spec.ts |  170 +-
 .../matrix-client-event-timeline.spec.ts      | 1092 +--
 spec/integ/matrix-client-methods.spec.ts      | 1395 +--
 spec/integ/matrix-client-opts.spec.ts         |  118 +-
 spec/integ/matrix-client-relations.spec.ts    |   75 +-
 spec/integ/matrix-client-retrying.spec.ts     |  108 +-
 .../integ/matrix-client-room-timeline.spec.ts |  600 +-
 spec/integ/matrix-client-syncing.spec.ts      | 1163 +--
 spec/integ/megolm-backup.spec.ts              |  127 +-
 spec/integ/megolm-integ.spec.ts               |  752 +-
 spec/integ/sliding-sync-sdk.spec.ts           |  207 +-
 spec/integ/sliding-sync.spec.ts               | 1340 +--
 spec/olm-loader.ts                            |    6 +-
 spec/slowReporter.js                          |    6 +-
 spec/test-utils/beacon.ts                     |   33 +-
 spec/test-utils/client.ts                     |    5 +-
 spec/test-utils/flushPromises.ts              |    2 +-
 spec/test-utils/test-utils.ts                 |   42 +-
 spec/test-utils/thread.ts                     |   68 +-
 spec/test-utils/webrtc.ts                     |  211 +-
 spec/unit/ReEmitter.spec.ts                   |   16 +-
 spec/unit/autodiscovery.spec.ts               |  697 +-
 spec/unit/content-helpers.spec.ts             |  208 +-
 spec/unit/content-repo.spec.ts                |   72 +-
 spec/unit/crypto.spec.ts                      |  543 +-
 spec/unit/crypto/CrossSigningInfo.spec.ts     |  224 +-
 spec/unit/crypto/DeviceList.spec.ts           |  170 +-
 spec/unit/crypto/algorithms/megolm.spec.ts    |  737 +-
 spec/unit/crypto/algorithms/olm.spec.ts       |  116 +-
 spec/unit/crypto/backup.spec.ts               |  420 +-
 spec/unit/crypto/cross-signing.spec.ts        |  402 +-
 spec/unit/crypto/crypto-utils.ts              |   18 +-
 spec/unit/crypto/dehydration.spec.ts          |   55 +-
 .../crypto/outgoing-room-key-requests.spec.ts |   72 +-
 spec/unit/crypto/secrets.spec.ts              |  300 +-
 .../crypto/verification/InRoomChannel.spec.ts |   41 +-
 spec/unit/crypto/verification/qr_code.spec.ts |    6 +-
 spec/unit/crypto/verification/request.spec.ts |   14 +-
 spec/unit/crypto/verification/sas.spec.ts     |  203 +-
 .../verification/secret_request.spec.ts       |   41 +-
 .../setDeviceVerification.spec.ts             |   10 +-
 spec/unit/crypto/verification/util.ts         |   73 +-
 .../verification/verification_request.spec.ts |  131 +-
 spec/unit/embedded.spec.ts                    |   40 +-
 spec/unit/event-mapper.spec.ts                |    6 +-
 spec/unit/event-timeline-set.spec.ts          |  146 +-
 spec/unit/event-timeline.spec.ts              |  377 +-
 spec/unit/filter-component.spec.ts            |  106 +-
 spec/unit/filter.spec.ts                      |   22 +-
 spec/unit/http-api/fetch.spec.ts              |   23 +-
 spec/unit/http-api/index.spec.ts              |   16 +-
 spec/unit/http-api/utils.spec.ts              |  188 +-
 spec/unit/interactive-auth.spec.ts            |  153 +-
 spec/unit/local_notifications.spec.ts         |    6 +-
 spec/unit/location.spec.ts                    |   33 +-
 spec/unit/login.spec.ts                       |   38 +-
 spec/unit/matrix-client.spec.ts               |  546 +-
 spec/unit/models/MSC3089Branch.spec.ts        |  162 +-
 spec/unit/models/MSC3089TreeSpace.spec.ts     |  377 +-
 spec/unit/models/beacon.spec.ts               |  255 +-
 spec/unit/models/event.spec.ts                |   25 +-
 spec/unit/models/thread.spec.ts               |   20 +-
 spec/unit/notifications.spec.ts               |   21 +-
 spec/unit/pusher.spec.ts                      |    6 +-
 spec/unit/pushprocessor.spec.ts               |  373 +-
 spec/unit/queueToDevice.spec.ts               |  156 +-
 spec/unit/read-receipt.spec.ts                |  128 +-
 spec/unit/realtime-callbacks.spec.ts          |   36 +-
 spec/unit/relations.spec.ts                   |   98 +-
 spec/unit/rendezvous/DummyTransport.ts        |   14 +-
 spec/unit/rendezvous/ecdh.spec.ts             |   52 +-
 spec/unit/rendezvous/rendezvous.spec.ts       |  170 +-
 .../rendezvous/simpleHttpTransport.spec.ts    |  131 +-
 spec/unit/room-member.spec.ts                 |  291 +-
 spec/unit/room-state.spec.ts                  |  803 +-
 spec/unit/room.spec.ts                        | 2167 +++--
 spec/unit/scheduler.spec.ts                   |  370 +-
 spec/unit/stores/indexeddb.spec.ts            |    9 +-
 spec/unit/sync-accumulator.spec.ts            |  329 +-
 spec/unit/timeline-window.spec.ts             |  150 +-
 spec/unit/user.spec.ts                        |   34 +-
 spec/unit/utils.spec.ts                       |  313 +-
 spec/unit/webrtc/call.spec.ts                 |  751 +-
 spec/unit/webrtc/callEventHandler.spec.ts     |   99 +-
 spec/unit/webrtc/groupCall.spec.ts            |  414 +-
 .../unit/webrtc/groupCallEventHandler.spec.ts |   78 +-
 spec/unit/webrtc/mediaHandler.spec.ts         |  120 +-
 src/@types/PushRules.ts                       |   29 +-
 src/@types/beacon.ts                          |    9 +-
 src/@types/event.ts                           |   28 +-
 src/@types/global.d.ts                        |   28 +-
 src/@types/location.ts                        |   11 +-
 src/@types/partials.ts                        |    3 +-
 src/@types/read_receipts.ts                   |    2 +-
 src/@types/sync.ts                            |    3 +-
 src/@types/uia.ts                             |    2 +-
 src/NamespacedValue.ts                        |    3 +-
 src/ReEmitter.ts                              |    7 +-
 src/ToDeviceMessageQueue.ts                   |    8 +-
 src/autodiscovery.ts                          |   39 +-
 src/client.ts                                 | 1850 ++--
 src/content-helpers.ts                        |   40 +-
 src/content-repo.ts                           |    6 +-
 src/crypto/CrossSigning.ts                    |  154 +-
 src/crypto/DeviceList.ts                      |  271 +-
 src/crypto/EncryptionSetup.ts                 |   47 +-
 src/crypto/OlmDevice.ts                       |  691 +-
 src/crypto/OutgoingRoomKeyRequestManager.ts   |  180 +-
 src/crypto/RoomList.ts                        |   24 +-
 src/crypto/SecretStorage.ts                   |   87 +-
 src/crypto/aes.ts                             |   41 +-
 src/crypto/algorithms/base.ts                 |   20 +-
 src/crypto/algorithms/megolm.ts               |  531 +-
 src/crypto/algorithms/olm.ts                  |  144 +-
 src/crypto/backup.ts                          |  158 +-
 src/crypto/dehydration.ts                     |  104 +-
 src/crypto/deviceinfo.ts                      |    4 +-
 src/crypto/index.ts                           |  851 +-
 src/crypto/key_passphrase.ts                  |   24 +-
 src/crypto/olmlib.ts                          |  116 +-
 src/crypto/recoverykey.ts                     |   18 +-
 src/crypto/store/base.ts                      |   13 +-
 .../store/indexeddb-crypto-store-backend.ts   |  229 +-
 src/crypto/store/indexeddb-crypto-store.ts    |  141 +-
 src/crypto/store/localStorage-crypto-store.ts |   89 +-
 src/crypto/store/memory-crypto-store.ts       |   58 +-
 src/crypto/verification/Base.ts               |   55 +-
 src/crypto/verification/Error.ts              |   18 +-
 src/crypto/verification/QRCode.ts             |   13 +-
 src/crypto/verification/SAS.ts                |  259 +-
 src/crypto/verification/SASDecimal.ts         |    6 +-
 .../verification/request/InRoomChannel.ts     |   31 +-
 .../verification/request/ToDeviceChannel.ts   |   30 +-
 .../request/VerificationRequest.ts            |  105 +-
 src/embedded.ts                               |   68 +-
 src/errors.ts                                 |    8 +-
 src/event-mapper.ts                           |   13 +-
 src/feature.ts                                |    9 +-
 src/filter-component.ts                       |   55 +-
 src/filter.ts                                 |   22 +-
 src/http-api/fetch.ts                         |   24 +-
 src/http-api/index.ts                         |   32 +-
 src/index.ts                                  |    1 -
 src/indexeddb-worker.ts                       |    1 -
 src/interactive-auth.ts                       |   25 +-
 src/logger.ts                                 |   12 +-
 src/matrix.ts                                 |   29 +-
 src/models/MSC3089Branch.ts                   |   72 +-
 src/models/MSC3089TreeSpace.ts                |  121 +-
 src/models/beacon.ts                          |   42 +-
 src/models/event-timeline-set.ts              |  124 +-
 src/models/event-timeline.ts                  |   44 +-
 src/models/event.ts                           |  132 +-
 src/models/invites-ignorer.ts                 |   53 +-
 src/models/read-receipt.ts                    |   39 +-
 src/models/related-relations.ts               |    6 +-
 src/models/relations-container.ts             |   20 +-
 src/models/relations.ts                       |    4 +-
 src/models/room-member.ts                     |   17 +-
 src/models/room-state.ts                      |   57 +-
 src/models/room-summary.ts                    |    1 -
 src/models/room.ts                            |  628 +-
 src/models/search-result.ts                   |    6 +-
 src/models/thread.ts                          |  122 +-
 src/models/typed-event-emitter.ts             |   25 +-
 src/models/user.ts                            |   12 +-
 src/pushprocessor.ts                          |   91 +-
 src/realtime-callbacks.ts                     |   15 +-
 src/rendezvous/MSC3906Rendezvous.ts           |   54 +-
 src/rendezvous/RendezvousChannel.ts           |    6 +-
 src/rendezvous/RendezvousFailureReason.ts     |   22 +-
 src/rendezvous/RendezvousIntent.ts            |    4 +-
 src/rendezvous/RendezvousTransport.ts         |   64 +-
 .../MSC3903ECDHv1RendezvousChannel.ts         |   54 +-
 src/rendezvous/channels/index.ts              |    3 +-
 src/rendezvous/index.ts                       |   14 +-
 .../MSC3886SimpleHttpRendezvousTransport.ts   |   50 +-
 src/rendezvous/transports/index.ts            |    2 +-
 src/room-hierarchy.ts                         |   17 +-
 src/scheduler.ts                              |   73 +-
 src/service-types.ts                          |    4 +-
 src/sliding-sync-sdk.ts                       |  195 +-
 src/sliding-sync.ts                           |   83 +-
 src/store/index.ts                            |   18 +-
 src/store/indexeddb-local-backend.ts          |   92 +-
 src/store/indexeddb-remote-backend.ts         |   44 +-
 src/store/indexeddb-store-worker.ts           |   77 +-
 src/store/indexeddb.ts                        |   52 +-
 src/store/local-storage-events-emitter.ts     |   12 +-
 src/store/memory.ts                           |    7 +-
 src/sync-accumulator.ts                       |   79 +-
 src/sync.ts                                   |  534 +-
 src/timeline-window.ts                        |   78 +-
 src/utils.ts                                  |   85 +-
 src/webrtc/call.ts                            |  518 +-
 src/webrtc/callEventHandler.ts                |   76 +-
 src/webrtc/callEventTypes.ts                  |    4 +-
 src/webrtc/callFeed.ts                        |    6 +-
 src/webrtc/groupCall.ts                       |  308 +-
 src/webrtc/groupCallEventHandler.ts           |   33 +-
 src/webrtc/mediaHandler.ts                    |   57 +-
 tsconfig-build.json                           |   22 +-
 tsconfig.json                                 |   37 +-
 239 files changed, 22143 insertions(+), 22067 deletions(-)

diff --git a/.babelrc b/.babelrc
index 6f4f54a93f1..6e6720bbf11 100644
--- a/.babelrc
+++ b/.babelrc
@@ -1,12 +1,15 @@
 {
     "sourceMaps": true,
     "presets": [
-        ["@babel/preset-env", {
-            "targets": {
-                "node": 10
-            },
-            "modules": "commonjs"
-        }],
+        [
+            "@babel/preset-env",
+            {
+                "targets": {
+                    "node": 10
+                },
+                "modules": "commonjs"
+            }
+        ],
         "@babel/preset-typescript"
     ],
     "plugins": [
diff --git a/.eslintrc.js b/.eslintrc.js
index c73e8a44d3f..fd77e6c5e42 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,13 +1,6 @@
 module.exports = {
-    plugins: [
-        "matrix-org",
-        "import",
-        "jsdoc",
-    ],
-    extends: [
-        "plugin:matrix-org/babel",
-        "plugin:import/typescript",
-    ],
+    plugins: ["matrix-org", "import", "jsdoc"],
+    extends: ["plugin:matrix-org/babel", "plugin:import/typescript"],
     env: {
         browser: true,
         node: true,
@@ -28,12 +21,15 @@ module.exports = {
         "padded-blocks": ["error"],
         "no-extend-native": ["error"],
         "camelcase": ["error"],
-        "no-multi-spaces": ["error", { "ignoreEOLComments": true }],
-        "space-before-function-paren": ["error", {
-            "anonymous": "never",
-            "named": "never",
-            "asyncArrow": "always",
-        }],
+        "no-multi-spaces": ["error", { ignoreEOLComments: true }],
+        "space-before-function-paren": [
+            "error",
+            {
+                anonymous: "never",
+                named: "never",
+                asyncArrow: "always",
+            },
+        ],
         "arrow-parens": "off",
         "prefer-promise-reject-errors": "off",
         "no-constant-condition": "off",
@@ -42,76 +38,78 @@ module.exports = {
         "no-console": "error",
 
         // restrict EventEmitters to force callers to use TypedEventEmitter
-        "no-restricted-imports": ["error", {
-            name: "events",
-            message: "Please use TypedEventEmitter instead",
-        }],
-
-        "import/no-restricted-paths": ["error", {
-            "zones": [{
-                "target": "./src/",
-                "from": "./src/index.ts",
-                "message": "The package index is dynamic between src and lib depending on " +
-                    "whether release or development, target the specific module or matrix.ts instead",
-            }],
-        }],
-    },
-    overrides: [{
-        files: [
-            "**/*.ts",
-        ],
-        plugins: [
-            "eslint-plugin-tsdoc",
+        "no-restricted-imports": [
+            "error",
+            {
+                name: "events",
+                message: "Please use TypedEventEmitter instead",
+            },
         ],
-        extends: [
-            "plugin:matrix-org/typescript",
-        ],
-        rules: {
-            // TypeScript has its own version of this
-            "@babel/no-invalid-this": "off",
 
-            // We're okay being explicit at the moment
-            "@typescript-eslint/no-empty-interface": "off",
-            // We disable this while we're transitioning
-            "@typescript-eslint/no-explicit-any": "off",
-            // We'd rather not do this but we do
-            "@typescript-eslint/ban-ts-comment": "off",
-            // We're okay with assertion errors when we ask for them
-            "@typescript-eslint/no-non-null-assertion": "off",
+        "import/no-restricted-paths": [
+            "error",
+            {
+                zones: [
+                    {
+                        target: "./src/",
+                        from: "./src/index.ts",
+                        message:
+                            "The package index is dynamic between src and lib depending on " +
+                            "whether release or development, target the specific module or matrix.ts instead",
+                    },
+                ],
+            },
+        ],
+    },
+    overrides: [
+        {
+            files: ["**/*.ts"],
+            plugins: ["eslint-plugin-tsdoc"],
+            extends: ["plugin:matrix-org/typescript"],
+            rules: {
+                // TypeScript has its own version of this
+                "@babel/no-invalid-this": "off",
 
-            // The non-TypeScript rule produces false positives
-            "func-call-spacing": "off",
-            "@typescript-eslint/func-call-spacing": ["error"],
+                // We're okay being explicit at the moment
+                "@typescript-eslint/no-empty-interface": "off",
+                // We disable this while we're transitioning
+                "@typescript-eslint/no-explicit-any": "off",
+                // We'd rather not do this but we do
+                "@typescript-eslint/ban-ts-comment": "off",
+                // We're okay with assertion errors when we ask for them
+                "@typescript-eslint/no-non-null-assertion": "off",
 
-            "quotes": "off",
-            // We use a `logger` intermediary module
-            "no-console": "error",
+                // The non-TypeScript rule produces false positives
+                "func-call-spacing": "off",
+                "@typescript-eslint/func-call-spacing": ["error"],
 
+                "quotes": "off",
+                // We use a `logger` intermediary module
+                "no-console": "error",
+            },
         },
-    }, {
-        // We don't need amazing docs in our spec files
-        files: [
-            "src/**/*.ts",
-        ],
-        rules: {
-            "tsdoc/syntax": "error",
-            // We use some select jsdoc rules as the tsdoc linter has only one rule
-            "jsdoc/no-types": "error",
-            "jsdoc/empty-tags": "error",
-            "jsdoc/check-property-names": "error",
-            "jsdoc/check-values": "error",
-            // These need a bit more work before we can enable
-            // "jsdoc/check-param-names": "error",
-            // "jsdoc/check-indentation": "error",
+        {
+            // We don't need amazing docs in our spec files
+            files: ["src/**/*.ts"],
+            rules: {
+                "tsdoc/syntax": "error",
+                // We use some select jsdoc rules as the tsdoc linter has only one rule
+                "jsdoc/no-types": "error",
+                "jsdoc/empty-tags": "error",
+                "jsdoc/check-property-names": "error",
+                "jsdoc/check-values": "error",
+                // These need a bit more work before we can enable
+                // "jsdoc/check-param-names": "error",
+                // "jsdoc/check-indentation": "error",
+            },
         },
-    }, {
-        files: [
-            "spec/**/*.ts",
-        ],
-        rules: {
-            // We don't need super strict typing in test utilities
-            "@typescript-eslint/explicit-function-return-type": "off",
-            "@typescript-eslint/explicit-member-accessibility": "off",
+        {
+            files: ["spec/**/*.ts"],
+            rules: {
+                // We don't need super strict typing in test utilities
+                "@typescript-eslint/explicit-function-return-type": "off",
+                "@typescript-eslint/explicit-member-accessibility": "off",
+            },
         },
-    }],
+    ],
 };
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index c0b7939a69b..bbaaa050791 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -2,9 +2,9 @@
 
 ## Checklist
 
-* [ ] Tests written for new code (and old code if feasible)
-* [ ] Linter and other CI checks pass
-* [ ] Sign-off given on the changes (see [CONTRIBUTING.md](https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md))
+-   [ ] Tests written for new code (and old code if feasible)
+-   [ ] Linter and other CI checks pass
+-   [ ] Sign-off given on the changes (see [CONTRIBUTING.md](https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md))
 
 <!--
 If you would like to specify text for the changelog entry other than your PR title, add the following:
diff --git a/.github/renovate.json b/.github/renovate.json
index 91ed4799766..76320426d9e 100644
--- a/.github/renovate.json
+++ b/.github/renovate.json
@@ -1,6 +1,4 @@
 {
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": [
-    "github>matrix-org/renovate-config-element-web"
-  ]
+    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+    "extends": ["github>matrix-org/renovate-config-element-web"]
 }
diff --git a/.github/workflows/backport.yml b/.github/workflows/backport.yml
index 10bda8e205f..32deb2f2b57 100644
--- a/.github/workflows/backport.yml
+++ b/.github/workflows/backport.yml
@@ -1,30 +1,30 @@
 name: Backport
 on:
-  pull_request_target:
-    types:
-      - closed
-      - labeled
-    branches:
-      - develop
+    pull_request_target:
+        types:
+            - closed
+            - labeled
+        branches:
+            - develop
 
 jobs:
-  backport:
-    name: Backport
-    runs-on: ubuntu-latest
-    # Only react to merged PRs for security reasons.
-    # See https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target.
-    if: >
-      github.event.pull_request.merged
-      && (
-        github.event.action == 'closed'
-        || (
-          github.event.action == 'labeled'
-          && contains(github.event.label.name, 'backport')
-        )
-      )
-    steps:
-      - uses: tibdex/backport@v2
-        with:
-          labels_template: "<%= JSON.stringify([...labels, 'X-Release-Blocker']) %>"
-          # We can't use GITHUB_TOKEN here or CI won't run on the new PR
-          github_token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+    backport:
+        name: Backport
+        runs-on: ubuntu-latest
+        # Only react to merged PRs for security reasons.
+        # See https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target.
+        if: >
+            github.event.pull_request.merged
+            && (
+              github.event.action == 'closed'
+              || (
+                github.event.action == 'labeled'
+                && contains(github.event.label.name, 'backport')
+              )
+            )
+        steps:
+            - uses: tibdex/backport@v2
+              with:
+                  labels_template: "<%= JSON.stringify([...labels, 'X-Release-Blocker']) %>"
+                  # We can't use GITHUB_TOKEN here or CI won't run on the new PR
+                  github_token: ${{ secrets.ELEMENT_BOT_TOKEN }}
diff --git a/.github/workflows/docs-pr-netlify.yaml b/.github/workflows/docs-pr-netlify.yaml
index 4e1b09c5b0f..c53f981b6ea 100644
--- a/.github/workflows/docs-pr-netlify.yaml
+++ b/.github/workflows/docs-pr-netlify.yaml
@@ -1,34 +1,34 @@
 name: Deploy documentation PR preview
 
 on:
-  workflow_run:
-    workflows: [ "Static Analysis" ]
-    types:
-      - completed
+    workflow_run:
+        workflows: ["Static Analysis"]
+        types:
+            - completed
 
 jobs:
-  netlify:
-    if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event == 'pull_request'
-    runs-on: ubuntu-latest
-    steps:
-      # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
-      # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
-      - name: 📥 Download artifact
-        uses: dawidd6/action-download-artifact@e6e25ac3a2b93187502a8be1ef9e9603afc34925 # v2.24.2
-        with:
-          workflow: static_analysis.yml
-          run_id: ${{ github.event.workflow_run.id }}
-          name: docs
-          path: docs
+    netlify:
+        if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event == 'pull_request'
+        runs-on: ubuntu-latest
+        steps:
+            # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
+            # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
+            - name: 📥 Download artifact
+              uses: dawidd6/action-download-artifact@e6e25ac3a2b93187502a8be1ef9e9603afc34925 # v2.24.2
+              with:
+                  workflow: static_analysis.yml
+                  run_id: ${{ github.event.workflow_run.id }}
+                  name: docs
+                  path: docs
 
-      - name: 📤 Deploy to Netlify
-        uses: matrix-org/netlify-pr-preview@v1
-        with:
-          path: docs
-          owner: ${{ github.event.workflow_run.head_repository.owner.login }}
-          branch: ${{ github.event.workflow_run.head_branch }}
-          revision: ${{ github.event.workflow_run.head_sha }}
-          token: ${{ secrets.NETLIFY_AUTH_TOKEN }}
-          site_id: ${{ secrets.NETLIFY_SITE_ID }}
-          desc: Documentation preview
-          deployment_env: PR Documentation Preview
+            - name: 📤 Deploy to Netlify
+              uses: matrix-org/netlify-pr-preview@v1
+              with:
+                  path: docs
+                  owner: ${{ github.event.workflow_run.head_repository.owner.login }}
+                  branch: ${{ github.event.workflow_run.head_branch }}
+                  revision: ${{ github.event.workflow_run.head_sha }}
+                  token: ${{ secrets.NETLIFY_AUTH_TOKEN }}
+                  site_id: ${{ secrets.NETLIFY_SITE_ID }}
+                  desc: Documentation preview
+                  deployment_env: PR Documentation Preview
diff --git a/.github/workflows/notify-downstream.yaml b/.github/workflows/notify-downstream.yaml
index af166cce7c3..1a7fee20eba 100644
--- a/.github/workflows/notify-downstream.yaml
+++ b/.github/workflows/notify-downstream.yaml
@@ -1,27 +1,27 @@
 name: Notify Downstream Projects
 on:
-  push:
-    branches: [ develop ]
+    push:
+        branches: [develop]
 concurrency: ${{ github.workflow }}-${{ github.ref }}
 jobs:
-  notify-downstream:
-    # Only respect triggers from our develop branch, ignore that of forks
-    if: github.repository == 'matrix-org/matrix-js-sdk'
-    continue-on-error: true
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - repo: vector-im/element-web
-            event: element-web-notify
-          - repo: matrix-org/matrix-react-sdk
-            event: upstream-sdk-notify
+    notify-downstream:
+        # Only respect triggers from our develop branch, ignore that of forks
+        if: github.repository == 'matrix-org/matrix-js-sdk'
+        continue-on-error: true
+        strategy:
+            fail-fast: false
+            matrix:
+                include:
+                    - repo: vector-im/element-web
+                      event: element-web-notify
+                    - repo: matrix-org/matrix-react-sdk
+                      event: upstream-sdk-notify
 
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify matrix-react-sdk repo that a new SDK build is on develop so it can CI against it
-        uses: peter-evans/repository-dispatch@v2
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          repository: ${{ matrix.repo }}
-          event-type: ${{ matrix.event }}
+        runs-on: ubuntu-latest
+        steps:
+            - name: Notify matrix-react-sdk repo that a new SDK build is on develop so it can CI against it
+              uses: peter-evans/repository-dispatch@v2
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  repository: ${{ matrix.repo }}
+                  event-type: ${{ matrix.event }}
diff --git a/.github/workflows/pull_request.yaml b/.github/workflows/pull_request.yaml
index d2a8857aa5f..4fc47ed39b1 100644
--- a/.github/workflows/pull_request.yaml
+++ b/.github/workflows/pull_request.yaml
@@ -1,91 +1,91 @@
 name: Pull Request
 on:
-  pull_request_target:
-    types: [ opened, edited, labeled, unlabeled, synchronize ]
-  workflow_call:
-    inputs:
-      labels:
-        type: string
-        default: "T-Defect,T-Deprecation,T-Enhancement,T-Task"
-        required: false
-        description: "No longer used, uses allchange logic now, will be removed at a later date"
-    secrets:
-      ELEMENT_BOT_TOKEN:
-        required: true
+    pull_request_target:
+        types: [opened, edited, labeled, unlabeled, synchronize]
+    workflow_call:
+        inputs:
+            labels:
+                type: string
+                default: "T-Defect,T-Deprecation,T-Enhancement,T-Task"
+                required: false
+                description: "No longer used, uses allchange logic now, will be removed at a later date"
+        secrets:
+            ELEMENT_BOT_TOKEN:
+                required: true
 concurrency: ${{ github.workflow }}-${{ github.event.pull_request.head.ref }}
 jobs:
-  changelog:
-    name: Preview Changelog
-    runs-on: ubuntu-latest
-    steps:
-      - uses: matrix-org/allchange@main
-        with:
-          ghToken: ${{ secrets.GITHUB_TOKEN }}
-          requireLabel: true
+    changelog:
+        name: Preview Changelog
+        runs-on: ubuntu-latest
+        steps:
+            - uses: matrix-org/allchange@main
+              with:
+                  ghToken: ${{ secrets.GITHUB_TOKEN }}
+                  requireLabel: true
 
-  prevent-blocked:
-    name: Prevent Blocked
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
-    steps:
-      - name: Add notice
-        uses: actions/github-script@v6
-        if: contains(github.event.pull_request.labels.*.name, 'X-Blocked')
-        with:
-          script: |
-            core.setFailed("Preventing merge whilst PR is marked blocked!");
+    prevent-blocked:
+        name: Prevent Blocked
+        runs-on: ubuntu-latest
+        permissions:
+            pull-requests: read
+        steps:
+            - name: Add notice
+              uses: actions/github-script@v6
+              if: contains(github.event.pull_request.labels.*.name, 'X-Blocked')
+              with:
+                  script: |
+                      core.setFailed("Preventing merge whilst PR is marked blocked!");
 
-  community-prs:
-    name: Label Community PRs
-    runs-on: ubuntu-latest
-    if: github.event.action == 'opened'
-    steps:
-      - name: Check membership
-        uses: tspascoal/get-user-teams-membership@v2
-        id: teams
-        with:
-          username: ${{ github.event.pull_request.user.login }}
-          organization: matrix-org
-          team: Core Team
-          GITHUB_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
+    community-prs:
+        name: Label Community PRs
+        runs-on: ubuntu-latest
+        if: github.event.action == 'opened'
+        steps:
+            - name: Check membership
+              uses: tspascoal/get-user-teams-membership@v2
+              id: teams
+              with:
+                  username: ${{ github.event.pull_request.user.login }}
+                  organization: matrix-org
+                  team: Core Team
+                  GITHUB_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
 
-      - name: Add label
-        if: ${{ steps.teams.outputs.isTeamMember == 'false' }}
-        uses: actions/github-script@v6
-        with:
-          script: |
-            github.rest.issues.addLabels({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              labels: ['Z-Community-PR']
-            });
+            - name: Add label
+              if: ${{ steps.teams.outputs.isTeamMember == 'false' }}
+              uses: actions/github-script@v6
+              with:
+                  script: |
+                      github.rest.issues.addLabels({
+                        issue_number: context.issue.number,
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        labels: ['Z-Community-PR']
+                      });
 
-  close-if-fork-develop:
-    name: Forbid develop branch fork contributions
-    runs-on: ubuntu-latest
-    if: >
-      github.event.action == 'opened' &&
-      github.event.pull_request.head.ref == 'develop' &&
-      github.event.pull_request.head.repo.full_name != github.repository
-    steps:
-      - name: Close pull request
-        uses: actions/github-script@v6
-        with:
-          script: |
-            github.rest.issues.createComment({
-              issue_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: "Thanks for opening this pull request, unfortunately we do not accept contributions from the main" +
-                " branch of your fork, please re-open once you switch to an alternative branch for everyone's sanity." +
-                " See https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md",
-            });
+    close-if-fork-develop:
+        name: Forbid develop branch fork contributions
+        runs-on: ubuntu-latest
+        if: >
+            github.event.action == 'opened' &&
+            github.event.pull_request.head.ref == 'develop' &&
+            github.event.pull_request.head.repo.full_name != github.repository
+        steps:
+            - name: Close pull request
+              uses: actions/github-script@v6
+              with:
+                  script: |
+                      github.rest.issues.createComment({
+                        issue_number: context.issue.number,
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        body: "Thanks for opening this pull request, unfortunately we do not accept contributions from the main" +
+                          " branch of your fork, please re-open once you switch to an alternative branch for everyone's sanity." +
+                          " See https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md",
+                      });
 
-            github.rest.pulls.update({
-              pull_number: context.issue.number,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              state: 'closed'
-            });
+                      github.rest.pulls.update({
+                        pull_number: context.issue.number,
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        state: 'closed'
+                      });
diff --git a/.github/workflows/release-npm.yml b/.github/workflows/release-npm.yml
index 84d88ea5e5e..88f452faf5a 100644
--- a/.github/workflows/release-npm.yml
+++ b/.github/workflows/release-npm.yml
@@ -1,41 +1,41 @@
 # Must only be called from `release#published` triggers
 name: Publish to npm
 on:
-  workflow_call:
-    secrets:
-      NPM_TOKEN:
-        required: true
+    workflow_call:
+        secrets:
+            NPM_TOKEN:
+                required: true
 jobs:
-  npm:
-    name: Publish to npm
-    runs-on: ubuntu-latest
-    steps:
-      - name: 🧮 Checkout code
-        uses: actions/checkout@v3
+    npm:
+        name: Publish to npm
+        runs-on: ubuntu-latest
+        steps:
+            - name: 🧮 Checkout code
+              uses: actions/checkout@v3
 
-      - name: 🔧 Yarn cache
-        uses: actions/setup-node@v3
-        with:
-          cache: "yarn"
-          registry-url: 'https://registry.npmjs.org'
+            - name: 🔧 Yarn cache
+              uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
+                  registry-url: "https://registry.npmjs.org"
 
-      - name: 🔨 Install dependencies
-        run: "yarn install --pure-lockfile"
+            - name: 🔨 Install dependencies
+              run: "yarn install --pure-lockfile"
 
-      - name: 🚀 Publish to npm
-        id: npm-publish
-        uses: JS-DevTools/npm-publish@v1
-        with:
-          token: ${{ secrets.NPM_TOKEN }}
-          access: public
-          tag: next
+            - name: 🚀 Publish to npm
+              id: npm-publish
+              uses: JS-DevTools/npm-publish@v1
+              with:
+                  token: ${{ secrets.NPM_TOKEN }}
+                  access: public
+                  tag: next
 
-      - name: 🎖️ Add `latest` dist-tag to final releases
-        if: github.event.release.prerelease == false
-        run: |
-          package=$(cat package.json | jq -er .name)
-          npm dist-tag add "$package@$release" latest
-        env:
-          # JS-DevTools/npm-publish overrides `NODE_AUTH_TOKEN` with `INPUT_TOKEN` in .npmrc
-          INPUT_TOKEN: ${{ secrets.NPM_TOKEN }}
-          release: ${{ steps.npm-publish.outputs.version }}
+            - name: 🎖️ Add `latest` dist-tag to final releases
+              if: github.event.release.prerelease == false
+              run: |
+                  package=$(cat package.json | jq -er .name)
+                  npm dist-tag add "$package@$release" latest
+              env:
+                  # JS-DevTools/npm-publish overrides `NODE_AUTH_TOKEN` with `INPUT_TOKEN` in .npmrc
+                  INPUT_TOKEN: ${{ secrets.NPM_TOKEN }}
+                  release: ${{ steps.npm-publish.outputs.version }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 721f45b6253..609eb38429f 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,58 +1,58 @@
 name: Release Process
 on:
-  release:
-    types: [ published ]
+    release:
+        types: [published]
 concurrency: ${{ github.workflow }}-${{ github.ref }}
 jobs:
-  jsdoc:
-    name: Publish Documentation
-    runs-on: ubuntu-latest
-    steps:
-      - name: 🧮 Checkout code
-        uses: actions/checkout@v3
-
-      - name: 🔧 Yarn cache
-        uses: actions/setup-node@v3
-        with:
-          cache: "yarn"
-
-      - name: 🔨 Install dependencies
-        run: "yarn install --pure-lockfile"
-
-      - name: 📖 Generate JSDoc
-        run: "yarn gendoc"
-
-      - name: 📋 Copy to temp
-        run: |
-          cp -a "./_docs" "$RUNNER_TEMP/"
-
-      - name: 🧮 Checkout gh-pages
-        uses: actions/checkout@v3
-        with:
-          ref: gh-pages
-
-      - name: 🔪 Prepare
-        run: |
-          tag="${{ github.ref_name }}"
-          VERSION="${tag#v}"
-          [ ! -e "$VERSION" ] || rm -r $VERSION
-          cp -r $RUNNER_TEMP/_docs/ $VERSION
-
-          # Add the new directory to the index if it isn't there already
-          if ! grep -q ">Version $VERSION</a>" index.html; then
-            perl -i -pe 'BEGIN {$rel=shift} $_ =~ /^<\/ul>/ && print
-              "<li><a href=\"${rel}/index.html\">Version ${rel}</a></li>\n"' "$VERSION" index.html
-          fi
-
-      - name: 🚀 Deploy
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          keep_files: true
-          publish_dir: .
-
-  npm:
-    name: Publish
-    uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    jsdoc:
+        name: Publish Documentation
+        runs-on: ubuntu-latest
+        steps:
+            - name: 🧮 Checkout code
+              uses: actions/checkout@v3
+
+            - name: 🔧 Yarn cache
+              uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
+
+            - name: 🔨 Install dependencies
+              run: "yarn install --pure-lockfile"
+
+            - name: 📖 Generate JSDoc
+              run: "yarn gendoc"
+
+            - name: 📋 Copy to temp
+              run: |
+                  cp -a "./_docs" "$RUNNER_TEMP/"
+
+            - name: 🧮 Checkout gh-pages
+              uses: actions/checkout@v3
+              with:
+                  ref: gh-pages
+
+            - name: 🔪 Prepare
+              run: |
+                  tag="${{ github.ref_name }}"
+                  VERSION="${tag#v}"
+                  [ ! -e "$VERSION" ] || rm -r $VERSION
+                  cp -r $RUNNER_TEMP/_docs/ $VERSION
+
+                  # Add the new directory to the index if it isn't there already
+                  if ! grep -q ">Version $VERSION</a>" index.html; then
+                    perl -i -pe 'BEGIN {$rel=shift} $_ =~ /^<\/ul>/ && print
+                      "<li><a href=\"${rel}/index.html\">Version ${rel}</a></li>\n"' "$VERSION" index.html
+                  fi
+
+            - name: 🚀 Deploy
+              uses: peaceiris/actions-gh-pages@v3
+              with:
+                  github_token: ${{ secrets.GITHUB_TOKEN }}
+                  keep_files: true
+                  publish_dir: .
+
+    npm:
+        name: Publish
+        uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
+        secrets:
+            NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
diff --git a/.github/workflows/sonarcloud.yml b/.github/workflows/sonarcloud.yml
index 6b2188a0c88..e70c9b99e2c 100644
--- a/.github/workflows/sonarcloud.yml
+++ b/.github/workflows/sonarcloud.yml
@@ -1,50 +1,50 @@
 # Must only be called from a workflow_run in the context of the upstream repo
 name: SonarCloud
 on:
-  workflow_call:
-    secrets:
-      SONAR_TOKEN:
-        required: true
-    inputs:
-      extra_args:
-        type: string
-        required: false
-        description: "Extra args to pass to SonarCloud"
+    workflow_call:
+        secrets:
+            SONAR_TOKEN:
+                required: true
+        inputs:
+            extra_args:
+                type: string
+                required: false
+                description: "Extra args to pass to SonarCloud"
 jobs:
-  sonarqube:
-    runs-on: ubuntu-latest
-    if: github.event.workflow_run.conclusion == 'success'
-    steps:
-      # We create the status here and then update it to success/failure in the `report` stage
-      # This provides an easy link to this workflow_run from the PR before Cypress is done.
-      - uses: Sibz/github-status-action@v1
-        with:
-          authToken: ${{ secrets.GITHUB_TOKEN }}
-          state: pending
-          context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
-          sha: ${{ github.event.workflow_run.head_sha }}
-          target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
+    sonarqube:
+        runs-on: ubuntu-latest
+        if: github.event.workflow_run.conclusion == 'success'
+        steps:
+            # We create the status here and then update it to success/failure in the `report` stage
+            # This provides an easy link to this workflow_run from the PR before Cypress is done.
+            - uses: Sibz/github-status-action@v1
+              with:
+                  authToken: ${{ secrets.GITHUB_TOKEN }}
+                  state: pending
+                  context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
+                  sha: ${{ github.event.workflow_run.head_sha }}
+                  target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
 
-      - name: "🩻 SonarCloud Scan"
-        id: sonarcloud
-        uses: matrix-org/sonarcloud-workflow-action@v2.3
-        with:
-          repository: ${{ github.event.workflow_run.head_repository.full_name }}
-          is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}
-          version_cmd: 'cat package.json | jq -r .version'
-          branch: ${{ github.event.workflow_run.head_branch }}
-          revision: ${{ github.event.workflow_run.head_sha }}
-          token: ${{ secrets.SONAR_TOKEN }}
-          coverage_run_id: ${{ github.event.workflow_run.id }}
-          coverage_workflow_name: tests.yml
-          coverage_extract_path: coverage
-          extra_args: ${{ inputs.extra_args }}
+            - name: "🩻 SonarCloud Scan"
+              id: sonarcloud
+              uses: matrix-org/sonarcloud-workflow-action@v2.3
+              with:
+                  repository: ${{ github.event.workflow_run.head_repository.full_name }}
+                  is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}
+                  version_cmd: "cat package.json | jq -r .version"
+                  branch: ${{ github.event.workflow_run.head_branch }}
+                  revision: ${{ github.event.workflow_run.head_sha }}
+                  token: ${{ secrets.SONAR_TOKEN }}
+                  coverage_run_id: ${{ github.event.workflow_run.id }}
+                  coverage_workflow_name: tests.yml
+                  coverage_extract_path: coverage
+                  extra_args: ${{ inputs.extra_args }}
 
-      - uses: Sibz/github-status-action@v1
-        if: always()
-        with:
-          authToken: ${{ secrets.GITHUB_TOKEN }}
-          state: ${{ steps.sonarcloud.outcome == 'success' && 'success' || 'failure' }}
-          context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
-          sha: ${{ github.event.workflow_run.head_sha }}
-          target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
+            - uses: Sibz/github-status-action@v1
+              if: always()
+              with:
+                  authToken: ${{ secrets.GITHUB_TOKEN }}
+                  state: ${{ steps.sonarcloud.outcome == 'success' && 'success' || 'failure' }}
+                  context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
+                  sha: ${{ github.event.workflow_run.head_sha }}
+                  target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
diff --git a/.github/workflows/sonarqube.yml b/.github/workflows/sonarqube.yml
index 61768adadee..f3946219183 100644
--- a/.github/workflows/sonarqube.yml
+++ b/.github/workflows/sonarqube.yml
@@ -1,43 +1,43 @@
 name: SonarQube
 on:
-  workflow_run:
-    workflows: [ "Tests" ]
-    types:
-      - completed
+    workflow_run:
+        workflows: ["Tests"]
+        types:
+            - completed
 concurrency:
-  group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch }}
-  cancel-in-progress: true
+    group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch }}
+    cancel-in-progress: true
 jobs:
-  # This is a workaround for https://github.com/SonarSource/SonarJS/issues/578
-  prepare:
-    name: Prepare
-    runs-on: ubuntu-latest
-    outputs:
-      reportPaths: ${{ steps.extra_args.outputs.reportPaths }}
-      testExecutionReportPaths: ${{ steps.extra_args.outputs.testExecutionReportPaths }}
-    steps:
-      # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
-      # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
-      - name: 📥 Download artifact
-        uses: dawidd6/action-download-artifact@v2
-        with:
-          workflow: tests.yaml
-          run_id: ${{ github.event.workflow_run.id }}
-          name: coverage
-          path: coverage
+    # This is a workaround for https://github.com/SonarSource/SonarJS/issues/578
+    prepare:
+        name: Prepare
+        runs-on: ubuntu-latest
+        outputs:
+            reportPaths: ${{ steps.extra_args.outputs.reportPaths }}
+            testExecutionReportPaths: ${{ steps.extra_args.outputs.testExecutionReportPaths }}
+        steps:
+            # There's a 'download artifact' action, but it hasn't been updated for the workflow_run action
+            # (https://github.com/actions/download-artifact/issues/60) so instead we get this mess:
+            - name: 📥 Download artifact
+              uses: dawidd6/action-download-artifact@v2
+              with:
+                  workflow: tests.yaml
+                  run_id: ${{ github.event.workflow_run.id }}
+                  name: coverage
+                  path: coverage
 
-      - id: extra_args
-        run: |
-          coverage=$(find coverage -type f -name '*lcov.info' | tr '\n' ',' | sed 's/,$//g')
-          echo "reportPaths=$coverage" >> $GITHUB_OUTPUT
-          reports=$(find coverage -type f -name 'jest-sonar-report*.xml' | tr '\n' ',' | sed 's/,$//g')
-          echo "testExecutionReportPaths=$reports" >> $GITHUB_OUTPUT
+            - id: extra_args
+              run: |
+                  coverage=$(find coverage -type f -name '*lcov.info' | tr '\n' ',' | sed 's/,$//g')
+                  echo "reportPaths=$coverage" >> $GITHUB_OUTPUT
+                  reports=$(find coverage -type f -name 'jest-sonar-report*.xml' | tr '\n' ',' | sed 's/,$//g')
+                  echo "testExecutionReportPaths=$reports" >> $GITHUB_OUTPUT
 
-  sonarqube:
-    name: 🩻 SonarQube
-    needs: prepare
-    uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
-    secrets:
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-    with:
-      extra_args: -Dsonar.javascript.lcov.reportPaths=${{ needs.prepare.outputs.reportPaths }} -Dsonar.testExecutionReportPaths=${{ needs.prepare.outputs.testExecutionReportPaths }}
+    sonarqube:
+        name: 🩻 SonarQube
+        needs: prepare
+        uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
+        secrets:
+            SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        with:
+            extra_args: -Dsonar.javascript.lcov.reportPaths=${{ needs.prepare.outputs.reportPaths }} -Dsonar.testExecutionReportPaths=${{ needs.prepare.outputs.testExecutionReportPaths }}
diff --git a/.github/workflows/static_analysis.yml b/.github/workflows/static_analysis.yml
index dfcaf62af0b..c66451559d3 100644
--- a/.github/workflows/static_analysis.yml
+++ b/.github/workflows/static_analysis.yml
@@ -1,74 +1,74 @@
 name: Static Analysis
 on:
-  pull_request: { }
-  push:
-    branches: [ develop, master ]
+    pull_request: {}
+    push:
+        branches: [develop, master]
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
 jobs:
-  ts_lint:
-    name: "Typescript Syntax Check"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
+    ts_lint:
+        name: "Typescript Syntax Check"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
 
-      - name: Install Deps
-        run: "yarn install"
+            - name: Install Deps
+              run: "yarn install"
 
-      - name: Typecheck
-        run: "yarn run lint:types"
+            - name: Typecheck
+              run: "yarn run lint:types"
 
-      - name: Switch js-sdk to release mode
-        run: |
-          scripts/switch_package_to_release.js
-          yarn install
-          yarn run build:compile
-          yarn run build:types
+            - name: Switch js-sdk to release mode
+              run: |
+                  scripts/switch_package_to_release.js
+                  yarn install
+                  yarn run build:compile
+                  yarn run build:types
 
-      - name: Typecheck (release mode)
-        run: "yarn run lint:types"
+            - name: Typecheck (release mode)
+              run: "yarn run lint:types"
 
-  js_lint:
-    name: "ESLint"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
+    js_lint:
+        name: "ESLint"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
 
-      - name: Install Deps
-        run: "yarn install"
+            - name: Install Deps
+              run: "yarn install"
 
-      - name: Run Linter
-        run: "yarn run lint:js"
+            - name: Run Linter
+              run: "yarn run lint:js"
 
-  docs:
-    name: "JSDoc Checker"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
+    docs:
+        name: "JSDoc Checker"
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
 
-      - name: Install Deps
-        run: "yarn install"
+            - name: Install Deps
+              run: "yarn install"
 
-      - name: Generate Docs
-        run: "yarn run gendoc"
+            - name: Generate Docs
+              run: "yarn run gendoc"
 
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: docs
-          path: _docs
-          # We'll only use this in a workflow_run, then we're done with it
-          retention-days: 1
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v3
+              with:
+                  name: docs
+                  path: _docs
+                  # We'll only use this in a workflow_run, then we're done with it
+                  retention-days: 1
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index c7c7da7e730..16098493211 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -1,61 +1,61 @@
 name: Tests
 on:
-  pull_request: { }
-  push:
-    branches: [ develop, master ]
+    pull_request: {}
+    push:
+        branches: [develop, master]
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+    group: ${{ github.workflow }}-${{ github.ref }}
+    cancel-in-progress: true
 jobs:
-  jest:
-    name: 'Jest [${{ matrix.specs }}] (Node ${{ matrix.node }})'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    strategy:
-      matrix:
-        specs: [browserify, integ, unit]
-        node: [16, 18, latest]
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
+    jest:
+        name: "Jest [${{ matrix.specs }}] (Node ${{ matrix.node }})"
+        runs-on: ubuntu-latest
+        timeout-minutes: 10
+        strategy:
+            matrix:
+                specs: [browserify, integ, unit]
+                node: [16, 18, latest]
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v3
 
-      - name: Setup Node
-        uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
-          node-version: ${{ matrix.node }}
+            - name: Setup Node
+              uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
+                  node-version: ${{ matrix.node }}
 
-      - name: Install dependencies
-        run: "yarn install"
+            - name: Install dependencies
+              run: "yarn install"
 
-      - name: Build
-        if: matrix.specs == 'browserify'
-        run: "yarn build"
+            - name: Build
+              if: matrix.specs == 'browserify'
+              run: "yarn build"
 
-      - name: Get number of CPU cores
-        id: cpu-cores
-        uses: SimenB/github-actions-cpu-cores@v1
+            - name: Get number of CPU cores
+              id: cpu-cores
+              uses: SimenB/github-actions-cpu-cores@v1
 
-      - name: Run tests with coverage and metrics
-        if: github.ref == 'refs/heads/develop'
-        run: |
-          yarn coverage --ci --reporters github-actions '--reporters=<rootDir>/spec/slowReporter.js' --max-workers ${{ steps.cpu-cores.outputs.count }} ./spec/${{ matrix.specs }}
-          mv coverage/lcov.info coverage/${{ matrix.node }}-${{ matrix.specs }}.lcov.info
-        env:
-          JEST_SONAR_UNIQUE_OUTPUT_NAME: true
+            - name: Run tests with coverage and metrics
+              if: github.ref == 'refs/heads/develop'
+              run: |
+                  yarn coverage --ci --reporters github-actions '--reporters=<rootDir>/spec/slowReporter.js' --max-workers ${{ steps.cpu-cores.outputs.count }} ./spec/${{ matrix.specs }}
+                  mv coverage/lcov.info coverage/${{ matrix.node }}-${{ matrix.specs }}.lcov.info
+              env:
+                  JEST_SONAR_UNIQUE_OUTPUT_NAME: true
 
-      - name: Run tests with coverage
-        if: github.ref != 'refs/heads/develop'
-        run: |
-          yarn coverage --ci --reporters github-actions --max-workers ${{ steps.cpu-cores.outputs.count }} ./spec/${{ matrix.specs }}
-          mv coverage/lcov.info coverage/${{ matrix.node }}-${{ matrix.specs }}.lcov.info
-        env:
-          JEST_SONAR_UNIQUE_OUTPUT_NAME: true
+            - name: Run tests with coverage
+              if: github.ref != 'refs/heads/develop'
+              run: |
+                  yarn coverage --ci --reporters github-actions --max-workers ${{ steps.cpu-cores.outputs.count }} ./spec/${{ matrix.specs }}
+                  mv coverage/lcov.info coverage/${{ matrix.node }}-${{ matrix.specs }}.lcov.info
+              env:
+                  JEST_SONAR_UNIQUE_OUTPUT_NAME: true
 
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: coverage
-          path: |
-            coverage
-            !coverage/lcov-report
+            - name: Upload Artifact
+              uses: actions/upload-artifact@v3
+              with:
+                  name: coverage
+                  path: |
+                      coverage
+                      !coverage/lcov-report
diff --git a/.github/workflows/upgrade_dependencies.yml b/.github/workflows/upgrade_dependencies.yml
index 2cabf1f196f..9858c2c80d2 100644
--- a/.github/workflows/upgrade_dependencies.yml
+++ b/.github/workflows/upgrade_dependencies.yml
@@ -1,38 +1,38 @@
 name: Upgrade Dependencies
 on:
-  workflow_dispatch: { }
-  workflow_call:
-    secrets:
-      ELEMENT_BOT_TOKEN:
-        required: true
+    workflow_dispatch: {}
+    workflow_call:
+        secrets:
+            ELEMENT_BOT_TOKEN:
+                required: true
 jobs:
-  upgrade:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
+    upgrade:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
 
-      - uses: actions/setup-node@v3
-        with:
-          cache: 'yarn'
+            - uses: actions/setup-node@v3
+              with:
+                  cache: "yarn"
 
-      - name: Upgrade
-        run: yarn upgrade && yarn install
+            - name: Upgrade
+              run: yarn upgrade && yarn install
 
-      - name: Create Pull Request
-        id: cpr
-        uses: peter-evans/create-pull-request@v4
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          branch: actions/upgrade-deps
-          delete-branch: true
-          title: Upgrade dependencies
-          labels: |
-            Dependencies
-            T-Task
-          
-      - name: Enable automerge
-        uses: peter-evans/enable-pull-request-automerge@v2
-        if: steps.cpr.outputs.pull-request-operation == 'created'
-        with:
-          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
-          pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}
+            - name: Create Pull Request
+              id: cpr
+              uses: peter-evans/create-pull-request@v4
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  branch: actions/upgrade-deps
+                  delete-branch: true
+                  title: Upgrade dependencies
+                  labels: |
+                      Dependencies
+                      T-Task
+
+            - name: Enable automerge
+              uses: peter-evans/enable-pull-request-automerge@v2
+              if: steps.cpr.outputs.pull-request-operation == 'created'
+              with:
+                  token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+                  pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e5dd9237cf8..6780d4b3d0b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,1624 +1,1676 @@
-Changes in [22.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v22.0.0) (2022-12-06)
-==================================================================================================
+# Changes in [22.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v22.0.0) (2022-12-06)
 
 ## 🚨 BREAKING CHANGES
- * Enable users to join group calls from multiple devices ([\#2902](https://github.com/matrix-org/matrix-js-sdk/pull/2902)).
+
+-   Enable users to join group calls from multiple devices ([\#2902](https://github.com/matrix-org/matrix-js-sdk/pull/2902)).
 
 ## 🦖 Deprecations
- * Deprecate a function containing a typo ([\#2904](https://github.com/matrix-org/matrix-js-sdk/pull/2904)).
+
+-   Deprecate a function containing a typo ([\#2904](https://github.com/matrix-org/matrix-js-sdk/pull/2904)).
 
 ## ✨ Features
- * sliding sync: add receipts extension ([\#2912](https://github.com/matrix-org/matrix-js-sdk/pull/2912)).
- * Define a spec support policy for the js-sdk ([\#2882](https://github.com/matrix-org/matrix-js-sdk/pull/2882)).
- * Further improvements to e2ee logging ([\#2900](https://github.com/matrix-org/matrix-js-sdk/pull/2900)).
- * sliding sync: add support for typing extension ([\#2893](https://github.com/matrix-org/matrix-js-sdk/pull/2893)).
- * Improve logging on Olm session errors ([\#2885](https://github.com/matrix-org/matrix-js-sdk/pull/2885)).
- * Improve logging of e2ee messages ([\#2884](https://github.com/matrix-org/matrix-js-sdk/pull/2884)).
+
+-   sliding sync: add receipts extension ([\#2912](https://github.com/matrix-org/matrix-js-sdk/pull/2912)).
+-   Define a spec support policy for the js-sdk ([\#2882](https://github.com/matrix-org/matrix-js-sdk/pull/2882)).
+-   Further improvements to e2ee logging ([\#2900](https://github.com/matrix-org/matrix-js-sdk/pull/2900)).
+-   sliding sync: add support for typing extension ([\#2893](https://github.com/matrix-org/matrix-js-sdk/pull/2893)).
+-   Improve logging on Olm session errors ([\#2885](https://github.com/matrix-org/matrix-js-sdk/pull/2885)).
+-   Improve logging of e2ee messages ([\#2884](https://github.com/matrix-org/matrix-js-sdk/pull/2884)).
 
 ## 🐛 Bug Fixes
- * Fix 3pid invite acceptance not working due to mxid being sent in body ([\#2907](https://github.com/matrix-org/matrix-js-sdk/pull/2907)). Fixes vector-im/element-web#23823.
- * Don't hang up calls that haven't started yet ([\#2898](https://github.com/matrix-org/matrix-js-sdk/pull/2898)).
- * Read receipt accumulation for threads ([\#2881](https://github.com/matrix-org/matrix-js-sdk/pull/2881)).
- * Make GroupCall work better with widgets ([\#2935](https://github.com/matrix-org/matrix-js-sdk/pull/2935)).
- * Fix highlight notifications increasing when total notification is zero ([\#2937](https://github.com/matrix-org/matrix-js-sdk/pull/2937)). Fixes vector-im/element-web#23885.
- * Fix synthesizeReceipt ([\#2916](https://github.com/matrix-org/matrix-js-sdk/pull/2916)). Fixes vector-im/element-web#23827 vector-im/element-web#23754 and vector-im/element-web#23847.
 
-Changes in [21.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.2.0) (2022-11-22)
-==================================================================================================
+-   Fix 3pid invite acceptance not working due to mxid being sent in body ([\#2907](https://github.com/matrix-org/matrix-js-sdk/pull/2907)). Fixes vector-im/element-web#23823.
+-   Don't hang up calls that haven't started yet ([\#2898](https://github.com/matrix-org/matrix-js-sdk/pull/2898)).
+-   Read receipt accumulation for threads ([\#2881](https://github.com/matrix-org/matrix-js-sdk/pull/2881)).
+-   Make GroupCall work better with widgets ([\#2935](https://github.com/matrix-org/matrix-js-sdk/pull/2935)).
+-   Fix highlight notifications increasing when total notification is zero ([\#2937](https://github.com/matrix-org/matrix-js-sdk/pull/2937)). Fixes vector-im/element-web#23885.
+-   Fix synthesizeReceipt ([\#2916](https://github.com/matrix-org/matrix-js-sdk/pull/2916)). Fixes vector-im/element-web#23827 vector-im/element-web#23754 and vector-im/element-web#23847.
+
+# Changes in [21.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.2.0) (2022-11-22)
 
 ## ✨ Features
- * Make calls go back to 'connecting' state when media lost ([\#2880](https://github.com/matrix-org/matrix-js-sdk/pull/2880)).
- * Add ability to send unthreaded receipt ([\#2878](https://github.com/matrix-org/matrix-js-sdk/pull/2878)).
- * Add way to abort search requests ([\#2877](https://github.com/matrix-org/matrix-js-sdk/pull/2877)).
- * sliding sync: add custom room subscriptions support ([\#2834](https://github.com/matrix-org/matrix-js-sdk/pull/2834)).
- * webrtc: add advanced audio settings ([\#2434](https://github.com/matrix-org/matrix-js-sdk/pull/2434)). Contributed by @MrAnno.
- * Add support for group calls using MSC3401 ([\#2553](https://github.com/matrix-org/matrix-js-sdk/pull/2553)).
- * Make the js-sdk conform to tsc --strict ([\#2835](https://github.com/matrix-org/matrix-js-sdk/pull/2835)). Fixes #2112 #2116 and #2124.
- * Let leave requests outlive the window ([\#2815](https://github.com/matrix-org/matrix-js-sdk/pull/2815)). Fixes vector-im/element-call#639.
- * Add event and message capabilities to RoomWidgetClient ([\#2797](https://github.com/matrix-org/matrix-js-sdk/pull/2797)).
- * Misc fixes for group call widgets ([\#2657](https://github.com/matrix-org/matrix-js-sdk/pull/2657)).
- * Support nested Matrix clients via the widget API ([\#2473](https://github.com/matrix-org/matrix-js-sdk/pull/2473)).
- * Set max average bitrate on PTT calls ([\#2499](https://github.com/matrix-org/matrix-js-sdk/pull/2499)). Fixes vector-im/element-call#440.
- * Add config option for e2e group call signalling ([\#2492](https://github.com/matrix-org/matrix-js-sdk/pull/2492)).
- * Enable DTX on audio tracks in calls ([\#2482](https://github.com/matrix-org/matrix-js-sdk/pull/2482)).
- * Don't ignore call member events with a distant future expiration date ([\#2466](https://github.com/matrix-org/matrix-js-sdk/pull/2466)).
- * Expire call member state events after 1 hour ([\#2446](https://github.com/matrix-org/matrix-js-sdk/pull/2446)).
- * Emit unknown device errors for group call participants without e2e ([\#2447](https://github.com/matrix-org/matrix-js-sdk/pull/2447)).
- * Mute disconnected peers in PTT mode ([\#2421](https://github.com/matrix-org/matrix-js-sdk/pull/2421)).
- * Add support for sending encrypted to-device events with OLM ([\#2322](https://github.com/matrix-org/matrix-js-sdk/pull/2322)). Contributed by @robertlong.
- * Support for PTT group call mode ([\#2338](https://github.com/matrix-org/matrix-js-sdk/pull/2338)).
+
+-   Make calls go back to 'connecting' state when media lost ([\#2880](https://github.com/matrix-org/matrix-js-sdk/pull/2880)).
+-   Add ability to send unthreaded receipt ([\#2878](https://github.com/matrix-org/matrix-js-sdk/pull/2878)).
+-   Add way to abort search requests ([\#2877](https://github.com/matrix-org/matrix-js-sdk/pull/2877)).
+-   sliding sync: add custom room subscriptions support ([\#2834](https://github.com/matrix-org/matrix-js-sdk/pull/2834)).
+-   webrtc: add advanced audio settings ([\#2434](https://github.com/matrix-org/matrix-js-sdk/pull/2434)). Contributed by @MrAnno.
+-   Add support for group calls using MSC3401 ([\#2553](https://github.com/matrix-org/matrix-js-sdk/pull/2553)).
+-   Make the js-sdk conform to tsc --strict ([\#2835](https://github.com/matrix-org/matrix-js-sdk/pull/2835)). Fixes #2112 #2116 and #2124.
+-   Let leave requests outlive the window ([\#2815](https://github.com/matrix-org/matrix-js-sdk/pull/2815)). Fixes vector-im/element-call#639.
+-   Add event and message capabilities to RoomWidgetClient ([\#2797](https://github.com/matrix-org/matrix-js-sdk/pull/2797)).
+-   Misc fixes for group call widgets ([\#2657](https://github.com/matrix-org/matrix-js-sdk/pull/2657)).
+-   Support nested Matrix clients via the widget API ([\#2473](https://github.com/matrix-org/matrix-js-sdk/pull/2473)).
+-   Set max average bitrate on PTT calls ([\#2499](https://github.com/matrix-org/matrix-js-sdk/pull/2499)). Fixes vector-im/element-call#440.
+-   Add config option for e2e group call signalling ([\#2492](https://github.com/matrix-org/matrix-js-sdk/pull/2492)).
+-   Enable DTX on audio tracks in calls ([\#2482](https://github.com/matrix-org/matrix-js-sdk/pull/2482)).
+-   Don't ignore call member events with a distant future expiration date ([\#2466](https://github.com/matrix-org/matrix-js-sdk/pull/2466)).
+-   Expire call member state events after 1 hour ([\#2446](https://github.com/matrix-org/matrix-js-sdk/pull/2446)).
+-   Emit unknown device errors for group call participants without e2e ([\#2447](https://github.com/matrix-org/matrix-js-sdk/pull/2447)).
+-   Mute disconnected peers in PTT mode ([\#2421](https://github.com/matrix-org/matrix-js-sdk/pull/2421)).
+-   Add support for sending encrypted to-device events with OLM ([\#2322](https://github.com/matrix-org/matrix-js-sdk/pull/2322)). Contributed by @robertlong.
+-   Support for PTT group call mode ([\#2338](https://github.com/matrix-org/matrix-js-sdk/pull/2338)).
 
 ## 🐛 Bug Fixes
- * Fix registration add phone number not working ([\#2876](https://github.com/matrix-org/matrix-js-sdk/pull/2876)). Contributed by @bagvand.
- * Use an underride rule for Element Call notifications ([\#2873](https://github.com/matrix-org/matrix-js-sdk/pull/2873)). Fixes vector-im/element-web#23691.
- * Fixes unwanted highlight notifications with encrypted threads ([\#2862](https://github.com/matrix-org/matrix-js-sdk/pull/2862)).
- * Extra insurance that we don't mix events in the wrong timelines - v2 ([\#2856](https://github.com/matrix-org/matrix-js-sdk/pull/2856)). Contributed by @MadLittleMods.
- * Hide pending events in thread timelines ([\#2843](https://github.com/matrix-org/matrix-js-sdk/pull/2843)). Fixes vector-im/element-web#23684.
- * Fix pagination token tracking for mixed room timelines ([\#2855](https://github.com/matrix-org/matrix-js-sdk/pull/2855)). Fixes vector-im/element-web#23695.
- * Extra insurance that we don't mix events in the wrong timelines ([\#2848](https://github.com/matrix-org/matrix-js-sdk/pull/2848)). Contributed by @MadLittleMods.
- * Do not freeze state in `initialiseState()` ([\#2846](https://github.com/matrix-org/matrix-js-sdk/pull/2846)).
- * Don't remove our own member for a split second when entering a call ([\#2844](https://github.com/matrix-org/matrix-js-sdk/pull/2844)).
- * Resolve races between `initLocalCallFeed` and `leave` ([\#2826](https://github.com/matrix-org/matrix-js-sdk/pull/2826)).
- * Add throwOnFail to groupCall.setScreensharingEnabled ([\#2787](https://github.com/matrix-org/matrix-js-sdk/pull/2787)).
- * Fix connectivity regressions ([\#2780](https://github.com/matrix-org/matrix-js-sdk/pull/2780)).
- * Fix screenshare failing after several attempts ([\#2771](https://github.com/matrix-org/matrix-js-sdk/pull/2771)). Fixes vector-im/element-call#625.
- * Don't block muting/unmuting on network requests ([\#2754](https://github.com/matrix-org/matrix-js-sdk/pull/2754)). Fixes vector-im/element-call#592.
- * Fix ICE restarts ([\#2702](https://github.com/matrix-org/matrix-js-sdk/pull/2702)).
- * Target widget actions at a specific room ([\#2670](https://github.com/matrix-org/matrix-js-sdk/pull/2670)).
- * Add tests for ice candidate sending ([\#2674](https://github.com/matrix-org/matrix-js-sdk/pull/2674)).
- * Prevent exception when muting ([\#2667](https://github.com/matrix-org/matrix-js-sdk/pull/2667)). Fixes vector-im/element-call#578.
- * Fix race in creating calls ([\#2662](https://github.com/matrix-org/matrix-js-sdk/pull/2662)).
- * Add client.waitUntilRoomReadyForGroupCalls() ([\#2641](https://github.com/matrix-org/matrix-js-sdk/pull/2641)).
- * Wait for client to start syncing before making group calls ([\#2632](https://github.com/matrix-org/matrix-js-sdk/pull/2632)). Fixes #2589.
- * Add GroupCallEventHandlerEvent.Room ([\#2631](https://github.com/matrix-org/matrix-js-sdk/pull/2631)).
- * Add missing events from reemitter to GroupCall ([\#2527](https://github.com/matrix-org/matrix-js-sdk/pull/2527)). Contributed by @toger5.
- * Prevent double mute status changed events ([\#2502](https://github.com/matrix-org/matrix-js-sdk/pull/2502)).
- * Don't mute the remote side immediately in PTT calls ([\#2487](https://github.com/matrix-org/matrix-js-sdk/pull/2487)). Fixes vector-im/element-call#425.
- * Fix some MatrixCall leaks and use a shared AudioContext ([\#2484](https://github.com/matrix-org/matrix-js-sdk/pull/2484)). Fixes vector-im/element-call#412.
- * Don't block muting on determining whether the device exists ([\#2461](https://github.com/matrix-org/matrix-js-sdk/pull/2461)).
- * Only clone streams on Safari ([\#2450](https://github.com/matrix-org/matrix-js-sdk/pull/2450)). Fixes vector-im/element-call#267.
- * Set PTT mode on call correctly ([\#2445](https://github.com/matrix-org/matrix-js-sdk/pull/2445)). Fixes vector-im/element-call#382.
- * Wait for mute event to send in PTT mode ([\#2401](https://github.com/matrix-org/matrix-js-sdk/pull/2401)).
- * Handle other members having no e2e keys ([\#2383](https://github.com/matrix-org/matrix-js-sdk/pull/2383)). Fixes vector-im/element-call#338.
- * Fix races when muting/unmuting ([\#2370](https://github.com/matrix-org/matrix-js-sdk/pull/2370)).
-
-Changes in [21.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.1.0) (2022-11-08)
-==================================================================================================
+
+-   Fix registration add phone number not working ([\#2876](https://github.com/matrix-org/matrix-js-sdk/pull/2876)). Contributed by @bagvand.
+-   Use an underride rule for Element Call notifications ([\#2873](https://github.com/matrix-org/matrix-js-sdk/pull/2873)). Fixes vector-im/element-web#23691.
+-   Fixes unwanted highlight notifications with encrypted threads ([\#2862](https://github.com/matrix-org/matrix-js-sdk/pull/2862)).
+-   Extra insurance that we don't mix events in the wrong timelines - v2 ([\#2856](https://github.com/matrix-org/matrix-js-sdk/pull/2856)). Contributed by @MadLittleMods.
+-   Hide pending events in thread timelines ([\#2843](https://github.com/matrix-org/matrix-js-sdk/pull/2843)). Fixes vector-im/element-web#23684.
+-   Fix pagination token tracking for mixed room timelines ([\#2855](https://github.com/matrix-org/matrix-js-sdk/pull/2855)). Fixes vector-im/element-web#23695.
+-   Extra insurance that we don't mix events in the wrong timelines ([\#2848](https://github.com/matrix-org/matrix-js-sdk/pull/2848)). Contributed by @MadLittleMods.
+-   Do not freeze state in `initialiseState()` ([\#2846](https://github.com/matrix-org/matrix-js-sdk/pull/2846)).
+-   Don't remove our own member for a split second when entering a call ([\#2844](https://github.com/matrix-org/matrix-js-sdk/pull/2844)).
+-   Resolve races between `initLocalCallFeed` and `leave` ([\#2826](https://github.com/matrix-org/matrix-js-sdk/pull/2826)).
+-   Add throwOnFail to groupCall.setScreensharingEnabled ([\#2787](https://github.com/matrix-org/matrix-js-sdk/pull/2787)).
+-   Fix connectivity regressions ([\#2780](https://github.com/matrix-org/matrix-js-sdk/pull/2780)).
+-   Fix screenshare failing after several attempts ([\#2771](https://github.com/matrix-org/matrix-js-sdk/pull/2771)). Fixes vector-im/element-call#625.
+-   Don't block muting/unmuting on network requests ([\#2754](https://github.com/matrix-org/matrix-js-sdk/pull/2754)). Fixes vector-im/element-call#592.
+-   Fix ICE restarts ([\#2702](https://github.com/matrix-org/matrix-js-sdk/pull/2702)).
+-   Target widget actions at a specific room ([\#2670](https://github.com/matrix-org/matrix-js-sdk/pull/2670)).
+-   Add tests for ice candidate sending ([\#2674](https://github.com/matrix-org/matrix-js-sdk/pull/2674)).
+-   Prevent exception when muting ([\#2667](https://github.com/matrix-org/matrix-js-sdk/pull/2667)). Fixes vector-im/element-call#578.
+-   Fix race in creating calls ([\#2662](https://github.com/matrix-org/matrix-js-sdk/pull/2662)).
+-   Add client.waitUntilRoomReadyForGroupCalls() ([\#2641](https://github.com/matrix-org/matrix-js-sdk/pull/2641)).
+-   Wait for client to start syncing before making group calls ([\#2632](https://github.com/matrix-org/matrix-js-sdk/pull/2632)). Fixes #2589.
+-   Add GroupCallEventHandlerEvent.Room ([\#2631](https://github.com/matrix-org/matrix-js-sdk/pull/2631)).
+-   Add missing events from reemitter to GroupCall ([\#2527](https://github.com/matrix-org/matrix-js-sdk/pull/2527)). Contributed by @toger5.
+-   Prevent double mute status changed events ([\#2502](https://github.com/matrix-org/matrix-js-sdk/pull/2502)).
+-   Don't mute the remote side immediately in PTT calls ([\#2487](https://github.com/matrix-org/matrix-js-sdk/pull/2487)). Fixes vector-im/element-call#425.
+-   Fix some MatrixCall leaks and use a shared AudioContext ([\#2484](https://github.com/matrix-org/matrix-js-sdk/pull/2484)). Fixes vector-im/element-call#412.
+-   Don't block muting on determining whether the device exists ([\#2461](https://github.com/matrix-org/matrix-js-sdk/pull/2461)).
+-   Only clone streams on Safari ([\#2450](https://github.com/matrix-org/matrix-js-sdk/pull/2450)). Fixes vector-im/element-call#267.
+-   Set PTT mode on call correctly ([\#2445](https://github.com/matrix-org/matrix-js-sdk/pull/2445)). Fixes vector-im/element-call#382.
+-   Wait for mute event to send in PTT mode ([\#2401](https://github.com/matrix-org/matrix-js-sdk/pull/2401)).
+-   Handle other members having no e2e keys ([\#2383](https://github.com/matrix-org/matrix-js-sdk/pull/2383)). Fixes vector-im/element-call#338.
+-   Fix races when muting/unmuting ([\#2370](https://github.com/matrix-org/matrix-js-sdk/pull/2370)).
+
+# Changes in [21.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.1.0) (2022-11-08)
 
 ## ✨ Features
- * Loading threads with server-side assistance ([\#2735](https://github.com/matrix-org/matrix-js-sdk/pull/2735)). Contributed by @justjanne.
- * Support sign in + E2EE set up using QR code implementing MSC3886, MSC3903 and MSC3906 ([\#2747](https://github.com/matrix-org/matrix-js-sdk/pull/2747)). Contributed by @hughns.
+
+-   Loading threads with server-side assistance ([\#2735](https://github.com/matrix-org/matrix-js-sdk/pull/2735)). Contributed by @justjanne.
+-   Support sign in + E2EE set up using QR code implementing MSC3886, MSC3903 and MSC3906 ([\#2747](https://github.com/matrix-org/matrix-js-sdk/pull/2747)). Contributed by @hughns.
 
 ## 🐛 Bug Fixes
- * Replace `instanceof Array` with `Array.isArray` ([\#2812](https://github.com/matrix-org/matrix-js-sdk/pull/2812)). Fixes #2811.
- * Emit UnreadNotification event on notifications reset ([\#2804](https://github.com/matrix-org/matrix-js-sdk/pull/2804)). Fixes vector-im/element-web#23590.
- * Fix incorrect prevEv being sent in ClientEvent.AccountData events ([\#2794](https://github.com/matrix-org/matrix-js-sdk/pull/2794)).
- * Fix build error caused by wrong ts-strict improvements ([\#2783](https://github.com/matrix-org/matrix-js-sdk/pull/2783)). Contributed by @justjanne.
- * Encryption should not hinder verification ([\#2734](https://github.com/matrix-org/matrix-js-sdk/pull/2734)).
 
-Changes in [21.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.1) (2022-11-01)
-==================================================================================================
+-   Replace `instanceof Array` with `Array.isArray` ([\#2812](https://github.com/matrix-org/matrix-js-sdk/pull/2812)). Fixes #2811.
+-   Emit UnreadNotification event on notifications reset ([\#2804](https://github.com/matrix-org/matrix-js-sdk/pull/2804)). Fixes vector-im/element-web#23590.
+-   Fix incorrect prevEv being sent in ClientEvent.AccountData events ([\#2794](https://github.com/matrix-org/matrix-js-sdk/pull/2794)).
+-   Fix build error caused by wrong ts-strict improvements ([\#2783](https://github.com/matrix-org/matrix-js-sdk/pull/2783)). Contributed by @justjanne.
+-   Encryption should not hinder verification ([\#2734](https://github.com/matrix-org/matrix-js-sdk/pull/2734)).
+
+# Changes in [21.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.1) (2022-11-01)
 
 ## 🐛 Bug Fixes
- * Fix default behavior of Room.getBlacklistUnverifiedDevices ([\#2830](https://github.com/matrix-org/matrix-js-sdk/pull/2830)). Contributed by @duxovni.
- * Catch server versions API call exception when starting the client ([\#2828](https://github.com/matrix-org/matrix-js-sdk/pull/2828)). Fixes vector-im/element-web#23634.
- * Fix authedRequest including `Authorization: Bearer undefined` for password resets ([\#2822](https://github.com/matrix-org/matrix-js-sdk/pull/2822)). Fixes vector-im/element-web#23655.
 
-Changes in [21.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.0) (2022-10-25)
-==================================================================================================
+-   Fix default behavior of Room.getBlacklistUnverifiedDevices ([\#2830](https://github.com/matrix-org/matrix-js-sdk/pull/2830)). Contributed by @duxovni.
+-   Catch server versions API call exception when starting the client ([\#2828](https://github.com/matrix-org/matrix-js-sdk/pull/2828)). Fixes vector-im/element-web#23634.
+-   Fix authedRequest including `Authorization: Bearer undefined` for password resets ([\#2822](https://github.com/matrix-org/matrix-js-sdk/pull/2822)). Fixes vector-im/element-web#23655.
+
+# Changes in [21.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.0) (2022-10-25)
 
 ## 🚨 BREAKING CHANGES
- * Changes the `uploadContent` API, kills off `request` and `browser-request` in favour of `fetch`, removed callback support on a lot of the methods, adds a lot of tests. ([\#2719](https://github.com/matrix-org/matrix-js-sdk/pull/2719)). Fixes #2415 and #801.
- * Remove deprecated `m.room.aliases` references ([\#2759](https://github.com/matrix-org/matrix-js-sdk/pull/2759)). Fixes vector-im/element-web#12680.
+
+-   Changes the `uploadContent` API, kills off `request` and `browser-request` in favour of `fetch`, removed callback support on a lot of the methods, adds a lot of tests. ([\#2719](https://github.com/matrix-org/matrix-js-sdk/pull/2719)). Fixes #2415 and #801.
+-   Remove deprecated `m.room.aliases` references ([\#2759](https://github.com/matrix-org/matrix-js-sdk/pull/2759)). Fixes vector-im/element-web#12680.
 
 ## ✨ Features
- * Remove node-specific crypto bits, use Node 16's WebCrypto ([\#2762](https://github.com/matrix-org/matrix-js-sdk/pull/2762)). Fixes #2760.
- * Export types for MatrixEvent and Room emitted events, and make event handler map types stricter ([\#2750](https://github.com/matrix-org/matrix-js-sdk/pull/2750)). Contributed by @stas-demydiuk.
- * Use even more stable calls to `/room_keys` ([\#2746](https://github.com/matrix-org/matrix-js-sdk/pull/2746)).
- * Upgrade to Olm 3.2.13 which has been repackaged to support Node 18 ([\#2744](https://github.com/matrix-org/matrix-js-sdk/pull/2744)).
- * Fix `power_level_content_override` type ([\#2741](https://github.com/matrix-org/matrix-js-sdk/pull/2741)).
- * Add custom notification handling for MSC3401 call events  ([\#2720](https://github.com/matrix-org/matrix-js-sdk/pull/2720)).
- * Add support for unread thread notifications ([\#2726](https://github.com/matrix-org/matrix-js-sdk/pull/2726)).
- * Load Thread List with server-side assistance (MSC3856) ([\#2602](https://github.com/matrix-org/matrix-js-sdk/pull/2602)).
- * Use stable calls to `/room_keys` ([\#2729](https://github.com/matrix-org/matrix-js-sdk/pull/2729)). Fixes vector-im/element-web#22839.
+
+-   Remove node-specific crypto bits, use Node 16's WebCrypto ([\#2762](https://github.com/matrix-org/matrix-js-sdk/pull/2762)). Fixes #2760.
+-   Export types for MatrixEvent and Room emitted events, and make event handler map types stricter ([\#2750](https://github.com/matrix-org/matrix-js-sdk/pull/2750)). Contributed by @stas-demydiuk.
+-   Use even more stable calls to `/room_keys` ([\#2746](https://github.com/matrix-org/matrix-js-sdk/pull/2746)).
+-   Upgrade to Olm 3.2.13 which has been repackaged to support Node 18 ([\#2744](https://github.com/matrix-org/matrix-js-sdk/pull/2744)).
+-   Fix `power_level_content_override` type ([\#2741](https://github.com/matrix-org/matrix-js-sdk/pull/2741)).
+-   Add custom notification handling for MSC3401 call events ([\#2720](https://github.com/matrix-org/matrix-js-sdk/pull/2720)).
+-   Add support for unread thread notifications ([\#2726](https://github.com/matrix-org/matrix-js-sdk/pull/2726)).
+-   Load Thread List with server-side assistance (MSC3856) ([\#2602](https://github.com/matrix-org/matrix-js-sdk/pull/2602)).
+-   Use stable calls to `/room_keys` ([\#2729](https://github.com/matrix-org/matrix-js-sdk/pull/2729)). Fixes vector-im/element-web#22839.
 
 ## 🐛 Bug Fixes
- * Fix POST data not being passed for registerWithIdentityServer ([\#2769](https://github.com/matrix-org/matrix-js-sdk/pull/2769)). Fixes matrix-org/element-web-rageshakes#16206.
- * Fix IdentityPrefix.V2 containing spurious `/api` ([\#2761](https://github.com/matrix-org/matrix-js-sdk/pull/2761)). Fixes vector-im/element-web#23505.
- * Always send back an httpStatus property if one is known ([\#2753](https://github.com/matrix-org/matrix-js-sdk/pull/2753)).
- * Check for AbortError, not any generic connection error, to avoid tightlooping ([\#2752](https://github.com/matrix-org/matrix-js-sdk/pull/2752)).
- * Correct the dir parameter of MSC3715 ([\#2745](https://github.com/matrix-org/matrix-js-sdk/pull/2745)). Contributed by @dhenneke.
- * Fix sync init when thread unread notif is not supported ([\#2739](https://github.com/matrix-org/matrix-js-sdk/pull/2739)). Fixes vector-im/element-web#23435.
- * Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
 
-Changes in [20.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.1.0) (2022-10-11)
-============================================================================================================
+-   Fix POST data not being passed for registerWithIdentityServer ([\#2769](https://github.com/matrix-org/matrix-js-sdk/pull/2769)). Fixes matrix-org/element-web-rageshakes#16206.
+-   Fix IdentityPrefix.V2 containing spurious `/api` ([\#2761](https://github.com/matrix-org/matrix-js-sdk/pull/2761)). Fixes vector-im/element-web#23505.
+-   Always send back an httpStatus property if one is known ([\#2753](https://github.com/matrix-org/matrix-js-sdk/pull/2753)).
+-   Check for AbortError, not any generic connection error, to avoid tightlooping ([\#2752](https://github.com/matrix-org/matrix-js-sdk/pull/2752)).
+-   Correct the dir parameter of MSC3715 ([\#2745](https://github.com/matrix-org/matrix-js-sdk/pull/2745)). Contributed by @dhenneke.
+-   Fix sync init when thread unread notif is not supported ([\#2739](https://github.com/matrix-org/matrix-js-sdk/pull/2739)). Fixes vector-im/element-web#23435.
+-   Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
+
+# Changes in [20.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.1.0) (2022-10-11)
 
 ## ✨ Features
- * Add local notification settings capability ([\#2700](https://github.com/matrix-org/matrix-js-sdk/pull/2700)).
- * Implementation of MSC3882 login token request ([\#2687](https://github.com/matrix-org/matrix-js-sdk/pull/2687)). Contributed by @hughns.
- * Typings for MSC2965 OIDC provider discovery ([\#2424](https://github.com/matrix-org/matrix-js-sdk/pull/2424)). Contributed by @hughns.
- * Support to remotely toggle push notifications ([\#2686](https://github.com/matrix-org/matrix-js-sdk/pull/2686)).
- * Read receipts for threads ([\#2635](https://github.com/matrix-org/matrix-js-sdk/pull/2635)).
+
+-   Add local notification settings capability ([\#2700](https://github.com/matrix-org/matrix-js-sdk/pull/2700)).
+-   Implementation of MSC3882 login token request ([\#2687](https://github.com/matrix-org/matrix-js-sdk/pull/2687)). Contributed by @hughns.
+-   Typings for MSC2965 OIDC provider discovery ([\#2424](https://github.com/matrix-org/matrix-js-sdk/pull/2424)). Contributed by @hughns.
+-   Support to remotely toggle push notifications ([\#2686](https://github.com/matrix-org/matrix-js-sdk/pull/2686)).
+-   Read receipts for threads ([\#2635](https://github.com/matrix-org/matrix-js-sdk/pull/2635)).
 
 ## 🐛 Bug Fixes
- * Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
- * Unexpected ignored self key request when it's not shared history ([\#2724](https://github.com/matrix-org/matrix-js-sdk/pull/2724)). Contributed by @mcalinghee.
- * Fix IDB initial migration handling causing spurious lazy loading upgrade loops ([\#2718](https://github.com/matrix-org/matrix-js-sdk/pull/2718)). Fixes vector-im/element-web#23377.
- * Fix backpagination at end logic being spec non-conforming ([\#2680](https://github.com/matrix-org/matrix-js-sdk/pull/2680)). Fixes vector-im/element-web#22784.
 
-Changes in [20.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.2) (2022-09-30)
-==================================================================================================
+-   Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
+-   Unexpected ignored self key request when it's not shared history ([\#2724](https://github.com/matrix-org/matrix-js-sdk/pull/2724)). Contributed by @mcalinghee.
+-   Fix IDB initial migration handling causing spurious lazy loading upgrade loops ([\#2718](https://github.com/matrix-org/matrix-js-sdk/pull/2718)). Fixes vector-im/element-web#23377.
+-   Fix backpagination at end logic being spec non-conforming ([\#2680](https://github.com/matrix-org/matrix-js-sdk/pull/2680)). Fixes vector-im/element-web#22784.
+
+# Changes in [20.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.2) (2022-09-30)
 
 ## 🐛 Bug Fixes
- * Fix issue in sync when crypto is not supported by client ([\#2715](https://github.com/matrix-org/matrix-js-sdk/pull/2715)). Contributed by @stas-demydiuk.
 
-Changes in [20.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.1) (2022-09-28)
-==================================================================================================
+-   Fix issue in sync when crypto is not supported by client ([\#2715](https://github.com/matrix-org/matrix-js-sdk/pull/2715)). Contributed by @stas-demydiuk.
+
+# Changes in [20.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.1) (2022-09-28)
 
 ## 🐛 Bug Fixes
- * Fix missing return when receiving an invitation without shared history ([\#2710](https://github.com/matrix-org/matrix-js-sdk/pull/2710)).
 
-Changes in [20.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.0) (2022-09-28)
-==================================================================================================
+-   Fix missing return when receiving an invitation without shared history ([\#2710](https://github.com/matrix-org/matrix-js-sdk/pull/2710)).
+
+# Changes in [20.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.0) (2022-09-28)
 
 ## 🚨 BREAKING CHANGES
- * Bump IDB crypto store version ([\#2705](https://github.com/matrix-org/matrix-js-sdk/pull/2705)).
 
-Changes in [19.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.7.0) (2022-09-28)
-==================================================================================================
+-   Bump IDB crypto store version ([\#2705](https://github.com/matrix-org/matrix-js-sdk/pull/2705)).
+
+# Changes in [19.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.7.0) (2022-09-28)
 
 ## 🔒 Security
-* Fix for [CVE-2022-39249](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39249)
-* Fix for [CVE-2022-39250](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39250)
-* Fix for [CVE-2022-39251](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39251)
-* Fix for [CVE-2022-39236](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39236)
 
-Changes in [19.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.6.0) (2022-09-27)
-==================================================================================================
+-   Fix for [CVE-2022-39249](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39249)
+-   Fix for [CVE-2022-39250](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39250)
+-   Fix for [CVE-2022-39251](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39251)
+-   Fix for [CVE-2022-39236](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39236)
+
+# Changes in [19.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.6.0) (2022-09-27)
 
 ## ✨ Features
- * Add a property aggregating all names of a NamespacedValue ([\#2656](https://github.com/matrix-org/matrix-js-sdk/pull/2656)).
- * Implementation of MSC3824 to add action= param on SSO login ([\#2398](https://github.com/matrix-org/matrix-js-sdk/pull/2398)). Contributed by @hughns.
- * Add invited_count and joined_count to sliding sync room responses. ([\#2628](https://github.com/matrix-org/matrix-js-sdk/pull/2628)).
- * Base support for MSC3847: Ignore invites with policy rooms ([\#2626](https://github.com/matrix-org/matrix-js-sdk/pull/2626)). Contributed by @Yoric.
+
+-   Add a property aggregating all names of a NamespacedValue ([\#2656](https://github.com/matrix-org/matrix-js-sdk/pull/2656)).
+-   Implementation of MSC3824 to add action= param on SSO login ([\#2398](https://github.com/matrix-org/matrix-js-sdk/pull/2398)). Contributed by @hughns.
+-   Add invited_count and joined_count to sliding sync room responses. ([\#2628](https://github.com/matrix-org/matrix-js-sdk/pull/2628)).
+-   Base support for MSC3847: Ignore invites with policy rooms ([\#2626](https://github.com/matrix-org/matrix-js-sdk/pull/2626)). Contributed by @Yoric.
 
 ## 🐛 Bug Fixes
- * Fix handling of remote echoes doubling up ([\#2639](https://github.com/matrix-org/matrix-js-sdk/pull/2639)). Fixes #2618.
 
-Changes in [19.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.5.0) (2022-09-13)
-==================================================================================================
+-   Fix handling of remote echoes doubling up ([\#2639](https://github.com/matrix-org/matrix-js-sdk/pull/2639)). Fixes #2618.
+
+# Changes in [19.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.5.0) (2022-09-13)
 
 ## 🐛 Bug Fixes
- * Fix bug in deepCompare which would incorrectly return objects with disjoint keys as equal ([\#2586](https://github.com/matrix-org/matrix-js-sdk/pull/2586)). Contributed by @3nprob.
- * Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
- * Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
- * Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
 
-Changes in [19.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.4.0) (2022-08-31)
-==================================================================================================
+-   Fix bug in deepCompare which would incorrectly return objects with disjoint keys as equal ([\#2586](https://github.com/matrix-org/matrix-js-sdk/pull/2586)). Contributed by @3nprob.
+-   Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
+-   Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
+-   Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
+
+# Changes in [19.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.4.0) (2022-08-31)
 
 ## 🔒 Security
-* Fix for [CVE-2022-36059](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D36059)
+
+-   Fix for [CVE-2022-36059](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D36059)
 
 Find more details at https://matrix.org/blog/2022/08/31/security-releases-matrix-js-sdk-19-4-0-and-matrix-react-sdk-3-53-0
 
 ## ✨ Features
- * Re-emit room state events on rooms ([\#2607](https://github.com/matrix-org/matrix-js-sdk/pull/2607)).
- * Add ability to override built in room name generator for an i18n'able one ([\#2609](https://github.com/matrix-org/matrix-js-sdk/pull/2609)).
- * Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
+
+-   Re-emit room state events on rooms ([\#2607](https://github.com/matrix-org/matrix-js-sdk/pull/2607)).
+-   Add ability to override built in room name generator for an i18n'able one ([\#2609](https://github.com/matrix-org/matrix-js-sdk/pull/2609)).
+-   Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
 
 ## 🐛 Bug Fixes
- * Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
- * Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
- * Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
- * fixed a sliding sync bug which could cause the `roomIndexToRoomId` map to be incorrect when a new room is added in the middle of the list or when an existing room is deleted from the middle of the list. ([\#2610](https://github.com/matrix-org/matrix-js-sdk/pull/2610)).
- * Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078. Contributed by @kerryarchibald.
- * Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
- * fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
 
-Changes in [19.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.3.0) (2022-08-16)
-==================================================================================================
+-   Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
+-   Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
+-   Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
+-   fixed a sliding sync bug which could cause the `roomIndexToRoomId` map to be incorrect when a new room is added in the middle of the list or when an existing room is deleted from the middle of the list. ([\#2610](https://github.com/matrix-org/matrix-js-sdk/pull/2610)).
+-   Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078. Contributed by @kerryarchibald.
+-   Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
+-   fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
+
+# Changes in [19.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.3.0) (2022-08-16)
 
 ## ✨ Features
- * Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
- * Emit an event when the client receives TURN servers ([\#2529](https://github.com/matrix-org/matrix-js-sdk/pull/2529)).
- * Add support for stable prefixes for MSC2285 ([\#2524](https://github.com/matrix-org/matrix-js-sdk/pull/2524)).
- * Remove stream-replacement ([\#2551](https://github.com/matrix-org/matrix-js-sdk/pull/2551)).
- * Add support for sending user-defined encrypted to-device messages ([\#2528](https://github.com/matrix-org/matrix-js-sdk/pull/2528)).
- * Retry to-device messages ([\#2549](https://github.com/matrix-org/matrix-js-sdk/pull/2549)). Fixes vector-im/element-web#12851.
- * Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
- * Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
+
+-   Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
+-   Emit an event when the client receives TURN servers ([\#2529](https://github.com/matrix-org/matrix-js-sdk/pull/2529)).
+-   Add support for stable prefixes for MSC2285 ([\#2524](https://github.com/matrix-org/matrix-js-sdk/pull/2524)).
+-   Remove stream-replacement ([\#2551](https://github.com/matrix-org/matrix-js-sdk/pull/2551)).
+-   Add support for sending user-defined encrypted to-device messages ([\#2528](https://github.com/matrix-org/matrix-js-sdk/pull/2528)).
+-   Retry to-device messages ([\#2549](https://github.com/matrix-org/matrix-js-sdk/pull/2549)). Fixes vector-im/element-web#12851.
+-   Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
+-   Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
 
 ## 🐛 Bug Fixes
- * Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078.
- * Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
- * Fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
- * Don't load the sync accumulator if there's already a sync persist in flight ([\#2569](https://github.com/matrix-org/matrix-js-sdk/pull/2569)).
 
-Changes in [19.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.2.0) (2022-08-02)
-==================================================================================================
+-   Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078.
+-   Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
+-   Fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
+-   Don't load the sync accumulator if there's already a sync persist in flight ([\#2569](https://github.com/matrix-org/matrix-js-sdk/pull/2569)).
+
+# Changes in [19.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.2.0) (2022-08-02)
 
 ## 🦖 Deprecations
- * Remove unstable support for `m.room_key.withheld` ([\#2512](https://github.com/matrix-org/matrix-js-sdk/pull/2512)). Fixes #2233.
+
+-   Remove unstable support for `m.room_key.withheld` ([\#2512](https://github.com/matrix-org/matrix-js-sdk/pull/2512)). Fixes #2233.
 
 ## ✨ Features
- * Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
- * Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
- * Add support for MSC3575: Sliding Sync ([\#2242](https://github.com/matrix-org/matrix-js-sdk/pull/2242)).
+
+-   Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
+-   Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
+-   Add support for MSC3575: Sliding Sync ([\#2242](https://github.com/matrix-org/matrix-js-sdk/pull/2242)).
 
 ## 🐛 Bug Fixes
- * Correct the units in TURN servers expiry documentation ([\#2520](https://github.com/matrix-org/matrix-js-sdk/pull/2520)).
- * Re-insert room IDs when decrypting bundled redaction events returned by `/sync` ([\#2531](https://github.com/matrix-org/matrix-js-sdk/pull/2531)). Contributed by @duxovni.
 
-Changes in [19.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.1.0) (2022-07-26)
-==================================================================================================
+-   Correct the units in TURN servers expiry documentation ([\#2520](https://github.com/matrix-org/matrix-js-sdk/pull/2520)).
+-   Re-insert room IDs when decrypting bundled redaction events returned by `/sync` ([\#2531](https://github.com/matrix-org/matrix-js-sdk/pull/2531)). Contributed by @duxovni.
+
+# Changes in [19.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.1.0) (2022-07-26)
 
 ## 🦖 Deprecations
- * Remove MSC3244 support ([\#2504](https://github.com/matrix-org/matrix-js-sdk/pull/2504)).
+
+-   Remove MSC3244 support ([\#2504](https://github.com/matrix-org/matrix-js-sdk/pull/2504)).
 
 ## ✨ Features
- * `room` now exports `KNOWN_SAFE_ROOM_VERSION` ([\#2474](https://github.com/matrix-org/matrix-js-sdk/pull/2474)).
+
+-   `room` now exports `KNOWN_SAFE_ROOM_VERSION` ([\#2474](https://github.com/matrix-org/matrix-js-sdk/pull/2474)).
 
 ## 🐛 Bug Fixes
- * Don't crash with undefined room in `processBeaconEvents()` ([\#2500](https://github.com/matrix-org/matrix-js-sdk/pull/2500)). Fixes #2494.
- * Properly re-insert room ID in bundled thread relation messages from sync ([\#2505](https://github.com/matrix-org/matrix-js-sdk/pull/2505)). Fixes vector-im/element-web#22094. Contributed by @duxovni.
- * Actually store the identity server in the client when given as an option ([\#2503](https://github.com/matrix-org/matrix-js-sdk/pull/2503)). Fixes vector-im/element-web#22757.
- * Fix call.collectCallStats() ([\#2480](https://github.com/matrix-org/matrix-js-sdk/pull/2480)).
 
-Changes in [19.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.0.0) (2022-07-05)
-==================================================================================================
+-   Don't crash with undefined room in `processBeaconEvents()` ([\#2500](https://github.com/matrix-org/matrix-js-sdk/pull/2500)). Fixes #2494.
+-   Properly re-insert room ID in bundled thread relation messages from sync ([\#2505](https://github.com/matrix-org/matrix-js-sdk/pull/2505)). Fixes vector-im/element-web#22094. Contributed by @duxovni.
+-   Actually store the identity server in the client when given as an option ([\#2503](https://github.com/matrix-org/matrix-js-sdk/pull/2503)). Fixes vector-im/element-web#22757.
+-   Fix call.collectCallStats() ([\#2480](https://github.com/matrix-org/matrix-js-sdk/pull/2480)).
+
+# Changes in [19.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.0.0) (2022-07-05)
 
 ## 🚨 BREAKING CHANGES
- * Remove unused sessionStore ([\#2455](https://github.com/matrix-org/matrix-js-sdk/pull/2455)).
+
+-   Remove unused sessionStore ([\#2455](https://github.com/matrix-org/matrix-js-sdk/pull/2455)).
 
 ## ✨ Features
- * Implement MSC3827: Filtering of `/publicRooms` by room type ([\#2469](https://github.com/matrix-org/matrix-js-sdk/pull/2469)).
- * expose latestLocationEvent on beacon model ([\#2467](https://github.com/matrix-org/matrix-js-sdk/pull/2467)). Contributed by @kerryarchibald.
- * Live location share - add start time leniency ([\#2465](https://github.com/matrix-org/matrix-js-sdk/pull/2465)). Contributed by @kerryarchibald.
- * Log real errors and not just their messages, traces are useful ([\#2464](https://github.com/matrix-org/matrix-js-sdk/pull/2464)).
- * Various changes to `src/crypto` files for correctness ([\#2137](https://github.com/matrix-org/matrix-js-sdk/pull/2137)). Contributed by @ShadowJonathan.
- * Update MSC3786 implementation: Check the `state_key` ([\#2429](https://github.com/matrix-org/matrix-js-sdk/pull/2429)).
- * Timeline needs to refresh when we see a MSC2716 marker event  ([\#2299](https://github.com/matrix-org/matrix-js-sdk/pull/2299)). Contributed by @MadLittleMods.
- * Try to load keys from key backup when a message fails to decrypt ([\#2373](https://github.com/matrix-org/matrix-js-sdk/pull/2373)). Fixes vector-im/element-web#21026. Contributed by @duxovni.
+
+-   Implement MSC3827: Filtering of `/publicRooms` by room type ([\#2469](https://github.com/matrix-org/matrix-js-sdk/pull/2469)).
+-   expose latestLocationEvent on beacon model ([\#2467](https://github.com/matrix-org/matrix-js-sdk/pull/2467)). Contributed by @kerryarchibald.
+-   Live location share - add start time leniency ([\#2465](https://github.com/matrix-org/matrix-js-sdk/pull/2465)). Contributed by @kerryarchibald.
+-   Log real errors and not just their messages, traces are useful ([\#2464](https://github.com/matrix-org/matrix-js-sdk/pull/2464)).
+-   Various changes to `src/crypto` files for correctness ([\#2137](https://github.com/matrix-org/matrix-js-sdk/pull/2137)). Contributed by @ShadowJonathan.
+-   Update MSC3786 implementation: Check the `state_key` ([\#2429](https://github.com/matrix-org/matrix-js-sdk/pull/2429)).
+-   Timeline needs to refresh when we see a MSC2716 marker event ([\#2299](https://github.com/matrix-org/matrix-js-sdk/pull/2299)). Contributed by @MadLittleMods.
+-   Try to load keys from key backup when a message fails to decrypt ([\#2373](https://github.com/matrix-org/matrix-js-sdk/pull/2373)). Fixes vector-im/element-web#21026. Contributed by @duxovni.
 
 ## 🐛 Bug Fixes
- * Send call version `1` as a string ([\#2471](https://github.com/matrix-org/matrix-js-sdk/pull/2471)). Fixes vector-im/element-web#22629.
- * Fix issue with `getEventTimeline` returning undefined for thread roots in main timeline ([\#2454](https://github.com/matrix-org/matrix-js-sdk/pull/2454)). Fixes vector-im/element-web#22539.
- * Add missing `type` property on `IAuthData` ([\#2463](https://github.com/matrix-org/matrix-js-sdk/pull/2463)).
- * Clearly indicate that `lastReply` on a Thread can return falsy ([\#2462](https://github.com/matrix-org/matrix-js-sdk/pull/2462)).
- * Fix issues with getEventTimeline and thread roots ([\#2444](https://github.com/matrix-org/matrix-js-sdk/pull/2444)). Fixes vector-im/element-web#21613.
- * Live location sharing - monitor liveness of beacons yet to start ([\#2437](https://github.com/matrix-org/matrix-js-sdk/pull/2437)). Contributed by @kerryarchibald.
- * Refactor Relations to not be per-EventTimelineSet ([\#2412](https://github.com/matrix-org/matrix-js-sdk/pull/2412)). Fixes #2399 and vector-im/element-web#22298.
- * Add tests for sendEvent threadId handling ([\#2435](https://github.com/matrix-org/matrix-js-sdk/pull/2435)). Fixes vector-im/element-web#22433.
- * Make sure `encryptAndSendKeysToDevices` assumes devices are unique per-user. ([\#2136](https://github.com/matrix-org/matrix-js-sdk/pull/2136)). Fixes #2135. Contributed by @ShadowJonathan.
- * Don't bug the user while re-checking key backups after decryption failures ([\#2430](https://github.com/matrix-org/matrix-js-sdk/pull/2430)). Fixes vector-im/element-web#22416. Contributed by @duxovni.
-
-Changes in [18.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.1.0) (2022-06-07)
-==================================================================================================
+
+-   Send call version `1` as a string ([\#2471](https://github.com/matrix-org/matrix-js-sdk/pull/2471)). Fixes vector-im/element-web#22629.
+-   Fix issue with `getEventTimeline` returning undefined for thread roots in main timeline ([\#2454](https://github.com/matrix-org/matrix-js-sdk/pull/2454)). Fixes vector-im/element-web#22539.
+-   Add missing `type` property on `IAuthData` ([\#2463](https://github.com/matrix-org/matrix-js-sdk/pull/2463)).
+-   Clearly indicate that `lastReply` on a Thread can return falsy ([\#2462](https://github.com/matrix-org/matrix-js-sdk/pull/2462)).
+-   Fix issues with getEventTimeline and thread roots ([\#2444](https://github.com/matrix-org/matrix-js-sdk/pull/2444)). Fixes vector-im/element-web#21613.
+-   Live location sharing - monitor liveness of beacons yet to start ([\#2437](https://github.com/matrix-org/matrix-js-sdk/pull/2437)). Contributed by @kerryarchibald.
+-   Refactor Relations to not be per-EventTimelineSet ([\#2412](https://github.com/matrix-org/matrix-js-sdk/pull/2412)). Fixes #2399 and vector-im/element-web#22298.
+-   Add tests for sendEvent threadId handling ([\#2435](https://github.com/matrix-org/matrix-js-sdk/pull/2435)). Fixes vector-im/element-web#22433.
+-   Make sure `encryptAndSendKeysToDevices` assumes devices are unique per-user. ([\#2136](https://github.com/matrix-org/matrix-js-sdk/pull/2136)). Fixes #2135. Contributed by @ShadowJonathan.
+-   Don't bug the user while re-checking key backups after decryption failures ([\#2430](https://github.com/matrix-org/matrix-js-sdk/pull/2430)). Fixes vector-im/element-web#22416. Contributed by @duxovni.
+
+# Changes in [18.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.1.0) (2022-06-07)
 
 ## ✨ Features
- * Convert `getLocalAliases` to a stable API call ([\#2402](https://github.com/matrix-org/matrix-js-sdk/pull/2402)).
+
+-   Convert `getLocalAliases` to a stable API call ([\#2402](https://github.com/matrix-org/matrix-js-sdk/pull/2402)).
 
 ## 🐛 Bug Fixes
- * Fix request, crypto, and bs58 imports ([\#2414](https://github.com/matrix-org/matrix-js-sdk/pull/2414)). Fixes #2415.
- * Update relations after every decryption attempt ([\#2387](https://github.com/matrix-org/matrix-js-sdk/pull/2387)). Fixes vector-im/element-web#22258. Contributed by @weeman1337.
- * Fix degraded mode for the IDBStore and test it ([\#2400](https://github.com/matrix-org/matrix-js-sdk/pull/2400)). Fixes matrix-org/element-web-rageshakes#13170.
- * Don't cancel SAS verifications if `ready` is received after `start` ([\#2250](https://github.com/matrix-org/matrix-js-sdk/pull/2250)).
- * Prevent overlapping sync accumulator persists ([\#2392](https://github.com/matrix-org/matrix-js-sdk/pull/2392)). Fixes vector-im/element-web#21541.
- * Fix behaviour of isRelation with relation m.replace for state events ([\#2389](https://github.com/matrix-org/matrix-js-sdk/pull/2389)). Fixes vector-im/element-web#22280.
- * Fixes #2384 ([\#2385](https://github.com/matrix-org/matrix-js-sdk/pull/2385)). Fixes undefined/matrix-js-sdk#2384. Contributed by @schmop.
- * Ensure rooms are recalculated on re-invites ([\#2374](https://github.com/matrix-org/matrix-js-sdk/pull/2374)). Fixes vector-im/element-web#22106.
-
-Changes in [18.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.0.0) (2022-05-24)
-==================================================================================================
+
+-   Fix request, crypto, and bs58 imports ([\#2414](https://github.com/matrix-org/matrix-js-sdk/pull/2414)). Fixes #2415.
+-   Update relations after every decryption attempt ([\#2387](https://github.com/matrix-org/matrix-js-sdk/pull/2387)). Fixes vector-im/element-web#22258. Contributed by @weeman1337.
+-   Fix degraded mode for the IDBStore and test it ([\#2400](https://github.com/matrix-org/matrix-js-sdk/pull/2400)). Fixes matrix-org/element-web-rageshakes#13170.
+-   Don't cancel SAS verifications if `ready` is received after `start` ([\#2250](https://github.com/matrix-org/matrix-js-sdk/pull/2250)).
+-   Prevent overlapping sync accumulator persists ([\#2392](https://github.com/matrix-org/matrix-js-sdk/pull/2392)). Fixes vector-im/element-web#21541.
+-   Fix behaviour of isRelation with relation m.replace for state events ([\#2389](https://github.com/matrix-org/matrix-js-sdk/pull/2389)). Fixes vector-im/element-web#22280.
+-   Fixes #2384 ([\#2385](https://github.com/matrix-org/matrix-js-sdk/pull/2385)). Fixes undefined/matrix-js-sdk#2384. Contributed by @schmop.
+-   Ensure rooms are recalculated on re-invites ([\#2374](https://github.com/matrix-org/matrix-js-sdk/pull/2374)). Fixes vector-im/element-web#22106.
+
+# Changes in [18.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.0.0) (2022-05-24)
 
 ## 🚨 BREAKING CHANGES (to experimental methods)
- * Implement changes to MSC2285 (private read receipts) ([\#2221](https://github.com/matrix-org/matrix-js-sdk/pull/2221)).
+
+-   Implement changes to MSC2285 (private read receipts) ([\#2221](https://github.com/matrix-org/matrix-js-sdk/pull/2221)).
 
 ## ✨ Features
- * Add support for HTML renderings of room topics ([\#2272](https://github.com/matrix-org/matrix-js-sdk/pull/2272)).
- * Add stopClient parameter to MatrixClient::logout ([\#2367](https://github.com/matrix-org/matrix-js-sdk/pull/2367)).
- * registration: add function to re-request email token ([\#2357](https://github.com/matrix-org/matrix-js-sdk/pull/2357)).
- * Remove hacky custom status feature ([\#2350](https://github.com/matrix-org/matrix-js-sdk/pull/2350)).
+
+-   Add support for HTML renderings of room topics ([\#2272](https://github.com/matrix-org/matrix-js-sdk/pull/2272)).
+-   Add stopClient parameter to MatrixClient::logout ([\#2367](https://github.com/matrix-org/matrix-js-sdk/pull/2367)).
+-   registration: add function to re-request email token ([\#2357](https://github.com/matrix-org/matrix-js-sdk/pull/2357)).
+-   Remove hacky custom status feature ([\#2350](https://github.com/matrix-org/matrix-js-sdk/pull/2350)).
 
 ## 🐛 Bug Fixes
- * Remove default push rule override for MSC1930 ([\#2376](https://github.com/matrix-org/matrix-js-sdk/pull/2376)). Fixes vector-im/element-web#15439.
- * Tweak thread creation & event adding to fix bugs around relations ([\#2369](https://github.com/matrix-org/matrix-js-sdk/pull/2369)). Fixes vector-im/element-web#22162 and vector-im/element-web#22180.
- * Prune both clear & wire content on redaction ([\#2346](https://github.com/matrix-org/matrix-js-sdk/pull/2346)). Fixes vector-im/element-web#21929.
- * MSC3786: Add a default push rule to ignore `m.room.server_acl` events ([\#2333](https://github.com/matrix-org/matrix-js-sdk/pull/2333)). Fixes vector-im/element-web#20788.
 
-Changes in [17.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.2.0) (2022-05-10)
-==================================================================================================
+-   Remove default push rule override for MSC1930 ([\#2376](https://github.com/matrix-org/matrix-js-sdk/pull/2376)). Fixes vector-im/element-web#15439.
+-   Tweak thread creation & event adding to fix bugs around relations ([\#2369](https://github.com/matrix-org/matrix-js-sdk/pull/2369)). Fixes vector-im/element-web#22162 and vector-im/element-web#22180.
+-   Prune both clear & wire content on redaction ([\#2346](https://github.com/matrix-org/matrix-js-sdk/pull/2346)). Fixes vector-im/element-web#21929.
+-   MSC3786: Add a default push rule to ignore `m.room.server_acl` events ([\#2333](https://github.com/matrix-org/matrix-js-sdk/pull/2333)). Fixes vector-im/element-web#20788.
+
+# Changes in [17.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.2.0) (2022-05-10)
 
 ## ✨ Features
- * Live location sharing: handle encrypted messages in processBeaconEvents ([\#2327](https://github.com/matrix-org/matrix-js-sdk/pull/2327)).
+
+-   Live location sharing: handle encrypted messages in processBeaconEvents ([\#2327](https://github.com/matrix-org/matrix-js-sdk/pull/2327)).
 
 ## 🐛 Bug Fixes
- * Fix race conditions around threads ([\#2331](https://github.com/matrix-org/matrix-js-sdk/pull/2331)). Fixes vector-im/element-web#21627.
- * Ignore m.replace relations on state events, they're invalid ([\#2306](https://github.com/matrix-org/matrix-js-sdk/pull/2306)). Fixes vector-im/element-web#21851.
- * fix example in readme ([\#2315](https://github.com/matrix-org/matrix-js-sdk/pull/2315)).
- * Don't decrement the length count of a thread when root redacted ([\#2314](https://github.com/matrix-org/matrix-js-sdk/pull/2314)).
- * Prevent attempt to create thread with id "undefined" ([\#2308](https://github.com/matrix-org/matrix-js-sdk/pull/2308)).
- * Update threads handling for replies-to-thread-responses as per MSC update ([\#2305](https://github.com/matrix-org/matrix-js-sdk/pull/2305)). Fixes vector-im/element-web#19678.
 
-Changes in [17.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.1.0) (2022-04-26)
-==================================================================================================
+-   Fix race conditions around threads ([\#2331](https://github.com/matrix-org/matrix-js-sdk/pull/2331)). Fixes vector-im/element-web#21627.
+-   Ignore m.replace relations on state events, they're invalid ([\#2306](https://github.com/matrix-org/matrix-js-sdk/pull/2306)). Fixes vector-im/element-web#21851.
+-   fix example in readme ([\#2315](https://github.com/matrix-org/matrix-js-sdk/pull/2315)).
+-   Don't decrement the length count of a thread when root redacted ([\#2314](https://github.com/matrix-org/matrix-js-sdk/pull/2314)).
+-   Prevent attempt to create thread with id "undefined" ([\#2308](https://github.com/matrix-org/matrix-js-sdk/pull/2308)).
+-   Update threads handling for replies-to-thread-responses as per MSC update ([\#2305](https://github.com/matrix-org/matrix-js-sdk/pull/2305)). Fixes vector-im/element-web#19678.
+
+# Changes in [17.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.1.0) (2022-04-26)
 
 ## ✨ Features
- * Add MatrixClient.doesServerSupportLogoutDevices() for MSC2457 ([\#2297](https://github.com/matrix-org/matrix-js-sdk/pull/2297)).
- * Live location sharing - expose room liveBeaconIds ([\#2296](https://github.com/matrix-org/matrix-js-sdk/pull/2296)).
- * Support for MSC2457 logout_devices param for setPassword() ([\#2285](https://github.com/matrix-org/matrix-js-sdk/pull/2285)).
- * Stabilise token authenticated registration support ([\#2181](https://github.com/matrix-org/matrix-js-sdk/pull/2181)). Contributed by @govynnus.
- * Live location sharing - Aggregate beacon locations on beacons ([\#2268](https://github.com/matrix-org/matrix-js-sdk/pull/2268)).
+
+-   Add MatrixClient.doesServerSupportLogoutDevices() for MSC2457 ([\#2297](https://github.com/matrix-org/matrix-js-sdk/pull/2297)).
+-   Live location sharing - expose room liveBeaconIds ([\#2296](https://github.com/matrix-org/matrix-js-sdk/pull/2296)).
+-   Support for MSC2457 logout_devices param for setPassword() ([\#2285](https://github.com/matrix-org/matrix-js-sdk/pull/2285)).
+-   Stabilise token authenticated registration support ([\#2181](https://github.com/matrix-org/matrix-js-sdk/pull/2181)). Contributed by @govynnus.
+-   Live location sharing - Aggregate beacon locations on beacons ([\#2268](https://github.com/matrix-org/matrix-js-sdk/pull/2268)).
 
 ## 🐛 Bug Fixes
- * Prevent duplicated re-emitter setups in event-mapper ([\#2293](https://github.com/matrix-org/matrix-js-sdk/pull/2293)).
- * Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
 
-Changes in [17.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0) (2022-04-11)
-==================================================================================================
+-   Prevent duplicated re-emitter setups in event-mapper ([\#2293](https://github.com/matrix-org/matrix-js-sdk/pull/2293)).
+-   Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
+
+# Changes in [17.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0) (2022-04-11)
 
 ## 🚨 BREAKING CHANGES
- * Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
+
+-   Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
 
 ## ✨ Features
- * Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
- * Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
+
+-   Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
+-   Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
 
 ## 🐛 Bug Fixes
- * Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
- * Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
- * Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
 
-Changes in [16.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.2-rc.1) (2022-04-05)
-============================================================================================================
+-   Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
+-   Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
+-   Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
+
+# Changes in [16.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.2-rc.1) (2022-04-05)
 
 ## 🚨 BREAKING CHANGES
- * Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
+
+-   Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
 
 ## ✨ Features
- * Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
- * Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
+
+-   Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
+-   Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
 
 ## 🐛 Bug Fixes
- * Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
- * Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
- * Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
 
-Changes in [16.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1) (2022-03-28)
-==================================================================================================
+-   Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
+-   Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
+-   Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
+
+# Changes in [16.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1) (2022-03-28)
 
 ## ✨ Features
- * emit aggregate room beacon liveness ([\#2241](https://github.com/matrix-org/matrix-js-sdk/pull/2241)).
- * Live location sharing - create m.beacon_info events ([\#2238](https://github.com/matrix-org/matrix-js-sdk/pull/2238)).
- * Beacon event types from MSC3489 ([\#2230](https://github.com/matrix-org/matrix-js-sdk/pull/2230)).
+
+-   emit aggregate room beacon liveness ([\#2241](https://github.com/matrix-org/matrix-js-sdk/pull/2241)).
+-   Live location sharing - create m.beacon_info events ([\#2238](https://github.com/matrix-org/matrix-js-sdk/pull/2238)).
+-   Beacon event types from MSC3489 ([\#2230](https://github.com/matrix-org/matrix-js-sdk/pull/2230)).
 
 ## 🐛 Bug Fixes
- * Fix incorrect usage of unstable variant of `is_falling_back` ([\#2227](https://github.com/matrix-org/matrix-js-sdk/pull/2227)).
 
-Changes in [16.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1-rc.1) (2022-03-22)
-============================================================================================================
+-   Fix incorrect usage of unstable variant of `is_falling_back` ([\#2227](https://github.com/matrix-org/matrix-js-sdk/pull/2227)).
+
+# Changes in [16.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1-rc.1) (2022-03-22)
 
-Changes in [16.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0) (2022-03-15)
-==================================================================================================
+# Changes in [16.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0) (2022-03-15)
 
 ## 🚨 BREAKING CHANGES
- * Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
+
+-   Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
 
 ## ✨ Features
- * Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
- * add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
- * Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
- * Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
+
+-   Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
+-   add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
+-   Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
+-   Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
 
 ## 🐛 Bug Fixes
- * Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
- * Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
- * Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
- * Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
- * fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
- * Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
 
-Changes in [16.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0-rc.1) (2022-03-08)
-============================================================================================================
+-   Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
+-   Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
+-   Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
+-   Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
+-   fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
+-   Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
+
+# Changes in [16.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0-rc.1) (2022-03-08)
 
 ## 🚨 BREAKING CHANGES
- * Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
+
+-   Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
 
 ## ✨ Features
- * Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
- * add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
- * Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
- * Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
+
+-   Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
+-   add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
+-   Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
+-   Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
 
 ## 🐛 Bug Fixes
- * Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
- * Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
- * Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
- * Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
- * fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
- * Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
 
-Changes in [15.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0) (2022-02-28)
-==================================================================================================
+-   Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
+-   Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
+-   Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
+-   Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
+-   fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
+-   Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
+
+# Changes in [15.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0) (2022-02-28)
 
 ## ✨ Features
- * Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
- * Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
+
+-   Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
+-   Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
 
 ## 🐛 Bug Fixes
- * [Release] Fix bug with the /hierarchy API sending invalid requests ([\#2202](https://github.com/matrix-org/matrix-js-sdk/pull/2202)).
- * Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
- * Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
- * Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
- * Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
- * Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
- * Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
- * Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
- * Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
-
-Changes in [15.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0-rc.1) (2022-02-22)
-============================================================================================================
+
+-   [Release] Fix bug with the /hierarchy API sending invalid requests ([\#2202](https://github.com/matrix-org/matrix-js-sdk/pull/2202)).
+-   Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
+-   Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
+-   Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
+-   Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
+-   Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
+-   Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
+-   Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
+-   Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
+
+# Changes in [15.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0-rc.1) (2022-02-22)
 
 ## ✨ Features
- * Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
- * Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
+
+-   Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
+-   Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
 
 ## 🐛 Bug Fixes
- * Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
- * Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
- * Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
- * Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
- * Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
- * Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
- * Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
- * Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
-
-Changes in [15.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.2) (2022-02-17)
-==================================================================================================
+
+-   Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
+-   Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
+-   Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
+-   Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
+-   Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
+-   Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
+-   Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
+-   Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
+
+# Changes in [15.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.2) (2022-02-17)
 
 ## 🐛 Bug Fixes
- * Fix synthetic read receipt handling
 
-Changes in [15.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1) (2022-02-14)
-==================================================================================================
+-   Fix synthetic read receipt handling
+
+# Changes in [15.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1) (2022-02-14)
 
 ## 🐛 Bug Fixes
- * Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
- * Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
- * Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
- * Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
- * Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
- * Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
- * Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
 
-Changes in [15.5.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1-rc.1) (2022-02-08)
-============================================================================================================
+-   Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
+-   Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
+-   Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
+-   Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
+-   Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
+-   Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
+-   Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
+
+# Changes in [15.5.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1-rc.1) (2022-02-08)
 
 ## 🐛 Bug Fixes
- * Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
- * Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
- * Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
- * Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
- * Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
- * Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
- * Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
 
-Changes in [15.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0) (2022-01-31)
-==================================================================================================
+-   Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
+-   Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
+-   Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
+-   Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
+-   Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
+-   Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
+-   Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
+
+# Changes in [15.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0) (2022-01-31)
 
 ## ✨ Features
- * Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
- * Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
- * Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
+
+-   Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
+-   Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
+-   Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
 
 ## 🐛 Bug Fixes
- * Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
- * Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
 
-Changes in [15.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0-rc.1) (2022-01-26)
-============================================================================================================
+-   Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
+-   Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
+
+# Changes in [15.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0-rc.1) (2022-01-26)
 
 ## ✨ Features
- * Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
- * Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
- * Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
+
+-   Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
+-   Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
+-   Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
 
 ## 🐛 Bug Fixes
- * Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
- * Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
 
-Changes in [15.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0) (2022-01-17)
-==================================================================================================
+-   Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
+-   Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
+
+# Changes in [15.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0) (2022-01-17)
 
 ## ✨ Features
- * Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
- * Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
- * Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
+
+-   Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
+-   Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
+-   Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
 
 ## 🐛 Bug Fixes
- * Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
- * Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
- * Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
- * Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
- * Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
 
-Changes in [15.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0-rc.1) (2022-01-11)
-============================================================================================================
+-   Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
+-   Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
+-   Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
+-   Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
+-   Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
+
+# Changes in [15.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0-rc.1) (2022-01-11)
 
 ## ✨ Features
- * Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
- * Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
- * Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
+
+-   Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
+-   Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
+-   Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
 
 ## 🐛 Bug Fixes
- * Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
- * Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
- * Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
- * Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
- * Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
 
-Changes in [15.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0) (2021-12-20)
-==================================================================================================
+-   Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
+-   Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
+-   Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
+-   Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
+-   Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
+
+# Changes in [15.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0) (2021-12-20)
 
 ## ✨ Features
- * Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
- * Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
- * Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
+
+-   Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
+-   Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
+-   Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
 
 ## 🐛 Bug Fixes
- * Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
- * Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
- * Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
 
-Changes in [15.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0-rc.1) (2021-12-14)
-============================================================================================================
+-   Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
+-   Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
+-   Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
+
+# Changes in [15.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0-rc.1) (2021-12-14)
 
 ## ✨ Features
- * Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
- * Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
- * Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
+
+-   Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
+-   Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
+-   Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
 
 ## 🐛 Bug Fixes
- * Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
- * Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
- * Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
 
-Changes in [15.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.1) (2021-12-13)
-==================================================================================================
+-   Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
+-   Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
+-   Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
+
+# Changes in [15.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.1) (2021-12-13)
 
- * Security release with updated version of Olm to fix https://matrix.org/blog/2021/12/03/pre-disclosure-upcoming-security-release-of-libolm-and-matrix-js-sdk
+-   Security release with updated version of Olm to fix https://matrix.org/blog/2021/12/03/pre-disclosure-upcoming-security-release-of-libolm-and-matrix-js-sdk
 
-Changes in [15.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0) (2021-12-06)
-==================================================================================================
+# Changes in [15.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0) (2021-12-06)
 
 ## ✨ Features
- * Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
- * Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
- * Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
+
+-   Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
+-   Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
+-   Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
 
 ## 🐛 Bug Fixes
- * Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
 
-Changes in [15.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0-rc.1) (2021-11-30)
-============================================================================================================
+-   Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
+
+# Changes in [15.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0-rc.1) (2021-11-30)
 
 ## ✨ Features
- * Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
- * Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
- * Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
+
+-   Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
+-   Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
+-   Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
 
 ## 🐛 Bug Fixes
- * Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
 
-Changes in [15.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1) (2021-11-22)
-==================================================================================================
+-   Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
+
+# Changes in [15.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1) (2021-11-22)
 
 ## 🐛 Bug Fixes
- * Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
- * Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
 
-Changes in [15.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1-rc.1) (2021-11-17)
-============================================================================================================
+-   Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
+-   Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
+
+# Changes in [15.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1-rc.1) (2021-11-17)
 
 ## 🐛 Bug Fixes
- * Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
- * Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
 
-Changes in [15.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0) (2021-11-08)
-==================================================================================================
+-   Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
+-   Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
+
+# Changes in [15.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0) (2021-11-08)
 
 ## 🦖 Deprecations
- * Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
+
+-   Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
 
 ## ✨ Features
- * Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
- * Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
- * Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
- * Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
+
+-   Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
+-   Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
+-   Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
+-   Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
 
 ## 🐛 Bug Fixes
- * Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
- * Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
 
-Changes in [15.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0-rc.1) (2021-11-02)
-============================================================================================================
+-   Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
+-   Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
+
+# Changes in [15.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0-rc.1) (2021-11-02)
 
 ## 🦖 Deprecations
- * Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
+
+-   Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
 
 ## ✨ Features
- * Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
- * Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
- * Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
- * Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
+
+-   Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
+-   Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
+-   Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
+-   Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
 
 ## 🐛 Bug Fixes
- * Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
- * Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
 
-Changes in [15.0.0](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0) (2021-10-25)
-===================================================================================================
+-   Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
+-   Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
+
+# Changes in [15.0.0](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0) (2021-10-25)
 
 ## 🚨 BREAKING CHANGES
- * Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
- * Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
- * Try to answer a call without video if we can't access the camera  ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
+
+-   Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
+-   Try to answer a call without video if we can't access the camera ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
 
 ## 🐛 Bug Fixes
- * Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
 
-Changes in [15.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0-rc.1) (2021-10-19)
-=============================================================================================================
+-   Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
+
+# Changes in [15.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0-rc.1) (2021-10-19)
 
 ## 🚨 BREAKING CHANGES
- * Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
- * Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
- * Try to answer a call without video if we can't access the camera  ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
+
+-   Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
+-   Try to answer a call without video if we can't access the camera ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
 
 ## 🐛 Bug Fixes
- * Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
 
-Changes in [14.0.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.1) (2021-10-12)
-===================================================================================================
+-   Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
+
+# Changes in [14.0.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.1) (2021-10-12)
 
 ## 🚨 BREAKING CHANGES
- * Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
- * Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
- * Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
+-   Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
- * Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
- * Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
- * Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
 
+-   Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
+-   Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
+-   Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
 
-Changes in [14.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.0-rc.1) (2021-10-04)
-=============================================================================================================
+# Changes in [14.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.0-rc.1) (2021-10-04)
 
 ## 🚨 BREAKING CHANGES
- * Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
- * Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
- * Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
+-   Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
- * Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
- * Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
- * Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
 
-Changes in [13.0.0](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0) (2021-09-27)
-===================================================================================================
+-   Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
+-   Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
+-   Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
+
+# Changes in [13.0.0](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0) (2021-09-27)
 
 ## ✨ Features
- * Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
- * Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
- * Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
+
+-   Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
+-   Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
+-   Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
 
 ## 🐛 Bug Fixes
- * Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
 
-Changes in [13.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0-rc.1) (2021-09-21)
-=============================================================================================================
+-   Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
+
+# Changes in [13.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0-rc.1) (2021-09-21)
 
 ## ✨ Features
- * Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
- * Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
- * Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
+
+-   Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
+-   Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
+-   Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
 
 ## 🐛 Bug Fixes
- * Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
 
-Changes in [12.5.0](https://github.com/vector-im/element-desktop/releases/tag/v12.5.0) (2021-09-14)
-===================================================================================================
+-   Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
+
+# Changes in [12.5.0](https://github.com/vector-im/element-desktop/releases/tag/v12.5.0) (2021-09-14)
 
 ## ✨ Features
- * [Release] Exclude opt-in Element performance metrics from encryption ([\#1901](https://github.com/matrix-org/matrix-js-sdk/pull/1901)).
- * Give `MatrixCall` the capability to emit `LengthChanged` events ([\#1873](https://github.com/matrix-org/matrix-js-sdk/pull/1873)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Improve browser example ([\#1875](https://github.com/matrix-org/matrix-js-sdk/pull/1875)). Contributed by [psrpinto](https://github.com/psrpinto).
- * Give `CallFeed` the capability to emit on volume changes ([\#1865](https://github.com/matrix-org/matrix-js-sdk/pull/1865)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   [Release] Exclude opt-in Element performance metrics from encryption ([\#1901](https://github.com/matrix-org/matrix-js-sdk/pull/1901)).
+-   Give `MatrixCall` the capability to emit `LengthChanged` events ([\#1873](https://github.com/matrix-org/matrix-js-sdk/pull/1873)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Improve browser example ([\#1875](https://github.com/matrix-org/matrix-js-sdk/pull/1875)). Contributed by [psrpinto](https://github.com/psrpinto).
+-   Give `CallFeed` the capability to emit on volume changes ([\#1865](https://github.com/matrix-org/matrix-js-sdk/pull/1865)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
- * Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).
 
-Changes in [12.4.1](https://github.com/vector-im/element-desktop/releases/tag/v12.4.1) (2021-09-13)
-===================================================================================================
+-   Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).
+
+# Changes in [12.4.1](https://github.com/vector-im/element-desktop/releases/tag/v12.4.1) (2021-09-13)
 
 ## 🔒 SECURITY FIXES
- * Fix a security issue with message key sharing. See https://matrix.org/blog/2021/09/13/vulnerability-disclosure-key-sharing
-   for details.
 
-Changes in [12.4.0](https://github.com/vector-im/element-desktop/releases/tag/v12.4.0) (2021-08-31)
-===================================================================================================
+-   Fix a security issue with message key sharing. See https://matrix.org/blog/2021/09/13/vulnerability-disclosure-key-sharing
+    for details.
+
+# Changes in [12.4.0](https://github.com/vector-im/element-desktop/releases/tag/v12.4.0) (2021-08-31)
 
 ## 🦖 Deprecations
- * Deprecate groups APIs. Groups are no longer supported, only Synapse has support. They are being replaced by Spaces which build off of Rooms and are far more flexible. ([\#1792](https://github.com/matrix-org/matrix-js-sdk/pull/1792)).
+
+-   Deprecate groups APIs. Groups are no longer supported, only Synapse has support. They are being replaced by Spaces which build off of Rooms and are far more flexible. ([\#1792](https://github.com/matrix-org/matrix-js-sdk/pull/1792)).
 
 ## ✨ Features
- * Add method for including extra fields when uploading to a tree space ([\#1850](https://github.com/matrix-org/matrix-js-sdk/pull/1850)).
+
+-   Add method for including extra fields when uploading to a tree space ([\#1850](https://github.com/matrix-org/matrix-js-sdk/pull/1850)).
 
 ## 🐛 Bug Fixes
- * Fix broken voice calls, no ringing and broken call notifications ([\#1858](https://github.com/matrix-org/matrix-js-sdk/pull/1858)). Fixes vector-im/element-web#18578 vector-im/element-web#18538 and vector-im/element-web#18578. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Revert "Fix glare related regressions" ([\#1857](https://github.com/matrix-org/matrix-js-sdk/pull/1857)).
- * Fix glare related regressions ([\#1851](https://github.com/matrix-org/matrix-js-sdk/pull/1851)). Fixes vector-im/element-web#18538 and vector-im/element-web#18538. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Fix temporary call messages being handled without call  ([\#1834](https://github.com/matrix-org/matrix-js-sdk/pull/1834)). Contributed by [Palid](https://github.com/Palid).
- * Fix conditional on returning file tree spaces ([\#1841](https://github.com/matrix-org/matrix-js-sdk/pull/1841)).
 
-Changes in [12.3.1](https://github.com/vector-im/element-desktop/releases/tag/v12.3.1) (2021-08-17)
-===================================================================================================
+-   Fix broken voice calls, no ringing and broken call notifications ([\#1858](https://github.com/matrix-org/matrix-js-sdk/pull/1858)). Fixes vector-im/element-web#18578 vector-im/element-web#18538 and vector-im/element-web#18578. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Revert "Fix glare related regressions" ([\#1857](https://github.com/matrix-org/matrix-js-sdk/pull/1857)).
+-   Fix glare related regressions ([\#1851](https://github.com/matrix-org/matrix-js-sdk/pull/1851)). Fixes vector-im/element-web#18538 and vector-im/element-web#18538. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Fix temporary call messages being handled without call ([\#1834](https://github.com/matrix-org/matrix-js-sdk/pull/1834)). Contributed by [Palid](https://github.com/Palid).
+-   Fix conditional on returning file tree spaces ([\#1841](https://github.com/matrix-org/matrix-js-sdk/pull/1841)).
+
+# Changes in [12.3.1](https://github.com/vector-im/element-desktop/releases/tag/v12.3.1) (2021-08-17)
 
 ## 🐛 Bug Fixes
- * Fix multiple VoIP regressions ([\#1860](https://github.com/matrix-org/matrix-js-sdk/pull/1860)).
 
-Changes in [12.3.0](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0) (2021-08-16)
-===================================================================================================
+-   Fix multiple VoIP regressions ([\#1860](https://github.com/matrix-org/matrix-js-sdk/pull/1860)).
+
+# Changes in [12.3.0](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0) (2021-08-16)
 
 ## ✨ Features
- * Support for MSC3291: Muting in VoIP calls ([\#1812](https://github.com/matrix-org/matrix-js-sdk/pull/1812)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Support for screen-sharing using multi-stream VoIP (MSC3077) ([\#1685](https://github.com/matrix-org/matrix-js-sdk/pull/1685)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Handle DTMF support ([\#1813](https://github.com/matrix-org/matrix-js-sdk/pull/1813)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+
+-   Support for MSC3291: Muting in VoIP calls ([\#1812](https://github.com/matrix-org/matrix-js-sdk/pull/1812)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Support for screen-sharing using multi-stream VoIP (MSC3077) ([\#1685](https://github.com/matrix-org/matrix-js-sdk/pull/1685)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Handle DTMF support ([\#1813](https://github.com/matrix-org/matrix-js-sdk/pull/1813)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
- * [Release] Fix glare related regressions ([\#1854](https://github.com/matrix-org/matrix-js-sdk/pull/1854)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Fix the types in shipped package ([\#1842](https://github.com/matrix-org/matrix-js-sdk/pull/1842)). Fixes vector-im/element-web#18503 and vector-im/element-web#18503.
- * Fix error on turning off screensharing ([\#1833](https://github.com/matrix-org/matrix-js-sdk/pull/1833)). Fixes vector-im/element-web#18449. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Fix blank profile in join events ([\#1837](https://github.com/matrix-org/matrix-js-sdk/pull/1837)). Fixes vector-im/element-web#18321.
- * fix TURN by fixing regression preventing multiple ICE candidates from sending. ([\#1838](https://github.com/matrix-org/matrix-js-sdk/pull/1838)).
- * Send `user_hangup` reason if the opponent supports it ([\#1820](https://github.com/matrix-org/matrix-js-sdk/pull/1820)). Fixes vector-im/element-web#18219. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
- * Apply hidden char check to rawDisplayName too ([\#1816](https://github.com/matrix-org/matrix-js-sdk/pull/1816)).
- * Only clear bit 63 when we create the IV ([\#1819](https://github.com/matrix-org/matrix-js-sdk/pull/1819)).
-
-Changes in [12.2.0](https://github.com/vector-im/element-desktop/releases/tag/v12.2.0) (2021-08-02)
-===================================================================================================
+
+-   [Release] Fix glare related regressions ([\#1854](https://github.com/matrix-org/matrix-js-sdk/pull/1854)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Fix the types in shipped package ([\#1842](https://github.com/matrix-org/matrix-js-sdk/pull/1842)). Fixes vector-im/element-web#18503 and vector-im/element-web#18503.
+-   Fix error on turning off screensharing ([\#1833](https://github.com/matrix-org/matrix-js-sdk/pull/1833)). Fixes vector-im/element-web#18449. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Fix blank profile in join events ([\#1837](https://github.com/matrix-org/matrix-js-sdk/pull/1837)). Fixes vector-im/element-web#18321.
+-   fix TURN by fixing regression preventing multiple ICE candidates from sending. ([\#1838](https://github.com/matrix-org/matrix-js-sdk/pull/1838)).
+-   Send `user_hangup` reason if the opponent supports it ([\#1820](https://github.com/matrix-org/matrix-js-sdk/pull/1820)). Fixes vector-im/element-web#18219. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+-   Apply hidden char check to rawDisplayName too ([\#1816](https://github.com/matrix-org/matrix-js-sdk/pull/1816)).
+-   Only clear bit 63 when we create the IV ([\#1819](https://github.com/matrix-org/matrix-js-sdk/pull/1819)).
+
+# Changes in [12.2.0](https://github.com/vector-im/element-desktop/releases/tag/v12.2.0) (2021-08-02)
 
 ## ✨ Features
- * Improve calculateRoomName performances by using Intl.Collator
-   [\#1801](https://github.com/matrix-org/matrix-js-sdk/pull/1801)
- * Switch callEventHandler from listening on `event` to `Room.timeline`
-   [\#1789](https://github.com/matrix-org/matrix-js-sdk/pull/1789)
- * Expose MatrixEvent's internal clearEvent as a function
-   [\#1784](https://github.com/matrix-org/matrix-js-sdk/pull/1784)
+
+-   Improve calculateRoomName performances by using Intl.Collator
+    [\#1801](https://github.com/matrix-org/matrix-js-sdk/pull/1801)
+-   Switch callEventHandler from listening on `event` to `Room.timeline`
+    [\#1789](https://github.com/matrix-org/matrix-js-sdk/pull/1789)
+-   Expose MatrixEvent's internal clearEvent as a function
+    [\#1784](https://github.com/matrix-org/matrix-js-sdk/pull/1784)
 
 ## 🐛 Bug Fixes
- * Clean up Event.clearEvent handling to fix a bug where malformed events with falsey content wouldn't be considered decrypted
-   [\#1807](https://github.com/matrix-org/matrix-js-sdk/pull/1807)
- * Standardise spelling and casing of homeserver, identity server, and integration manager
-   [\#1782](https://github.com/matrix-org/matrix-js-sdk/pull/1782)
 
-Changes in [12.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0) (2021-07-19)
-==================================================================================================
+-   Clean up Event.clearEvent handling to fix a bug where malformed events with falsey content wouldn't be considered decrypted
+    [\#1807](https://github.com/matrix-org/matrix-js-sdk/pull/1807)
+-   Standardise spelling and casing of homeserver, identity server, and integration manager
+    [\#1782](https://github.com/matrix-org/matrix-js-sdk/pull/1782)
+
+# Changes in [12.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0) (2021-07-19)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.1.0-rc.1...v12.1.0)
 
- * No changes from rc.1
+-   No changes from rc.1
+
+# Changes in [12.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0-rc.1) (2021-07-14)
 
-Changes in [12.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0-rc.1) (2021-07-14)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.1...v12.1.0-rc.1)
 
- * Add VS Code to gitignore
-   [\#1783](https://github.com/matrix-org/matrix-js-sdk/pull/1783)
- * Make `Crypto::inRoomVerificationRequests` public
-   [\#1781](https://github.com/matrix-org/matrix-js-sdk/pull/1781)
- * Call `setEventMetadata()` for filtered `timelineSet`s
-   [\#1765](https://github.com/matrix-org/matrix-js-sdk/pull/1765)
- * Symmetric backup
-   [\#1775](https://github.com/matrix-org/matrix-js-sdk/pull/1775)
- * Attempt to fix megolm key not being in SSSS
-   [\#1776](https://github.com/matrix-org/matrix-js-sdk/pull/1776)
- * Convert SecretStorage to TypeScript
-   [\#1774](https://github.com/matrix-org/matrix-js-sdk/pull/1774)
- * Strip hash from urls being previewed to de-duplicate
-   [\#1721](https://github.com/matrix-org/matrix-js-sdk/pull/1721)
- * Do not generate a lockfile when running in CI
-   [\#1773](https://github.com/matrix-org/matrix-js-sdk/pull/1773)
- * Tidy up secret requesting code
-   [\#1766](https://github.com/matrix-org/matrix-js-sdk/pull/1766)
- * Convert Sync and SyncAccumulator to Typescript
-   [\#1763](https://github.com/matrix-org/matrix-js-sdk/pull/1763)
- * Convert EventTimeline, EventTimelineSet and TimelineWindow to TS
-   [\#1762](https://github.com/matrix-org/matrix-js-sdk/pull/1762)
- * Comply with new member-delimiter-style rule
-   [\#1764](https://github.com/matrix-org/matrix-js-sdk/pull/1764)
- * Do not honor string power levels
-   [\#1754](https://github.com/matrix-org/matrix-js-sdk/pull/1754)
- * Typescriptify some crypto stuffs
-   [\#1508](https://github.com/matrix-org/matrix-js-sdk/pull/1508)
- * Make filterId read/write and optional
-   [\#1760](https://github.com/matrix-org/matrix-js-sdk/pull/1760)
-
-Changes in [12.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1) (2021-07-05)
-==================================================================================================
+-   Add VS Code to gitignore
+    [\#1783](https://github.com/matrix-org/matrix-js-sdk/pull/1783)
+-   Make `Crypto::inRoomVerificationRequests` public
+    [\#1781](https://github.com/matrix-org/matrix-js-sdk/pull/1781)
+-   Call `setEventMetadata()` for filtered `timelineSet`s
+    [\#1765](https://github.com/matrix-org/matrix-js-sdk/pull/1765)
+-   Symmetric backup
+    [\#1775](https://github.com/matrix-org/matrix-js-sdk/pull/1775)
+-   Attempt to fix megolm key not being in SSSS
+    [\#1776](https://github.com/matrix-org/matrix-js-sdk/pull/1776)
+-   Convert SecretStorage to TypeScript
+    [\#1774](https://github.com/matrix-org/matrix-js-sdk/pull/1774)
+-   Strip hash from urls being previewed to de-duplicate
+    [\#1721](https://github.com/matrix-org/matrix-js-sdk/pull/1721)
+-   Do not generate a lockfile when running in CI
+    [\#1773](https://github.com/matrix-org/matrix-js-sdk/pull/1773)
+-   Tidy up secret requesting code
+    [\#1766](https://github.com/matrix-org/matrix-js-sdk/pull/1766)
+-   Convert Sync and SyncAccumulator to Typescript
+    [\#1763](https://github.com/matrix-org/matrix-js-sdk/pull/1763)
+-   Convert EventTimeline, EventTimelineSet and TimelineWindow to TS
+    [\#1762](https://github.com/matrix-org/matrix-js-sdk/pull/1762)
+-   Comply with new member-delimiter-style rule
+    [\#1764](https://github.com/matrix-org/matrix-js-sdk/pull/1764)
+-   Do not honor string power levels
+    [\#1754](https://github.com/matrix-org/matrix-js-sdk/pull/1754)
+-   Typescriptify some crypto stuffs
+    [\#1508](https://github.com/matrix-org/matrix-js-sdk/pull/1508)
+-   Make filterId read/write and optional
+    [\#1760](https://github.com/matrix-org/matrix-js-sdk/pull/1760)
+
+# Changes in [12.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1) (2021-07-05)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.1-rc.1...v12.0.1)
 
- * No changes from rc.1
+-   No changes from rc.1
+
+# Changes in [12.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1-rc.1) (2021-06-29)
 
-Changes in [12.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1-rc.1) (2021-06-29)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.0...v12.0.1-rc.1)
 
- * Fix broken /messages filtering due to internal field changes in
-   FilterComponent
-   [\#1759](https://github.com/matrix-org/matrix-js-sdk/pull/1759)
- * Convert crypto index to TS
-   [\#1749](https://github.com/matrix-org/matrix-js-sdk/pull/1749)
- * Fix typescript return types for membership update events
-   [\#1739](https://github.com/matrix-org/matrix-js-sdk/pull/1739)
- * Fix types of MatrixEvent sender & target
-   [\#1753](https://github.com/matrix-org/matrix-js-sdk/pull/1753)
- * Add keysharing on invites to File Tree Spaces
-   [\#1744](https://github.com/matrix-org/matrix-js-sdk/pull/1744)
- * Convert Room and RoomState to Typescript
-   [\#1746](https://github.com/matrix-org/matrix-js-sdk/pull/1746)
- * Improve type of IContent msgtype
-   [\#1752](https://github.com/matrix-org/matrix-js-sdk/pull/1752)
- * Add PR template
-   [\#1747](https://github.com/matrix-org/matrix-js-sdk/pull/1747)
- * Add functions to assist in immutability of Event objects
-   [\#1738](https://github.com/matrix-org/matrix-js-sdk/pull/1738)
- * Convert Event Context to TS
-   [\#1742](https://github.com/matrix-org/matrix-js-sdk/pull/1742)
- * Bump lodash from 4.17.20 to 4.17.21
-   [\#1743](https://github.com/matrix-org/matrix-js-sdk/pull/1743)
- * Add invite retries to file trees
-   [\#1740](https://github.com/matrix-org/matrix-js-sdk/pull/1740)
- * Convert IndexedDBStore to TS
-   [\#1741](https://github.com/matrix-org/matrix-js-sdk/pull/1741)
- * Convert additional files to typescript
-   [\#1736](https://github.com/matrix-org/matrix-js-sdk/pull/1736)
-
-Changes in [12.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0) (2021-06-21)
-==================================================================================================
+-   Fix broken /messages filtering due to internal field changes in
+    FilterComponent
+    [\#1759](https://github.com/matrix-org/matrix-js-sdk/pull/1759)
+-   Convert crypto index to TS
+    [\#1749](https://github.com/matrix-org/matrix-js-sdk/pull/1749)
+-   Fix typescript return types for membership update events
+    [\#1739](https://github.com/matrix-org/matrix-js-sdk/pull/1739)
+-   Fix types of MatrixEvent sender & target
+    [\#1753](https://github.com/matrix-org/matrix-js-sdk/pull/1753)
+-   Add keysharing on invites to File Tree Spaces
+    [\#1744](https://github.com/matrix-org/matrix-js-sdk/pull/1744)
+-   Convert Room and RoomState to Typescript
+    [\#1746](https://github.com/matrix-org/matrix-js-sdk/pull/1746)
+-   Improve type of IContent msgtype
+    [\#1752](https://github.com/matrix-org/matrix-js-sdk/pull/1752)
+-   Add PR template
+    [\#1747](https://github.com/matrix-org/matrix-js-sdk/pull/1747)
+-   Add functions to assist in immutability of Event objects
+    [\#1738](https://github.com/matrix-org/matrix-js-sdk/pull/1738)
+-   Convert Event Context to TS
+    [\#1742](https://github.com/matrix-org/matrix-js-sdk/pull/1742)
+-   Bump lodash from 4.17.20 to 4.17.21
+    [\#1743](https://github.com/matrix-org/matrix-js-sdk/pull/1743)
+-   Add invite retries to file trees
+    [\#1740](https://github.com/matrix-org/matrix-js-sdk/pull/1740)
+-   Convert IndexedDBStore to TS
+    [\#1741](https://github.com/matrix-org/matrix-js-sdk/pull/1741)
+-   Convert additional files to typescript
+    [\#1736](https://github.com/matrix-org/matrix-js-sdk/pull/1736)
+
+# Changes in [12.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0) (2021-06-21)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.0-rc.1...v12.0.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [12.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0-rc.1) (2021-06-15)
 
-Changes in [12.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0-rc.1) (2021-06-15)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.2.0...v12.0.0-rc.1)
 
- * Rework how disambiguation is handled
-   [\#1730](https://github.com/matrix-org/matrix-js-sdk/pull/1730)
- * Fix baseToString for n=0 edge case to match inverse stringToBase
-   [\#1735](https://github.com/matrix-org/matrix-js-sdk/pull/1735)
- * Move various types from the react-sdk to the js-sdk
-   [\#1734](https://github.com/matrix-org/matrix-js-sdk/pull/1734)
- * Unstable implementation of MSC3089: File Trees
-   [\#1732](https://github.com/matrix-org/matrix-js-sdk/pull/1732)
- * Add MSC3230 event type to enum
-   [\#1729](https://github.com/matrix-org/matrix-js-sdk/pull/1729)
- * Add separate reason code for transferred calls
-   [\#1731](https://github.com/matrix-org/matrix-js-sdk/pull/1731)
- * Use sendonly for call hold
-   [\#1728](https://github.com/matrix-org/matrix-js-sdk/pull/1728)
- * Stop breeding sync listeners
-   [\#1727](https://github.com/matrix-org/matrix-js-sdk/pull/1727)
- * Fix semicolons in TS files
-   [\#1724](https://github.com/matrix-org/matrix-js-sdk/pull/1724)
- * [BREAKING] Convert MatrixClient to TypeScript
-   [\#1718](https://github.com/matrix-org/matrix-js-sdk/pull/1718)
- * Factor out backup management to a separate module
-   [\#1697](https://github.com/matrix-org/matrix-js-sdk/pull/1697)
- * Ignore power_levels events with unknown state_key on room-state
-   initialization
-   [\#1723](https://github.com/matrix-org/matrix-js-sdk/pull/1723)
- * Revert 1579 (Fix extra negotiate message in Firefox)
-   [\#1725](https://github.com/matrix-org/matrix-js-sdk/pull/1725)
-
-Changes in [11.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0) (2021-06-07)
-==================================================================================================
+-   Rework how disambiguation is handled
+    [\#1730](https://github.com/matrix-org/matrix-js-sdk/pull/1730)
+-   Fix baseToString for n=0 edge case to match inverse stringToBase
+    [\#1735](https://github.com/matrix-org/matrix-js-sdk/pull/1735)
+-   Move various types from the react-sdk to the js-sdk
+    [\#1734](https://github.com/matrix-org/matrix-js-sdk/pull/1734)
+-   Unstable implementation of MSC3089: File Trees
+    [\#1732](https://github.com/matrix-org/matrix-js-sdk/pull/1732)
+-   Add MSC3230 event type to enum
+    [\#1729](https://github.com/matrix-org/matrix-js-sdk/pull/1729)
+-   Add separate reason code for transferred calls
+    [\#1731](https://github.com/matrix-org/matrix-js-sdk/pull/1731)
+-   Use sendonly for call hold
+    [\#1728](https://github.com/matrix-org/matrix-js-sdk/pull/1728)
+-   Stop breeding sync listeners
+    [\#1727](https://github.com/matrix-org/matrix-js-sdk/pull/1727)
+-   Fix semicolons in TS files
+    [\#1724](https://github.com/matrix-org/matrix-js-sdk/pull/1724)
+-   [BREAKING] Convert MatrixClient to TypeScript
+    [\#1718](https://github.com/matrix-org/matrix-js-sdk/pull/1718)
+-   Factor out backup management to a separate module
+    [\#1697](https://github.com/matrix-org/matrix-js-sdk/pull/1697)
+-   Ignore power_levels events with unknown state_key on room-state
+    initialization
+    [\#1723](https://github.com/matrix-org/matrix-js-sdk/pull/1723)
+-   Revert 1579 (Fix extra negotiate message in Firefox)
+    [\#1725](https://github.com/matrix-org/matrix-js-sdk/pull/1725)
+
+# Changes in [11.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0) (2021-06-07)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.2.0-rc.1...v11.2.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [11.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0-rc.1) (2021-06-01)
 
-Changes in [11.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0-rc.1) (2021-06-01)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.1.0...v11.2.0-rc.1)
 
- * Switch to stable endpoint/fields for MSC2858
-   [\#1720](https://github.com/matrix-org/matrix-js-sdk/pull/1720)
- * Bump ws from 7.4.2 to 7.4.6
-   [\#1715](https://github.com/matrix-org/matrix-js-sdk/pull/1715)
- * Make consistent call event type checks
-   [\#1712](https://github.com/matrix-org/matrix-js-sdk/pull/1712)
- * Apply new Babel linting config
-   [\#1714](https://github.com/matrix-org/matrix-js-sdk/pull/1714)
- * Bump browserslist from 4.16.1 to 4.16.6
-   [\#1709](https://github.com/matrix-org/matrix-js-sdk/pull/1709)
- * Add user_busy call hangup reason
-   [\#1713](https://github.com/matrix-org/matrix-js-sdk/pull/1713)
- * 👕 New linting rules
-   [\#1688](https://github.com/matrix-org/matrix-js-sdk/pull/1688)
- * Emit relations created when target event added later
-   [\#1710](https://github.com/matrix-org/matrix-js-sdk/pull/1710)
- * Bump libolm version and update package name.
-   [\#1705](https://github.com/matrix-org/matrix-js-sdk/pull/1705)
- * Fix uploadContent not rejecting promise when http status code >= 400
-   [\#1703](https://github.com/matrix-org/matrix-js-sdk/pull/1703)
- * Reduce noise in tests
-   [\#1702](https://github.com/matrix-org/matrix-js-sdk/pull/1702)
- * Only log once if a Room lacks an m.room.create event
-   [\#1700](https://github.com/matrix-org/matrix-js-sdk/pull/1700)
- * Cache normalized room name
-   [\#1701](https://github.com/matrix-org/matrix-js-sdk/pull/1701)
- * Change call event handlers to adapt to undecrypted events
-   [\#1698](https://github.com/matrix-org/matrix-js-sdk/pull/1698)
-
-Changes in [11.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0) (2021-05-24)
-==================================================================================================
+-   Switch to stable endpoint/fields for MSC2858
+    [\#1720](https://github.com/matrix-org/matrix-js-sdk/pull/1720)
+-   Bump ws from 7.4.2 to 7.4.6
+    [\#1715](https://github.com/matrix-org/matrix-js-sdk/pull/1715)
+-   Make consistent call event type checks
+    [\#1712](https://github.com/matrix-org/matrix-js-sdk/pull/1712)
+-   Apply new Babel linting config
+    [\#1714](https://github.com/matrix-org/matrix-js-sdk/pull/1714)
+-   Bump browserslist from 4.16.1 to 4.16.6
+    [\#1709](https://github.com/matrix-org/matrix-js-sdk/pull/1709)
+-   Add user_busy call hangup reason
+    [\#1713](https://github.com/matrix-org/matrix-js-sdk/pull/1713)
+-   👕 New linting rules
+    [\#1688](https://github.com/matrix-org/matrix-js-sdk/pull/1688)
+-   Emit relations created when target event added later
+    [\#1710](https://github.com/matrix-org/matrix-js-sdk/pull/1710)
+-   Bump libolm version and update package name.
+    [\#1705](https://github.com/matrix-org/matrix-js-sdk/pull/1705)
+-   Fix uploadContent not rejecting promise when http status code >= 400
+    [\#1703](https://github.com/matrix-org/matrix-js-sdk/pull/1703)
+-   Reduce noise in tests
+    [\#1702](https://github.com/matrix-org/matrix-js-sdk/pull/1702)
+-   Only log once if a Room lacks an m.room.create event
+    [\#1700](https://github.com/matrix-org/matrix-js-sdk/pull/1700)
+-   Cache normalized room name
+    [\#1701](https://github.com/matrix-org/matrix-js-sdk/pull/1701)
+-   Change call event handlers to adapt to undecrypted events
+    [\#1698](https://github.com/matrix-org/matrix-js-sdk/pull/1698)
+
+# Changes in [11.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0) (2021-05-24)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.1.0-rc.1...v11.1.0)
 
- * [Release] Bump libolm version and update package name
-   [\#1707](https://github.com/matrix-org/matrix-js-sdk/pull/1707)
- * [Release] Change call event handlers to adapt to undecrypted events
-   [\#1699](https://github.com/matrix-org/matrix-js-sdk/pull/1699)
+-   [Release] Bump libolm version and update package name
+    [\#1707](https://github.com/matrix-org/matrix-js-sdk/pull/1707)
+-   [Release] Change call event handlers to adapt to undecrypted events
+    [\#1699](https://github.com/matrix-org/matrix-js-sdk/pull/1699)
+
+# Changes in [11.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0-rc.1) (2021-05-19)
 
-Changes in [11.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0-rc.1) (2021-05-19)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.0.0...v11.1.0-rc.1)
 
- * Fix regressed glare
-   [\#1690](https://github.com/matrix-org/matrix-js-sdk/pull/1690)
- * Add m.reaction to EventType enum
-   [\#1692](https://github.com/matrix-org/matrix-js-sdk/pull/1692)
- * Prioritise and reduce the amount of events decrypted on application startup
-   [\#1684](https://github.com/matrix-org/matrix-js-sdk/pull/1684)
- * Decrypt relations before applying them to target event
-   [\#1696](https://github.com/matrix-org/matrix-js-sdk/pull/1696)
- * Guard against duplicates in `Relations` model
-
-Changes in [11.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0) (2021-05-17)
-==================================================================================================
+-   Fix regressed glare
+    [\#1690](https://github.com/matrix-org/matrix-js-sdk/pull/1690)
+-   Add m.reaction to EventType enum
+    [\#1692](https://github.com/matrix-org/matrix-js-sdk/pull/1692)
+-   Prioritise and reduce the amount of events decrypted on application startup
+    [\#1684](https://github.com/matrix-org/matrix-js-sdk/pull/1684)
+-   Decrypt relations before applying them to target event
+    [\#1696](https://github.com/matrix-org/matrix-js-sdk/pull/1696)
+-   Guard against duplicates in `Relations` model
+
+# Changes in [11.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0) (2021-05-17)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.0.0-rc.1...v11.0.0)
 
- * [Release] Fix regressed glare
-   [\#1695](https://github.com/matrix-org/matrix-js-sdk/pull/1695)
+-   [Release] Fix regressed glare
+    [\#1695](https://github.com/matrix-org/matrix-js-sdk/pull/1695)
+
+# Changes in [11.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0-rc.1) (2021-05-11)
 
-Changes in [11.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0-rc.1) (2021-05-11)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.1.0...v11.0.0-rc.1)
 
-BREAKING CHANGES
----
+## BREAKING CHANGES
+
+-   `MatrixCall` and related APIs have been redesigned to support multiple streams
+    (see [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660) for more details)
 
- * `MatrixCall` and related APIs have been redesigned to support multiple streams
-   (see [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660) for more details)
+## All changes
 
-All changes
----
+-   Switch from MSC1772 unstable prefixes to stable
+    [\#1679](https://github.com/matrix-org/matrix-js-sdk/pull/1679)
+-   Update the VoIP example to work with the new changes
+    [\#1680](https://github.com/matrix-org/matrix-js-sdk/pull/1680)
+-   Bump hosted-git-info from 2.8.8 to 2.8.9
+    [\#1687](https://github.com/matrix-org/matrix-js-sdk/pull/1687)
+-   Support for multiple streams (not MSC3077)
+    [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660)
+-   Tweak missing m.room.create errors to describe their source
+    [\#1683](https://github.com/matrix-org/matrix-js-sdk/pull/1683)
 
- * Switch from MSC1772 unstable prefixes to stable
-   [\#1679](https://github.com/matrix-org/matrix-js-sdk/pull/1679)
- * Update the VoIP example to work with the new changes
-   [\#1680](https://github.com/matrix-org/matrix-js-sdk/pull/1680)
- * Bump hosted-git-info from 2.8.8 to 2.8.9
-   [\#1687](https://github.com/matrix-org/matrix-js-sdk/pull/1687)
- * Support for multiple streams (not MSC3077)
-   [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660)
- * Tweak missing m.room.create errors to describe their source
-   [\#1683](https://github.com/matrix-org/matrix-js-sdk/pull/1683)
+# Changes in [10.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0) (2021-05-10)
 
-Changes in [10.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0) (2021-05-10)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.1.0-rc.1...v10.1.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [10.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0-rc.1) (2021-05-04)
 
-Changes in [10.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0-rc.1) (2021-05-04)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.0.0...v10.1.0-rc.1)
 
- * Revert "Raise logging dramatically to chase pending event errors"
-   [\#1681](https://github.com/matrix-org/matrix-js-sdk/pull/1681)
- * Add test coverage collection script
-   [\#1677](https://github.com/matrix-org/matrix-js-sdk/pull/1677)
- * Raise logging dramatically to chase pending event errors
-   [\#1678](https://github.com/matrix-org/matrix-js-sdk/pull/1678)
- * Support MSC3086 asserted identity
-   [\#1674](https://github.com/matrix-org/matrix-js-sdk/pull/1674)
- * Fix `/search` with no results field work again
-   [\#1670](https://github.com/matrix-org/matrix-js-sdk/pull/1670)
- * Add room.getMembers method
-   [\#1672](https://github.com/matrix-org/matrix-js-sdk/pull/1672)
-
-Changes in [10.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0) (2021-04-26)
-==================================================================================================
+-   Revert "Raise logging dramatically to chase pending event errors"
+    [\#1681](https://github.com/matrix-org/matrix-js-sdk/pull/1681)
+-   Add test coverage collection script
+    [\#1677](https://github.com/matrix-org/matrix-js-sdk/pull/1677)
+-   Raise logging dramatically to chase pending event errors
+    [\#1678](https://github.com/matrix-org/matrix-js-sdk/pull/1678)
+-   Support MSC3086 asserted identity
+    [\#1674](https://github.com/matrix-org/matrix-js-sdk/pull/1674)
+-   Fix `/search` with no results field work again
+    [\#1670](https://github.com/matrix-org/matrix-js-sdk/pull/1670)
+-   Add room.getMembers method
+    [\#1672](https://github.com/matrix-org/matrix-js-sdk/pull/1672)
+
+# Changes in [10.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0) (2021-04-26)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.0.0-rc.1...v10.0.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [10.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0-rc.1) (2021-04-21)
 
-Changes in [10.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0-rc.1) (2021-04-21)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.11.0...v10.0.0-rc.1)
 
-BREAKING CHANGES
----
-
- * The `RoomState.members` event is now only emitted when the room member's power level or the room's normal power level actually changes
-
-All changes
----
-
- * Restrict event emit for room members that had power levels changed
-   [\#1675](https://github.com/matrix-org/matrix-js-sdk/pull/1675)
- * Fix sync with misconfigured push rules
-   [\#1669](https://github.com/matrix-org/matrix-js-sdk/pull/1669)
- * Add missing await
-   [\#1665](https://github.com/matrix-org/matrix-js-sdk/pull/1665)
- * Migrate to `eslint-plugin-matrix-org`
-   [\#1642](https://github.com/matrix-org/matrix-js-sdk/pull/1642)
- * Add missing event type enum for key verification done
-   [\#1664](https://github.com/matrix-org/matrix-js-sdk/pull/1664)
- * Fix timeline jumpiness by setting correct txnId
-   [\#1663](https://github.com/matrix-org/matrix-js-sdk/pull/1663)
- * Fix calling addEventListener if it does not exist
-   [\#1661](https://github.com/matrix-org/matrix-js-sdk/pull/1661)
- * Persist unsent messages for subsequent sessions
-   [\#1655](https://github.com/matrix-org/matrix-js-sdk/pull/1655)
-
-Changes in [9.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0) (2021-04-12)
-==================================================================================================
+## BREAKING CHANGES
+
+-   The `RoomState.members` event is now only emitted when the room member's power level or the room's normal power level actually changes
+
+## All changes
+
+-   Restrict event emit for room members that had power levels changed
+    [\#1675](https://github.com/matrix-org/matrix-js-sdk/pull/1675)
+-   Fix sync with misconfigured push rules
+    [\#1669](https://github.com/matrix-org/matrix-js-sdk/pull/1669)
+-   Add missing await
+    [\#1665](https://github.com/matrix-org/matrix-js-sdk/pull/1665)
+-   Migrate to `eslint-plugin-matrix-org`
+    [\#1642](https://github.com/matrix-org/matrix-js-sdk/pull/1642)
+-   Add missing event type enum for key verification done
+    [\#1664](https://github.com/matrix-org/matrix-js-sdk/pull/1664)
+-   Fix timeline jumpiness by setting correct txnId
+    [\#1663](https://github.com/matrix-org/matrix-js-sdk/pull/1663)
+-   Fix calling addEventListener if it does not exist
+    [\#1661](https://github.com/matrix-org/matrix-js-sdk/pull/1661)
+-   Persist unsent messages for subsequent sessions
+    [\#1655](https://github.com/matrix-org/matrix-js-sdk/pull/1655)
+
+# Changes in [9.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0) (2021-04-12)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.11.0-rc.1...v9.11.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0-rc.1) (2021-04-07)
 
-Changes in [9.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0-rc.1) (2021-04-07)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.10.0...v9.11.0-rc.1)
 
- * Only try to cache private keys we know exist
-   [\#1657](https://github.com/matrix-org/matrix-js-sdk/pull/1657)
- * Properly terminate screen-share calls if NoUserMedia
-   [\#1654](https://github.com/matrix-org/matrix-js-sdk/pull/1654)
- * Attended transfer
-   [\#1652](https://github.com/matrix-org/matrix-js-sdk/pull/1652)
- * Remove catch handlers in private key retrieval
-   [\#1653](https://github.com/matrix-org/matrix-js-sdk/pull/1653)
- * Fixed the media fail error on caller's side
-   [\#1651](https://github.com/matrix-org/matrix-js-sdk/pull/1651)
- * Add function to share megolm keys for historical messages, take 2
-   [\#1640](https://github.com/matrix-org/matrix-js-sdk/pull/1640)
- * Cache cross-signing private keys if needed on bootstrap
-   [\#1649](https://github.com/matrix-org/matrix-js-sdk/pull/1649)
-
-Changes in [9.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0) (2021-03-29)
-==================================================================================================
+-   Only try to cache private keys we know exist
+    [\#1657](https://github.com/matrix-org/matrix-js-sdk/pull/1657)
+-   Properly terminate screen-share calls if NoUserMedia
+    [\#1654](https://github.com/matrix-org/matrix-js-sdk/pull/1654)
+-   Attended transfer
+    [\#1652](https://github.com/matrix-org/matrix-js-sdk/pull/1652)
+-   Remove catch handlers in private key retrieval
+    [\#1653](https://github.com/matrix-org/matrix-js-sdk/pull/1653)
+-   Fixed the media fail error on caller's side
+    [\#1651](https://github.com/matrix-org/matrix-js-sdk/pull/1651)
+-   Add function to share megolm keys for historical messages, take 2
+    [\#1640](https://github.com/matrix-org/matrix-js-sdk/pull/1640)
+-   Cache cross-signing private keys if needed on bootstrap
+    [\#1649](https://github.com/matrix-org/matrix-js-sdk/pull/1649)
+
+# Changes in [9.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0) (2021-03-29)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.10.0-rc.1...v9.10.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0-rc.1) (2021-03-25)
 
-Changes in [9.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0-rc.1) (2021-03-25)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.9.0...v9.10.0-rc.1)
 
- * Don't send m.call.hangup if m.call.invite wasn't sent either
-   [\#1647](https://github.com/matrix-org/matrix-js-sdk/pull/1647)
- * docs: registerGuest()
-   [\#1641](https://github.com/matrix-org/matrix-js-sdk/pull/1641)
- * Download device keys in chunks of 250
-   [\#1639](https://github.com/matrix-org/matrix-js-sdk/pull/1639)
- * More VoIP connectivity fixes
-   [\#1646](https://github.com/matrix-org/matrix-js-sdk/pull/1646)
- * Make selectDesktopCapturerSource param optional
-   [\#1644](https://github.com/matrix-org/matrix-js-sdk/pull/1644)
- * Expose APIs needed for reworked cross-signing login flow
-   [\#1632](https://github.com/matrix-org/matrix-js-sdk/pull/1632)
-
-Changes in [9.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0) (2021-03-15)
-================================================================================================
+-   Don't send m.call.hangup if m.call.invite wasn't sent either
+    [\#1647](https://github.com/matrix-org/matrix-js-sdk/pull/1647)
+-   docs: registerGuest()
+    [\#1641](https://github.com/matrix-org/matrix-js-sdk/pull/1641)
+-   Download device keys in chunks of 250
+    [\#1639](https://github.com/matrix-org/matrix-js-sdk/pull/1639)
+-   More VoIP connectivity fixes
+    [\#1646](https://github.com/matrix-org/matrix-js-sdk/pull/1646)
+-   Make selectDesktopCapturerSource param optional
+    [\#1644](https://github.com/matrix-org/matrix-js-sdk/pull/1644)
+-   Expose APIs needed for reworked cross-signing login flow
+    [\#1632](https://github.com/matrix-org/matrix-js-sdk/pull/1632)
+
+# Changes in [9.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0) (2021-03-15)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.9.0-rc.1...v9.9.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0-rc.1) (2021-03-10)
 
-Changes in [9.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0-rc.1) (2021-03-10)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.8.0...v9.9.0-rc.1)
 
- * Remove detailed Olm session logging
-   [\#1638](https://github.com/matrix-org/matrix-js-sdk/pull/1638)
- * Add space summary suggested only param
-   [\#1637](https://github.com/matrix-org/matrix-js-sdk/pull/1637)
- * Check TURN servers periodically, and at start of calls
-   [\#1634](https://github.com/matrix-org/matrix-js-sdk/pull/1634)
- * Support sending invite reasons
-   [\#1624](https://github.com/matrix-org/matrix-js-sdk/pull/1624)
- * Bump elliptic from 6.5.3 to 6.5.4
-   [\#1636](https://github.com/matrix-org/matrix-js-sdk/pull/1636)
- * Add a function to get a room's MXC URI
-   [\#1635](https://github.com/matrix-org/matrix-js-sdk/pull/1635)
- * Stop streams if the call has ended
-   [\#1633](https://github.com/matrix-org/matrix-js-sdk/pull/1633)
- * Remove export keyword from global.d.ts
-   [\#1631](https://github.com/matrix-org/matrix-js-sdk/pull/1631)
- * Fix IndexedDB store creation example
-   [\#1445](https://github.com/matrix-org/matrix-js-sdk/pull/1445)
- * An attempt to  cleanup how constraints are handled in calls
-   [\#1613](https://github.com/matrix-org/matrix-js-sdk/pull/1613)
- * Extract display name patterns to constants
-   [\#1628](https://github.com/matrix-org/matrix-js-sdk/pull/1628)
- * Bump pug-code-gen from 2.0.2 to 2.0.3
-   [\#1630](https://github.com/matrix-org/matrix-js-sdk/pull/1630)
- * Avoid deadlocks when ensuring Olm sessions for devices
-   [\#1627](https://github.com/matrix-org/matrix-js-sdk/pull/1627)
- * Filter out edits from other senders in history
-   [\#1626](https://github.com/matrix-org/matrix-js-sdk/pull/1626)
- * Fix ContentHelpers export
-   [\#1618](https://github.com/matrix-org/matrix-js-sdk/pull/1618)
- * Add logging to in progress Olm sessions
-   [\#1621](https://github.com/matrix-org/matrix-js-sdk/pull/1621)
- * Don't ignore ICE candidates received before offer/answer
-   [\#1623](https://github.com/matrix-org/matrix-js-sdk/pull/1623)
- * Better handling of send failures on VoIP events
-   [\#1622](https://github.com/matrix-org/matrix-js-sdk/pull/1622)
- * Log when turn creds expire
-   [\#1620](https://github.com/matrix-org/matrix-js-sdk/pull/1620)
- * Initial Spaces [MSC1772] support
-   [\#1563](https://github.com/matrix-org/matrix-js-sdk/pull/1563)
- * Add logging to crypto store transactions
-   [\#1617](https://github.com/matrix-org/matrix-js-sdk/pull/1617)
- * Room helper for getting type and checking if it is a space room
-   [\#1610](https://github.com/matrix-org/matrix-js-sdk/pull/1610)
-
-Changes in [9.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0) (2021-03-01)
-================================================================================================
+-   Remove detailed Olm session logging
+    [\#1638](https://github.com/matrix-org/matrix-js-sdk/pull/1638)
+-   Add space summary suggested only param
+    [\#1637](https://github.com/matrix-org/matrix-js-sdk/pull/1637)
+-   Check TURN servers periodically, and at start of calls
+    [\#1634](https://github.com/matrix-org/matrix-js-sdk/pull/1634)
+-   Support sending invite reasons
+    [\#1624](https://github.com/matrix-org/matrix-js-sdk/pull/1624)
+-   Bump elliptic from 6.5.3 to 6.5.4
+    [\#1636](https://github.com/matrix-org/matrix-js-sdk/pull/1636)
+-   Add a function to get a room's MXC URI
+    [\#1635](https://github.com/matrix-org/matrix-js-sdk/pull/1635)
+-   Stop streams if the call has ended
+    [\#1633](https://github.com/matrix-org/matrix-js-sdk/pull/1633)
+-   Remove export keyword from global.d.ts
+    [\#1631](https://github.com/matrix-org/matrix-js-sdk/pull/1631)
+-   Fix IndexedDB store creation example
+    [\#1445](https://github.com/matrix-org/matrix-js-sdk/pull/1445)
+-   An attempt to cleanup how constraints are handled in calls
+    [\#1613](https://github.com/matrix-org/matrix-js-sdk/pull/1613)
+-   Extract display name patterns to constants
+    [\#1628](https://github.com/matrix-org/matrix-js-sdk/pull/1628)
+-   Bump pug-code-gen from 2.0.2 to 2.0.3
+    [\#1630](https://github.com/matrix-org/matrix-js-sdk/pull/1630)
+-   Avoid deadlocks when ensuring Olm sessions for devices
+    [\#1627](https://github.com/matrix-org/matrix-js-sdk/pull/1627)
+-   Filter out edits from other senders in history
+    [\#1626](https://github.com/matrix-org/matrix-js-sdk/pull/1626)
+-   Fix ContentHelpers export
+    [\#1618](https://github.com/matrix-org/matrix-js-sdk/pull/1618)
+-   Add logging to in progress Olm sessions
+    [\#1621](https://github.com/matrix-org/matrix-js-sdk/pull/1621)
+-   Don't ignore ICE candidates received before offer/answer
+    [\#1623](https://github.com/matrix-org/matrix-js-sdk/pull/1623)
+-   Better handling of send failures on VoIP events
+    [\#1622](https://github.com/matrix-org/matrix-js-sdk/pull/1622)
+-   Log when turn creds expire
+    [\#1620](https://github.com/matrix-org/matrix-js-sdk/pull/1620)
+-   Initial Spaces [MSC1772] support
+    [\#1563](https://github.com/matrix-org/matrix-js-sdk/pull/1563)
+-   Add logging to crypto store transactions
+    [\#1617](https://github.com/matrix-org/matrix-js-sdk/pull/1617)
+-   Room helper for getting type and checking if it is a space room
+    [\#1610](https://github.com/matrix-org/matrix-js-sdk/pull/1610)
+
+# Changes in [9.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0) (2021-03-01)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.8.0-rc.1...v9.8.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.8.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0-rc.1) (2021-02-24)
 
-Changes in [9.8.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0-rc.1) (2021-02-24)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.7.0...v9.8.0-rc.1)
 
- * Optimise prefixed logger
-   [\#1615](https://github.com/matrix-org/matrix-js-sdk/pull/1615)
- * Add debug logs to encryption prep, take 3
-   [\#1614](https://github.com/matrix-org/matrix-js-sdk/pull/1614)
- * Add functions for upper & lowercase random strings
-   [\#1612](https://github.com/matrix-org/matrix-js-sdk/pull/1612)
- * Room helpers for invite permissions and join rules
-   [\#1609](https://github.com/matrix-org/matrix-js-sdk/pull/1609)
- * Fixed wording in "Adding video track with id" log
-   [\#1606](https://github.com/matrix-org/matrix-js-sdk/pull/1606)
- * Add more debug logs to encryption prep
-   [\#1605](https://github.com/matrix-org/matrix-js-sdk/pull/1605)
- * Add option to set ice candidate pool size
-   [\#1604](https://github.com/matrix-org/matrix-js-sdk/pull/1604)
- * Cancel call if no source was selected
-   [\#1601](https://github.com/matrix-org/matrix-js-sdk/pull/1601)
-
-Changes in [9.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0) (2021-02-16)
-================================================================================================
+-   Optimise prefixed logger
+    [\#1615](https://github.com/matrix-org/matrix-js-sdk/pull/1615)
+-   Add debug logs to encryption prep, take 3
+    [\#1614](https://github.com/matrix-org/matrix-js-sdk/pull/1614)
+-   Add functions for upper & lowercase random strings
+    [\#1612](https://github.com/matrix-org/matrix-js-sdk/pull/1612)
+-   Room helpers for invite permissions and join rules
+    [\#1609](https://github.com/matrix-org/matrix-js-sdk/pull/1609)
+-   Fixed wording in "Adding video track with id" log
+    [\#1606](https://github.com/matrix-org/matrix-js-sdk/pull/1606)
+-   Add more debug logs to encryption prep
+    [\#1605](https://github.com/matrix-org/matrix-js-sdk/pull/1605)
+-   Add option to set ice candidate pool size
+    [\#1604](https://github.com/matrix-org/matrix-js-sdk/pull/1604)
+-   Cancel call if no source was selected
+    [\#1601](https://github.com/matrix-org/matrix-js-sdk/pull/1601)
+
+# Changes in [9.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0) (2021-02-16)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.7.0-rc.1...v9.7.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.7.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0-rc.1) (2021-02-10)
 
-Changes in [9.7.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0-rc.1) (2021-02-10)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.6.0...v9.7.0-rc.1)
 
- * Handle undefined peerconn
-   [\#1600](https://github.com/matrix-org/matrix-js-sdk/pull/1600)
- * ReEmitter: Don't throw if no error handler is attached
-   [\#1599](https://github.com/matrix-org/matrix-js-sdk/pull/1599)
- * Convert ReEmitter to TS
-   [\#1598](https://github.com/matrix-org/matrix-js-sdk/pull/1598)
- * Fix typo in main readme
-   [\#1597](https://github.com/matrix-org/matrix-js-sdk/pull/1597)
- * Remove rogue plus character
-   [\#1596](https://github.com/matrix-org/matrix-js-sdk/pull/1596)
- * Fix call ID NaN
-   [\#1595](https://github.com/matrix-org/matrix-js-sdk/pull/1595)
- * Fix Electron type merging
-   [\#1594](https://github.com/matrix-org/matrix-js-sdk/pull/1594)
- * Fix browser screen share
-   [\#1593](https://github.com/matrix-org/matrix-js-sdk/pull/1593)
- * Fix desktop Matrix screen sharing
-   [\#1570](https://github.com/matrix-org/matrix-js-sdk/pull/1570)
- * Guard against confused server retry times
-   [\#1591](https://github.com/matrix-org/matrix-js-sdk/pull/1591)
- * Decrypt redaction events
-   [\#1589](https://github.com/matrix-org/matrix-js-sdk/pull/1589)
- * Fix edge cases with peeking where a room is re-peeked
-   [\#1587](https://github.com/matrix-org/matrix-js-sdk/pull/1587)
-
-Changes in [9.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0) (2021-02-03)
-================================================================================================
+-   Handle undefined peerconn
+    [\#1600](https://github.com/matrix-org/matrix-js-sdk/pull/1600)
+-   ReEmitter: Don't throw if no error handler is attached
+    [\#1599](https://github.com/matrix-org/matrix-js-sdk/pull/1599)
+-   Convert ReEmitter to TS
+    [\#1598](https://github.com/matrix-org/matrix-js-sdk/pull/1598)
+-   Fix typo in main readme
+    [\#1597](https://github.com/matrix-org/matrix-js-sdk/pull/1597)
+-   Remove rogue plus character
+    [\#1596](https://github.com/matrix-org/matrix-js-sdk/pull/1596)
+-   Fix call ID NaN
+    [\#1595](https://github.com/matrix-org/matrix-js-sdk/pull/1595)
+-   Fix Electron type merging
+    [\#1594](https://github.com/matrix-org/matrix-js-sdk/pull/1594)
+-   Fix browser screen share
+    [\#1593](https://github.com/matrix-org/matrix-js-sdk/pull/1593)
+-   Fix desktop Matrix screen sharing
+    [\#1570](https://github.com/matrix-org/matrix-js-sdk/pull/1570)
+-   Guard against confused server retry times
+    [\#1591](https://github.com/matrix-org/matrix-js-sdk/pull/1591)
+-   Decrypt redaction events
+    [\#1589](https://github.com/matrix-org/matrix-js-sdk/pull/1589)
+-   Fix edge cases with peeking where a room is re-peeked
+    [\#1587](https://github.com/matrix-org/matrix-js-sdk/pull/1587)
+
+# Changes in [9.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0) (2021-02-03)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.6.0-rc.1...v9.6.0)
 
- * [Release] Fix edge cases with peeking where a room is re-peeked
-   [\#1588](https://github.com/matrix-org/matrix-js-sdk/pull/1588)
+-   [Release] Fix edge cases with peeking where a room is re-peeked
+    [\#1588](https://github.com/matrix-org/matrix-js-sdk/pull/1588)
+
+# Changes in [9.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0-rc.1) (2021-01-29)
 
-Changes in [9.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0-rc.1) (2021-01-29)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.1...v9.6.0-rc.1)
 
- * Add support for getting call stats
-   [\#1584](https://github.com/matrix-org/matrix-js-sdk/pull/1584)
- * Fix compatibility with v0 calls
-   [\#1583](https://github.com/matrix-org/matrix-js-sdk/pull/1583)
- * Upgrade deps 2021-01
-   [\#1582](https://github.com/matrix-org/matrix-js-sdk/pull/1582)
- * Log the call ID when logging that we've received VoIP events
-   [\#1581](https://github.com/matrix-org/matrix-js-sdk/pull/1581)
- * Fix extra negotiate message in Firefox
-   [\#1579](https://github.com/matrix-org/matrix-js-sdk/pull/1579)
- * Add debug logs to encryption prep
-   [\#1580](https://github.com/matrix-org/matrix-js-sdk/pull/1580)
- * Expose getPresence endpoint
-   [\#1578](https://github.com/matrix-org/matrix-js-sdk/pull/1578)
- * Queue keys for backup even if backup isn't enabled yet
-   [\#1577](https://github.com/matrix-org/matrix-js-sdk/pull/1577)
- * Stop retrying TURN access when forbidden
-   [\#1576](https://github.com/matrix-org/matrix-js-sdk/pull/1576)
- * Add DTMF sending support
-   [\#1573](https://github.com/matrix-org/matrix-js-sdk/pull/1573)
-
-Changes in [9.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.1) (2021-01-26)
-================================================================================================
+-   Add support for getting call stats
+    [\#1584](https://github.com/matrix-org/matrix-js-sdk/pull/1584)
+-   Fix compatibility with v0 calls
+    [\#1583](https://github.com/matrix-org/matrix-js-sdk/pull/1583)
+-   Upgrade deps 2021-01
+    [\#1582](https://github.com/matrix-org/matrix-js-sdk/pull/1582)
+-   Log the call ID when logging that we've received VoIP events
+    [\#1581](https://github.com/matrix-org/matrix-js-sdk/pull/1581)
+-   Fix extra negotiate message in Firefox
+    [\#1579](https://github.com/matrix-org/matrix-js-sdk/pull/1579)
+-   Add debug logs to encryption prep
+    [\#1580](https://github.com/matrix-org/matrix-js-sdk/pull/1580)
+-   Expose getPresence endpoint
+    [\#1578](https://github.com/matrix-org/matrix-js-sdk/pull/1578)
+-   Queue keys for backup even if backup isn't enabled yet
+    [\#1577](https://github.com/matrix-org/matrix-js-sdk/pull/1577)
+-   Stop retrying TURN access when forbidden
+    [\#1576](https://github.com/matrix-org/matrix-js-sdk/pull/1576)
+-   Add DTMF sending support
+    [\#1573](https://github.com/matrix-org/matrix-js-sdk/pull/1573)
+
+# Changes in [9.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.1) (2021-01-26)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.0...v9.5.1)
 
- * [Release] Fix compatibility with v0 calls
-   [\#1585](https://github.com/matrix-org/matrix-js-sdk/pull/1585)
+-   [Release] Fix compatibility with v0 calls
+    [\#1585](https://github.com/matrix-org/matrix-js-sdk/pull/1585)
+
+# Changes in [9.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0) (2021-01-18)
 
-Changes in [9.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0) (2021-01-18)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.0-rc.1...v9.5.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0-rc.1) (2021-01-13)
 
-Changes in [9.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0-rc.1) (2021-01-13)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.1...v9.5.0-rc.1)
 
- * Don't log if no WebRTC
-   [\#1574](https://github.com/matrix-org/matrix-js-sdk/pull/1574)
- * Add _unstable_getSharedRooms
-   [\#1417](https://github.com/matrix-org/matrix-js-sdk/pull/1417)
- * Bump node-notifier from 8.0.0 to 8.0.1
-   [\#1568](https://github.com/matrix-org/matrix-js-sdk/pull/1568)
- * Ignore party ID if opponent is v0
-   [\#1567](https://github.com/matrix-org/matrix-js-sdk/pull/1567)
- * Basic call transfer initiation support
-   [\#1566](https://github.com/matrix-org/matrix-js-sdk/pull/1566)
- * Room version 6 is now a thing
-   [\#1572](https://github.com/matrix-org/matrix-js-sdk/pull/1572)
- * Store keys with same index but better trust level
-   [\#1571](https://github.com/matrix-org/matrix-js-sdk/pull/1571)
- * Use TypeScript source for development, swap to build during release
-   [\#1561](https://github.com/matrix-org/matrix-js-sdk/pull/1561)
- * Revert "Ignore party ID if opponent is v0"
-   [\#1565](https://github.com/matrix-org/matrix-js-sdk/pull/1565)
- * Basic call transfer initiation support
-   [\#1558](https://github.com/matrix-org/matrix-js-sdk/pull/1558)
- * Ignore party ID if opponent is v0
-   [\#1559](https://github.com/matrix-org/matrix-js-sdk/pull/1559)
- * Honour a call reject event from another of our own devices
-   [\#1562](https://github.com/matrix-org/matrix-js-sdk/pull/1562)
-
-Changes in [9.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.1) (2020-12-21)
-================================================================================================
+-   Don't log if no WebRTC
+    [\#1574](https://github.com/matrix-org/matrix-js-sdk/pull/1574)
+-   Add \_unstable_getSharedRooms
+    [\#1417](https://github.com/matrix-org/matrix-js-sdk/pull/1417)
+-   Bump node-notifier from 8.0.0 to 8.0.1
+    [\#1568](https://github.com/matrix-org/matrix-js-sdk/pull/1568)
+-   Ignore party ID if opponent is v0
+    [\#1567](https://github.com/matrix-org/matrix-js-sdk/pull/1567)
+-   Basic call transfer initiation support
+    [\#1566](https://github.com/matrix-org/matrix-js-sdk/pull/1566)
+-   Room version 6 is now a thing
+    [\#1572](https://github.com/matrix-org/matrix-js-sdk/pull/1572)
+-   Store keys with same index but better trust level
+    [\#1571](https://github.com/matrix-org/matrix-js-sdk/pull/1571)
+-   Use TypeScript source for development, swap to build during release
+    [\#1561](https://github.com/matrix-org/matrix-js-sdk/pull/1561)
+-   Revert "Ignore party ID if opponent is v0"
+    [\#1565](https://github.com/matrix-org/matrix-js-sdk/pull/1565)
+-   Basic call transfer initiation support
+    [\#1558](https://github.com/matrix-org/matrix-js-sdk/pull/1558)
+-   Ignore party ID if opponent is v0
+    [\#1559](https://github.com/matrix-org/matrix-js-sdk/pull/1559)
+-   Honour a call reject event from another of our own devices
+    [\#1562](https://github.com/matrix-org/matrix-js-sdk/pull/1562)
+
+# Changes in [9.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.1) (2020-12-21)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0...v9.4.1)
 
- * Further script tweaks to get all layers building again
+-   Further script tweaks to get all layers building again
+
+# Changes in [9.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0) (2020-12-21)
 
-Changes in [9.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0) (2020-12-21)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0-rc.2...v9.4.0)
 
- * Revert `postinstall` script change, causes issues for other layers
+-   Revert `postinstall` script change, causes issues for other layers
+
+# Changes in [9.4.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.2) (2020-12-16)
 
-Changes in [9.4.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.2) (2020-12-16)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0-rc.1...v9.4.0-rc.2)
 
- * Remove `postinstall` script which also runs as a dependency
-   [\#1560](https://github.com/matrix-org/matrix-js-sdk/pull/1560)
+-   Remove `postinstall` script which also runs as a dependency
+    [\#1560](https://github.com/matrix-org/matrix-js-sdk/pull/1560)
+
+# Changes in [9.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.1) (2020-12-16)
 
-Changes in [9.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.1) (2020-12-16)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.3.0...v9.4.0-rc.1)
 
- * Fixes to support line 1 / 2
-   [\#1553](https://github.com/matrix-org/matrix-js-sdk/pull/1553)
- * Add API for listening to remote hold status, advertise VoIP V1
-   [\#1549](https://github.com/matrix-org/matrix-js-sdk/pull/1549)
- * A hangup from another client is still valid
-   [\#1555](https://github.com/matrix-org/matrix-js-sdk/pull/1555)
- * Remove temporary build step for tests
-   [\#1554](https://github.com/matrix-org/matrix-js-sdk/pull/1554)
- * Move browser build steps to prepublish only
-   [\#1552](https://github.com/matrix-org/matrix-js-sdk/pull/1552)
- * Extend getSsoLoginUrl for MSC2858
-   [\#1541](https://github.com/matrix-org/matrix-js-sdk/pull/1541)
-
-Changes in [9.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0) (2020-12-07)
-================================================================================================
+-   Fixes to support line 1 / 2
+    [\#1553](https://github.com/matrix-org/matrix-js-sdk/pull/1553)
+-   Add API for listening to remote hold status, advertise VoIP V1
+    [\#1549](https://github.com/matrix-org/matrix-js-sdk/pull/1549)
+-   A hangup from another client is still valid
+    [\#1555](https://github.com/matrix-org/matrix-js-sdk/pull/1555)
+-   Remove temporary build step for tests
+    [\#1554](https://github.com/matrix-org/matrix-js-sdk/pull/1554)
+-   Move browser build steps to prepublish only
+    [\#1552](https://github.com/matrix-org/matrix-js-sdk/pull/1552)
+-   Extend getSsoLoginUrl for MSC2858
+    [\#1541](https://github.com/matrix-org/matrix-js-sdk/pull/1541)
+
+# Changes in [9.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0) (2020-12-07)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.3.0-rc.1...v9.3.0)
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0-rc.1) (2020-12-02)
 
-Changes in [9.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0-rc.1) (2020-12-02)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.2.0...v9.3.0-rc.1)
 
- * Export CallError
-   [\#1551](https://github.com/matrix-org/matrix-js-sdk/pull/1551)
- * Upgrade dependencies
-   [\#1550](https://github.com/matrix-org/matrix-js-sdk/pull/1550)
- * Don't log error when environment does not support WebRTC
-   [\#1547](https://github.com/matrix-org/matrix-js-sdk/pull/1547)
- * Fix dehydration method name
-   [\#1544](https://github.com/matrix-org/matrix-js-sdk/pull/1544)
-
-Changes in [9.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0) (2020-11-23)
-================================================================================================
+-   Export CallError
+    [\#1551](https://github.com/matrix-org/matrix-js-sdk/pull/1551)
+-   Upgrade dependencies
+    [\#1550](https://github.com/matrix-org/matrix-js-sdk/pull/1550)
+-   Don't log error when environment does not support WebRTC
+    [\#1547](https://github.com/matrix-org/matrix-js-sdk/pull/1547)
+-   Fix dehydration method name
+    [\#1544](https://github.com/matrix-org/matrix-js-sdk/pull/1544)
+
+# Changes in [9.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0) (2020-11-23)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.2.0-rc.1...v9.2.0)
 
- * [Release] Fix dehydration method name
-   [\#1545](https://github.com/matrix-org/matrix-js-sdk/pull/1545)
+-   [Release] Fix dehydration method name
+    [\#1545](https://github.com/matrix-org/matrix-js-sdk/pull/1545)
+
+# Changes in [9.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0-rc.1) (2020-11-18)
 
-Changes in [9.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0-rc.1) (2020-11-18)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.1.0...v9.2.0-rc.1)
 
- * Implement call holding functionality
-   [\#1532](https://github.com/matrix-org/matrix-js-sdk/pull/1532)
- * Support awaitable one-time dehydration
-   [\#1537](https://github.com/matrix-org/matrix-js-sdk/pull/1537)
- * Client set profile methods update own user
-   [\#1534](https://github.com/matrix-org/matrix-js-sdk/pull/1534)
+-   Implement call holding functionality
+    [\#1532](https://github.com/matrix-org/matrix-js-sdk/pull/1532)
+-   Support awaitable one-time dehydration
+    [\#1537](https://github.com/matrix-org/matrix-js-sdk/pull/1537)
+-   Client set profile methods update own user
+    [\#1534](https://github.com/matrix-org/matrix-js-sdk/pull/1534)
+
+# Changes in [9.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0) (2020-11-09)
 
-Changes in [9.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0) (2020-11-09)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.1.0-rc.1...v9.1.0)
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [9.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0-rc.1) (2020-11-04)
 
-Changes in [9.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0-rc.1) (2020-11-04)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.1...v9.1.0-rc.1)
 
- * Fix spelling error in the server ACL event type
-   [\#1535](https://github.com/matrix-org/matrix-js-sdk/pull/1535)
- * await idb operations from crypto store for dehydration
-   [\#1533](https://github.com/matrix-org/matrix-js-sdk/pull/1533)
- * Fix stuck never-sending messages
-   [\#1531](https://github.com/matrix-org/matrix-js-sdk/pull/1531)
- * Await key cache check to avoid prompts
-   [\#1529](https://github.com/matrix-org/matrix-js-sdk/pull/1529)
- * Improve ICE candidate batching
-   [\#1524](https://github.com/matrix-org/matrix-js-sdk/pull/1524)
- * Convert logger to typescript
-   [\#1527](https://github.com/matrix-org/matrix-js-sdk/pull/1527)
- * Fix logger typo
-   [\#1525](https://github.com/matrix-org/matrix-js-sdk/pull/1525)
- * bind online listener to window instead of document
-   [\#1523](https://github.com/matrix-org/matrix-js-sdk/pull/1523)
- * Support m.call.select_answer
-   [\#1522](https://github.com/matrix-org/matrix-js-sdk/pull/1522)
-
-Changes in [9.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.1) (2020-10-28)
-================================================================================================
+-   Fix spelling error in the server ACL event type
+    [\#1535](https://github.com/matrix-org/matrix-js-sdk/pull/1535)
+-   await idb operations from crypto store for dehydration
+    [\#1533](https://github.com/matrix-org/matrix-js-sdk/pull/1533)
+-   Fix stuck never-sending messages
+    [\#1531](https://github.com/matrix-org/matrix-js-sdk/pull/1531)
+-   Await key cache check to avoid prompts
+    [\#1529](https://github.com/matrix-org/matrix-js-sdk/pull/1529)
+-   Improve ICE candidate batching
+    [\#1524](https://github.com/matrix-org/matrix-js-sdk/pull/1524)
+-   Convert logger to typescript
+    [\#1527](https://github.com/matrix-org/matrix-js-sdk/pull/1527)
+-   Fix logger typo
+    [\#1525](https://github.com/matrix-org/matrix-js-sdk/pull/1525)
+-   bind online listener to window instead of document
+    [\#1523](https://github.com/matrix-org/matrix-js-sdk/pull/1523)
+-   Support m.call.select_answer
+    [\#1522](https://github.com/matrix-org/matrix-js-sdk/pull/1522)
+
+# Changes in [9.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.1) (2020-10-28)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.0...v9.0.1)
 
- * [Release] Await key cache check to avoid prompts
-   [\#1530](https://github.com/matrix-org/matrix-js-sdk/pull/1530)
+-   [Release] Await key cache check to avoid prompts
+    [\#1530](https://github.com/matrix-org/matrix-js-sdk/pull/1530)
+
+# Changes in [9.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0) (2020-10-26)
 
-Changes in [9.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0) (2020-10-26)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.0-rc.1...v9.0.0)
 
- * Fix logger typo
-   [\#1528](https://github.com/matrix-org/matrix-js-sdk/pull/1528)
+-   Fix logger typo
+    [\#1528](https://github.com/matrix-org/matrix-js-sdk/pull/1528)
+
+# Changes in [9.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0-rc.1) (2020-10-21)
 
-Changes in [9.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0-rc.1) (2020-10-21)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.5.0...v9.0.0-rc.1)
 
-BREAKING CHANGES
----
-
- * `hasPendingEvent` now returns false instead of throwing when pending ordering mode is not `detached`
-
-All changes
----
-
- * Don't cache failures when fetching /versions
-   [\#1521](https://github.com/matrix-org/matrix-js-sdk/pull/1521)
- * Install deps first as part of release
-   [\#1518](https://github.com/matrix-org/matrix-js-sdk/pull/1518)
- * [Breaking] Change hasPendingEvent to return false if pending ordering
-   !detached
-   [\#1517](https://github.com/matrix-org/matrix-js-sdk/pull/1517)
- * Skip editor prompts for merges
-   [\#1519](https://github.com/matrix-org/matrix-js-sdk/pull/1519)
- * Convert call test to TypeScript
-   [\#1516](https://github.com/matrix-org/matrix-js-sdk/pull/1516)
- * Support party_id
-   [\#1512](https://github.com/matrix-org/matrix-js-sdk/pull/1512)
- * Support m.call.reject
-   [\#1510](https://github.com/matrix-org/matrix-js-sdk/pull/1510)
- * Remove specbuild from .gitignore
-   [\#1515](https://github.com/matrix-org/matrix-js-sdk/pull/1515)
- * Log the error when we failed to send candidates
-   [\#1514](https://github.com/matrix-org/matrix-js-sdk/pull/1514)
- * Fixes for call state machine
-   [\#1503](https://github.com/matrix-org/matrix-js-sdk/pull/1503)
- * Fix call event handler listener removing
-   [\#1506](https://github.com/matrix-org/matrix-js-sdk/pull/1506)
- * Set the type of the call based on the tracks
-   [\#1501](https://github.com/matrix-org/matrix-js-sdk/pull/1501)
- * Use new local timestamp for calls
-   [\#1499](https://github.com/matrix-org/matrix-js-sdk/pull/1499)
- * Adjust types and APIs to match React SDK
-   [\#1502](https://github.com/matrix-org/matrix-js-sdk/pull/1502)
- * Make an accurate version of 'age' for events
-   [\#1495](https://github.com/matrix-org/matrix-js-sdk/pull/1495)
- * Make 'options' parameter optional
-   [\#1498](https://github.com/matrix-org/matrix-js-sdk/pull/1498)
- * Create a giant event type enum
-   [\#1497](https://github.com/matrix-org/matrix-js-sdk/pull/1497)
- * Convert call.js to Typescript & update WebRTC APIs (re-apply)
-   [\#1494](https://github.com/matrix-org/matrix-js-sdk/pull/1494)
-
-Changes in [8.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0) (2020-10-12)
-================================================================================================
+## BREAKING CHANGES
+
+-   `hasPendingEvent` now returns false instead of throwing when pending ordering mode is not `detached`
+
+## All changes
+
+-   Don't cache failures when fetching /versions
+    [\#1521](https://github.com/matrix-org/matrix-js-sdk/pull/1521)
+-   Install deps first as part of release
+    [\#1518](https://github.com/matrix-org/matrix-js-sdk/pull/1518)
+-   [Breaking] Change hasPendingEvent to return false if pending ordering
+    !detached
+    [\#1517](https://github.com/matrix-org/matrix-js-sdk/pull/1517)
+-   Skip editor prompts for merges
+    [\#1519](https://github.com/matrix-org/matrix-js-sdk/pull/1519)
+-   Convert call test to TypeScript
+    [\#1516](https://github.com/matrix-org/matrix-js-sdk/pull/1516)
+-   Support party_id
+    [\#1512](https://github.com/matrix-org/matrix-js-sdk/pull/1512)
+-   Support m.call.reject
+    [\#1510](https://github.com/matrix-org/matrix-js-sdk/pull/1510)
+-   Remove specbuild from .gitignore
+    [\#1515](https://github.com/matrix-org/matrix-js-sdk/pull/1515)
+-   Log the error when we failed to send candidates
+    [\#1514](https://github.com/matrix-org/matrix-js-sdk/pull/1514)
+-   Fixes for call state machine
+    [\#1503](https://github.com/matrix-org/matrix-js-sdk/pull/1503)
+-   Fix call event handler listener removing
+    [\#1506](https://github.com/matrix-org/matrix-js-sdk/pull/1506)
+-   Set the type of the call based on the tracks
+    [\#1501](https://github.com/matrix-org/matrix-js-sdk/pull/1501)
+-   Use new local timestamp for calls
+    [\#1499](https://github.com/matrix-org/matrix-js-sdk/pull/1499)
+-   Adjust types and APIs to match React SDK
+    [\#1502](https://github.com/matrix-org/matrix-js-sdk/pull/1502)
+-   Make an accurate version of 'age' for events
+    [\#1495](https://github.com/matrix-org/matrix-js-sdk/pull/1495)
+-   Make 'options' parameter optional
+    [\#1498](https://github.com/matrix-org/matrix-js-sdk/pull/1498)
+-   Create a giant event type enum
+    [\#1497](https://github.com/matrix-org/matrix-js-sdk/pull/1497)
+-   Convert call.js to Typescript & update WebRTC APIs (re-apply)
+    [\#1494](https://github.com/matrix-org/matrix-js-sdk/pull/1494)
+
+# Changes in [8.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0) (2020-10-12)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.5.0-rc.1...v8.5.0)
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [8.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0-rc.1) (2020-10-07)
 
-Changes in [8.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0-rc.1) (2020-10-07)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.4.1...v8.5.0-rc.1)
 
- * Add support for olm fallback keys
-   [\#1467](https://github.com/matrix-org/matrix-js-sdk/pull/1467)
- * Fix editing local echoes not updating them in real time
-   [\#1492](https://github.com/matrix-org/matrix-js-sdk/pull/1492)
- * Fix re-emit of Event.replaced to be on client and not room
-   [\#1491](https://github.com/matrix-org/matrix-js-sdk/pull/1491)
- * Add space to log line
-   [\#1496](https://github.com/matrix-org/matrix-js-sdk/pull/1496)
- * Revert "Convert call.js to Typescript & update WebRTC APIs"
-   [\#1493](https://github.com/matrix-org/matrix-js-sdk/pull/1493)
- * Convert call.js to Typescript & update WebRTC APIs
-   [\#1487](https://github.com/matrix-org/matrix-js-sdk/pull/1487)
- * Dehydrate and rehydrate devices
-   [\#1436](https://github.com/matrix-org/matrix-js-sdk/pull/1436)
- * Keep local device after processing device list sync
-   [\#1490](https://github.com/matrix-org/matrix-js-sdk/pull/1490)
- * Enforce logger module via lint rules
-   [\#1489](https://github.com/matrix-org/matrix-js-sdk/pull/1489)
- * Extend method redactEvent with reason
-   [\#1462](https://github.com/matrix-org/matrix-js-sdk/pull/1462)
- * Catch exception from call event handler
-   [\#1484](https://github.com/matrix-org/matrix-js-sdk/pull/1484)
- * Ignore invalid candidates
-   [\#1483](https://github.com/matrix-org/matrix-js-sdk/pull/1483)
- * Always push docs if they are generated
-   [\#1478](https://github.com/matrix-org/matrix-js-sdk/pull/1478)
- * Only sign key backup with cross-signing keys when available
-   [\#1481](https://github.com/matrix-org/matrix-js-sdk/pull/1481)
- * Upgrade dependencies
-   [\#1479](https://github.com/matrix-org/matrix-js-sdk/pull/1479)
-
-Changes in [8.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.1) (2020-09-28)
-================================================================================================
+-   Add support for olm fallback keys
+    [\#1467](https://github.com/matrix-org/matrix-js-sdk/pull/1467)
+-   Fix editing local echoes not updating them in real time
+    [\#1492](https://github.com/matrix-org/matrix-js-sdk/pull/1492)
+-   Fix re-emit of Event.replaced to be on client and not room
+    [\#1491](https://github.com/matrix-org/matrix-js-sdk/pull/1491)
+-   Add space to log line
+    [\#1496](https://github.com/matrix-org/matrix-js-sdk/pull/1496)
+-   Revert "Convert call.js to Typescript & update WebRTC APIs"
+    [\#1493](https://github.com/matrix-org/matrix-js-sdk/pull/1493)
+-   Convert call.js to Typescript & update WebRTC APIs
+    [\#1487](https://github.com/matrix-org/matrix-js-sdk/pull/1487)
+-   Dehydrate and rehydrate devices
+    [\#1436](https://github.com/matrix-org/matrix-js-sdk/pull/1436)
+-   Keep local device after processing device list sync
+    [\#1490](https://github.com/matrix-org/matrix-js-sdk/pull/1490)
+-   Enforce logger module via lint rules
+    [\#1489](https://github.com/matrix-org/matrix-js-sdk/pull/1489)
+-   Extend method redactEvent with reason
+    [\#1462](https://github.com/matrix-org/matrix-js-sdk/pull/1462)
+-   Catch exception from call event handler
+    [\#1484](https://github.com/matrix-org/matrix-js-sdk/pull/1484)
+-   Ignore invalid candidates
+    [\#1483](https://github.com/matrix-org/matrix-js-sdk/pull/1483)
+-   Always push docs if they are generated
+    [\#1478](https://github.com/matrix-org/matrix-js-sdk/pull/1478)
+-   Only sign key backup with cross-signing keys when available
+    [\#1481](https://github.com/matrix-org/matrix-js-sdk/pull/1481)
+-   Upgrade dependencies
+    [\#1479](https://github.com/matrix-org/matrix-js-sdk/pull/1479)
+
+# Changes in [8.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.1) (2020-09-28)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.4.0...v8.4.1)
 
- * Catch exception from call event handler
-   [\#1486](https://github.com/matrix-org/matrix-js-sdk/pull/1486)
- * Ignore invalid candidates
-   [\#1485](https://github.com/matrix-org/matrix-js-sdk/pull/1485)
+-   Catch exception from call event handler
+    [\#1486](https://github.com/matrix-org/matrix-js-sdk/pull/1486)
+-   Ignore invalid candidates
+    [\#1485](https://github.com/matrix-org/matrix-js-sdk/pull/1485)
+
+# Changes in [8.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0) (2020-09-28)
 
-Changes in [8.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0) (2020-09-28)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.4.0-rc.1...v8.4.0)
 
- * Only sign key backup with cross-signing keys when available
-   [\#1482](https://github.com/matrix-org/matrix-js-sdk/pull/1482)
+-   Only sign key backup with cross-signing keys when available
+    [\#1482](https://github.com/matrix-org/matrix-js-sdk/pull/1482)
+
+# Changes in [8.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0-rc.1) (2020-09-23)
 
-Changes in [8.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0-rc.1) (2020-09-23)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.3.0...v8.4.0-rc.1)
 
- * If there are extraParams set, ensure that queryParams is defined
-   [\#1477](https://github.com/matrix-org/matrix-js-sdk/pull/1477)
- * Add diagnostics to security bootstrap paths
-   [\#1475](https://github.com/matrix-org/matrix-js-sdk/pull/1475)
- * Switch to a combination of better-docs and docdash
-   [\#1459](https://github.com/matrix-org/matrix-js-sdk/pull/1459)
- * Undo attempts to cache private keys aggressively
-   [\#1474](https://github.com/matrix-org/matrix-js-sdk/pull/1474)
- * Repair secret storage reset, cache keys when missing
-   [\#1472](https://github.com/matrix-org/matrix-js-sdk/pull/1472)
- * Prevent parallel getVersions calls
-   [\#1471](https://github.com/matrix-org/matrix-js-sdk/pull/1471)
- * Send end-of-candidates
-   [\#1473](https://github.com/matrix-org/matrix-js-sdk/pull/1473)
- * Add a function for checking the /versions flag for forced e2ee
-   [\#1470](https://github.com/matrix-org/matrix-js-sdk/pull/1470)
- * Add option to allow users of pantialaimon to use the SDK
-   [\#1469](https://github.com/matrix-org/matrix-js-sdk/pull/1469)
- * Fixed Yarn broken link
-   [\#1468](https://github.com/matrix-org/matrix-js-sdk/pull/1468)
- * some TypeScript and doc fixes
-   [\#1466](https://github.com/matrix-org/matrix-js-sdk/pull/1466)
- * Remove Travis CI reference
-   [\#1464](https://github.com/matrix-org/matrix-js-sdk/pull/1464)
- * Inject identity server token for 3pid invites on createRoom
-   [\#1463](https://github.com/matrix-org/matrix-js-sdk/pull/1463)
-
-Changes in [8.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0) (2020-09-14)
-================================================================================================
+-   If there are extraParams set, ensure that queryParams is defined
+    [\#1477](https://github.com/matrix-org/matrix-js-sdk/pull/1477)
+-   Add diagnostics to security bootstrap paths
+    [\#1475](https://github.com/matrix-org/matrix-js-sdk/pull/1475)
+-   Switch to a combination of better-docs and docdash
+    [\#1459](https://github.com/matrix-org/matrix-js-sdk/pull/1459)
+-   Undo attempts to cache private keys aggressively
+    [\#1474](https://github.com/matrix-org/matrix-js-sdk/pull/1474)
+-   Repair secret storage reset, cache keys when missing
+    [\#1472](https://github.com/matrix-org/matrix-js-sdk/pull/1472)
+-   Prevent parallel getVersions calls
+    [\#1471](https://github.com/matrix-org/matrix-js-sdk/pull/1471)
+-   Send end-of-candidates
+    [\#1473](https://github.com/matrix-org/matrix-js-sdk/pull/1473)
+-   Add a function for checking the /versions flag for forced e2ee
+    [\#1470](https://github.com/matrix-org/matrix-js-sdk/pull/1470)
+-   Add option to allow users of pantialaimon to use the SDK
+    [\#1469](https://github.com/matrix-org/matrix-js-sdk/pull/1469)
+-   Fixed Yarn broken link
+    [\#1468](https://github.com/matrix-org/matrix-js-sdk/pull/1468)
+-   some TypeScript and doc fixes
+    [\#1466](https://github.com/matrix-org/matrix-js-sdk/pull/1466)
+-   Remove Travis CI reference
+    [\#1464](https://github.com/matrix-org/matrix-js-sdk/pull/1464)
+-   Inject identity server token for 3pid invites on createRoom
+    [\#1463](https://github.com/matrix-org/matrix-js-sdk/pull/1463)
+
+# Changes in [8.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0) (2020-09-14)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.3.0-rc.1...v8.3.0)
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [8.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0-rc.1) (2020-09-09)
 
-Changes in [8.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0-rc.1) (2020-09-09)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.2.0...v8.3.0-rc.1)
 
- * Add missing options in ICreateClientOpts
-   [\#1452](https://github.com/matrix-org/matrix-js-sdk/pull/1452)
- * Ensure ready functions return boolean values
-   [\#1457](https://github.com/matrix-org/matrix-js-sdk/pull/1457)
- * Handle missing cross-signing keys gracefully
-   [\#1456](https://github.com/matrix-org/matrix-js-sdk/pull/1456)
- * Fix eslint ts override tsx matching
-   [\#1451](https://github.com/matrix-org/matrix-js-sdk/pull/1451)
- * Untangle cross-signing and secret storage
-   [\#1450](https://github.com/matrix-org/matrix-js-sdk/pull/1450)
-
-Changes in [8.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0) (2020-09-01)
-================================================================================================
+-   Add missing options in ICreateClientOpts
+    [\#1452](https://github.com/matrix-org/matrix-js-sdk/pull/1452)
+-   Ensure ready functions return boolean values
+    [\#1457](https://github.com/matrix-org/matrix-js-sdk/pull/1457)
+-   Handle missing cross-signing keys gracefully
+    [\#1456](https://github.com/matrix-org/matrix-js-sdk/pull/1456)
+-   Fix eslint ts override tsx matching
+    [\#1451](https://github.com/matrix-org/matrix-js-sdk/pull/1451)
+-   Untangle cross-signing and secret storage
+    [\#1450](https://github.com/matrix-org/matrix-js-sdk/pull/1450)
+
+# Changes in [8.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0) (2020-09-01)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.2.0-rc.1...v8.2.0)
 
 ## Security notice
@@ -1629,2150 +1681,2131 @@ Security Disclosure Policy.
 
 ## All changes
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [8.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0-rc.1) (2020-08-26)
 
-Changes in [8.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0-rc.1) (2020-08-26)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.1.0...v8.2.0-rc.1)
 
- * Add state event check
-   [\#1449](https://github.com/matrix-org/matrix-js-sdk/pull/1449)
- * Add method to check whether client .well-known has been fetched
-   [\#1444](https://github.com/matrix-org/matrix-js-sdk/pull/1444)
- * Handle auth errors during cross-signing key upload
-   [\#1443](https://github.com/matrix-org/matrix-js-sdk/pull/1443)
- * Don't fail if the requested audio output isn't available
-   [\#1448](https://github.com/matrix-org/matrix-js-sdk/pull/1448)
- * Fix logging failures
-   [\#1447](https://github.com/matrix-org/matrix-js-sdk/pull/1447)
- * Log the constraints we pass to getUserMedia
-   [\#1446](https://github.com/matrix-org/matrix-js-sdk/pull/1446)
- * Use SAS emoji data from matrix-doc
-   [\#1440](https://github.com/matrix-org/matrix-js-sdk/pull/1440)
-
-Changes in [8.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0) (2020-08-17)
-================================================================================================
+-   Add state event check
+    [\#1449](https://github.com/matrix-org/matrix-js-sdk/pull/1449)
+-   Add method to check whether client .well-known has been fetched
+    [\#1444](https://github.com/matrix-org/matrix-js-sdk/pull/1444)
+-   Handle auth errors during cross-signing key upload
+    [\#1443](https://github.com/matrix-org/matrix-js-sdk/pull/1443)
+-   Don't fail if the requested audio output isn't available
+    [\#1448](https://github.com/matrix-org/matrix-js-sdk/pull/1448)
+-   Fix logging failures
+    [\#1447](https://github.com/matrix-org/matrix-js-sdk/pull/1447)
+-   Log the constraints we pass to getUserMedia
+    [\#1446](https://github.com/matrix-org/matrix-js-sdk/pull/1446)
+-   Use SAS emoji data from matrix-doc
+    [\#1440](https://github.com/matrix-org/matrix-js-sdk/pull/1440)
+
+# Changes in [8.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0) (2020-08-17)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.1.0-rc.1...v8.1.0)
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [8.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0-rc.1) (2020-08-13)
 
-Changes in [8.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0-rc.1) (2020-08-13)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.0.1...v8.1.0-rc.1)
 
- * Update on Promises
-   [\#1438](https://github.com/matrix-org/matrix-js-sdk/pull/1438)
- * Store and request master cross-signing key
-   [\#1437](https://github.com/matrix-org/matrix-js-sdk/pull/1437)
- * Filter out non-string display names
-   [\#1433](https://github.com/matrix-org/matrix-js-sdk/pull/1433)
- * Bump elliptic from 6.5.2 to 6.5.3
-   [\#1427](https://github.com/matrix-org/matrix-js-sdk/pull/1427)
- * Replace Riot with Element in docs and comments
-   [\#1431](https://github.com/matrix-org/matrix-js-sdk/pull/1431)
- * Remove leftover bits of TSLint
-   [\#1430](https://github.com/matrix-org/matrix-js-sdk/pull/1430)
-
-Changes in [8.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1) (2020-08-05)
-================================================================================================
+-   Update on Promises
+    [\#1438](https://github.com/matrix-org/matrix-js-sdk/pull/1438)
+-   Store and request master cross-signing key
+    [\#1437](https://github.com/matrix-org/matrix-js-sdk/pull/1437)
+-   Filter out non-string display names
+    [\#1433](https://github.com/matrix-org/matrix-js-sdk/pull/1433)
+-   Bump elliptic from 6.5.2 to 6.5.3
+    [\#1427](https://github.com/matrix-org/matrix-js-sdk/pull/1427)
+-   Replace Riot with Element in docs and comments
+    [\#1431](https://github.com/matrix-org/matrix-js-sdk/pull/1431)
+-   Remove leftover bits of TSLint
+    [\#1430](https://github.com/matrix-org/matrix-js-sdk/pull/1430)
+
+# Changes in [8.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1) (2020-08-05)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.0.1-rc.1...v8.0.1)
 
- * Filter out non-string display names
-   [\#1434](https://github.com/matrix-org/matrix-js-sdk/pull/1434)
+-   Filter out non-string display names
+    [\#1434](https://github.com/matrix-org/matrix-js-sdk/pull/1434)
+
+# Changes in [8.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1-rc.1) (2020-07-31)
 
-Changes in [8.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1-rc.1) (2020-07-31)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.0.0...v8.0.1-rc.1)
 
- * Remove redundant lint dependencies
-   [\#1426](https://github.com/matrix-org/matrix-js-sdk/pull/1426)
- * Upload all keys when we start using a new key backup version
-   [\#1428](https://github.com/matrix-org/matrix-js-sdk/pull/1428)
- * Expose countSessionsNeedingBackup
-   [\#1429](https://github.com/matrix-org/matrix-js-sdk/pull/1429)
- * Configure and use new eslint package
-   [\#1422](https://github.com/matrix-org/matrix-js-sdk/pull/1422)
-
-Changes in [8.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.0) (2020-07-27)
-================================================================================================
+-   Remove redundant lint dependencies
+    [\#1426](https://github.com/matrix-org/matrix-js-sdk/pull/1426)
+-   Upload all keys when we start using a new key backup version
+    [\#1428](https://github.com/matrix-org/matrix-js-sdk/pull/1428)
+-   Expose countSessionsNeedingBackup
+    [\#1429](https://github.com/matrix-org/matrix-js-sdk/pull/1429)
+-   Configure and use new eslint package
+    [\#1422](https://github.com/matrix-org/matrix-js-sdk/pull/1422)
+
+# Changes in [8.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.0) (2020-07-27)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.1.0...v8.0.0)
 
-BREAKING CHANGES
----
+## BREAKING CHANGES
+
+-   `RoomState` events changed to use a Map instead of an object, which changes the collection APIs available to access them.
 
-* `RoomState` events changed to use a Map instead of an object, which changes the collection APIs available to access them.
+## All Changes
 
-All Changes
----
+-   Properly support txnId
+    [\#1424](https://github.com/matrix-org/matrix-js-sdk/pull/1424)
+-   [BREAKING] Remove deprecated getIdenticonUri
+    [\#1423](https://github.com/matrix-org/matrix-js-sdk/pull/1423)
+-   Bump lodash from 4.17.15 to 4.17.19
+    [\#1421](https://github.com/matrix-org/matrix-js-sdk/pull/1421)
+-   [BREAKING] Convert RoomState's stored state map to a real map
+    [\#1419](https://github.com/matrix-org/matrix-js-sdk/pull/1419)
 
- * Properly support txnId
-   [\#1424](https://github.com/matrix-org/matrix-js-sdk/pull/1424)
- * [BREAKING] Remove deprecated getIdenticonUri
-   [\#1423](https://github.com/matrix-org/matrix-js-sdk/pull/1423)
- * Bump lodash from 4.17.15 to 4.17.19
-   [\#1421](https://github.com/matrix-org/matrix-js-sdk/pull/1421)
- * [BREAKING] Convert RoomState's stored state map to a real map
-   [\#1419](https://github.com/matrix-org/matrix-js-sdk/pull/1419)
+# Changes in [7.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0) (2020-07-03)
 
-Changes in [7.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0) (2020-07-03)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.1.0-rc.1...v7.1.0)
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [7.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0-rc.1) (2020-07-01)
 
-Changes in [7.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0-rc.1) (2020-07-01)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.0.0...v7.1.0-rc.1)
 
- * Ask general crypto callbacks for 4S privkey if operation adapter doesn't
-   have it yet
-   [\#1414](https://github.com/matrix-org/matrix-js-sdk/pull/1414)
- * Fix ICreateClientOpts missing idBaseUrl
-   [\#1413](https://github.com/matrix-org/matrix-js-sdk/pull/1413)
- * Increase max event listeners for rooms
-   [\#1411](https://github.com/matrix-org/matrix-js-sdk/pull/1411)
- * Don't trust keys megolm received from backup for verifying the sender
-   [\#1406](https://github.com/matrix-org/matrix-js-sdk/pull/1406)
- * Raise the last known account data / state event for an update
-   [\#1410](https://github.com/matrix-org/matrix-js-sdk/pull/1410)
- * Isolate encryption bootstrap side-effects
-   [\#1380](https://github.com/matrix-org/matrix-js-sdk/pull/1380)
- * Add method to get current in-flight to-device requests
-   [\#1405](https://github.com/matrix-org/matrix-js-sdk/pull/1405)
-
-Changes in [7.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0) (2020-06-23)
-================================================================================================
+-   Ask general crypto callbacks for 4S privkey if operation adapter doesn't
+    have it yet
+    [\#1414](https://github.com/matrix-org/matrix-js-sdk/pull/1414)
+-   Fix ICreateClientOpts missing idBaseUrl
+    [\#1413](https://github.com/matrix-org/matrix-js-sdk/pull/1413)
+-   Increase max event listeners for rooms
+    [\#1411](https://github.com/matrix-org/matrix-js-sdk/pull/1411)
+-   Don't trust keys megolm received from backup for verifying the sender
+    [\#1406](https://github.com/matrix-org/matrix-js-sdk/pull/1406)
+-   Raise the last known account data / state event for an update
+    [\#1410](https://github.com/matrix-org/matrix-js-sdk/pull/1410)
+-   Isolate encryption bootstrap side-effects
+    [\#1380](https://github.com/matrix-org/matrix-js-sdk/pull/1380)
+-   Add method to get current in-flight to-device requests
+    [\#1405](https://github.com/matrix-org/matrix-js-sdk/pull/1405)
+
+# Changes in [7.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0) (2020-06-23)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.0.0-rc.1...v7.0.0)
 
-* No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [7.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0-rc.1) (2020-06-17)
 
-Changes in [7.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0-rc.1) (2020-06-17)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.2...v7.0.0-rc.1)
 
-BREAKING CHANGES
----
-
- * Presence lists were removed from the spec in r0.5.0, and the corresponding methods have now been removed here as well:
-   * `getPresenceList`
-   * `inviteToPresenceList`
-   * `dropFromPresenceList`
-
-All changes
----
-
- * Remove support for unspecced device-specific push rules
-   [\#1404](https://github.com/matrix-org/matrix-js-sdk/pull/1404)
- * Use existing session id for fetching flows as to not get a new session
-   [\#1403](https://github.com/matrix-org/matrix-js-sdk/pull/1403)
- * Upgrade deps
-   [\#1400](https://github.com/matrix-org/matrix-js-sdk/pull/1400)
- * Bring back backup key format migration
-   [\#1398](https://github.com/matrix-org/matrix-js-sdk/pull/1398)
- * Fix: more informative error message when we cant find a key to decrypt with
-   [\#1313](https://github.com/matrix-org/matrix-js-sdk/pull/1313)
- * Add js-sdk mechanism for polling client well-known for config
-   [\#1394](https://github.com/matrix-org/matrix-js-sdk/pull/1394)
- * Fix verification request timeouts to match spec
-   [\#1388](https://github.com/matrix-org/matrix-js-sdk/pull/1388)
- * Drop presence list methods
-   [\#1391](https://github.com/matrix-org/matrix-js-sdk/pull/1391)
- * Batch up URL previews to prevent excessive requests
-   [\#1395](https://github.com/matrix-org/matrix-js-sdk/pull/1395)
-
-Changes in [6.2.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.2) (2020-06-16)
-================================================================================================
+## BREAKING CHANGES
+
+-   Presence lists were removed from the spec in r0.5.0, and the corresponding methods have now been removed here as well:
+    -   `getPresenceList`
+    -   `inviteToPresenceList`
+    -   `dropFromPresenceList`
+
+## All changes
+
+-   Remove support for unspecced device-specific push rules
+    [\#1404](https://github.com/matrix-org/matrix-js-sdk/pull/1404)
+-   Use existing session id for fetching flows as to not get a new session
+    [\#1403](https://github.com/matrix-org/matrix-js-sdk/pull/1403)
+-   Upgrade deps
+    [\#1400](https://github.com/matrix-org/matrix-js-sdk/pull/1400)
+-   Bring back backup key format migration
+    [\#1398](https://github.com/matrix-org/matrix-js-sdk/pull/1398)
+-   Fix: more informative error message when we cant find a key to decrypt with
+    [\#1313](https://github.com/matrix-org/matrix-js-sdk/pull/1313)
+-   Add js-sdk mechanism for polling client well-known for config
+    [\#1394](https://github.com/matrix-org/matrix-js-sdk/pull/1394)
+-   Fix verification request timeouts to match spec
+    [\#1388](https://github.com/matrix-org/matrix-js-sdk/pull/1388)
+-   Drop presence list methods
+    [\#1391](https://github.com/matrix-org/matrix-js-sdk/pull/1391)
+-   Batch up URL previews to prevent excessive requests
+    [\#1395](https://github.com/matrix-org/matrix-js-sdk/pull/1395)
+
+# Changes in [6.2.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.2) (2020-06-16)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.1...v6.2.2)
 
- * Use existing session id for fetching flows as to not get a new session
-   [\#1407](https://github.com/matrix-org/matrix-js-sdk/pull/1407)
+-   Use existing session id for fetching flows as to not get a new session
+    [\#1407](https://github.com/matrix-org/matrix-js-sdk/pull/1407)
+
+# Changes in [6.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.1) (2020-06-05)
 
-Changes in [6.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.1) (2020-06-05)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.0...v6.2.1)
 
- * Bring back backup key format migration
-   [\#1399](https://github.com/matrix-org/matrix-js-sdk/pull/1399)
+-   Bring back backup key format migration
+    [\#1399](https://github.com/matrix-org/matrix-js-sdk/pull/1399)
+
+# Changes in [6.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0) (2020-06-04)
 
-Changes in [6.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0) (2020-06-04)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.0-rc.1...v6.2.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [6.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0-rc.1) (2020-06-02)
 
-Changes in [6.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0-rc.1) (2020-06-02)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.1.0...v6.2.0-rc.1)
 
- * Make auth argument in the register request compliant with r0.6.0
-   [\#1304](https://github.com/matrix-org/matrix-js-sdk/pull/1304)
- * Send the wrong auth params with the right auth params
-   [\#1393](https://github.com/matrix-org/matrix-js-sdk/pull/1393)
- * encrypt cached keys with pickle key
-   [\#1387](https://github.com/matrix-org/matrix-js-sdk/pull/1387)
- * Fix replying to key share requests
-   [\#1385](https://github.com/matrix-org/matrix-js-sdk/pull/1385)
- * Add dist to package.json files so CDNs can serve it
-   [\#1384](https://github.com/matrix-org/matrix-js-sdk/pull/1384)
- * Fix getVersion warning saying undefined room
-   [\#1382](https://github.com/matrix-org/matrix-js-sdk/pull/1382)
- * Combine the two places we processed client-level default push rules
-   [\#1379](https://github.com/matrix-org/matrix-js-sdk/pull/1379)
- * make MAC check robust against unpadded vs padded base64 differences
-   [\#1378](https://github.com/matrix-org/matrix-js-sdk/pull/1378)
- * Remove key backup format migration
-   [\#1375](https://github.com/matrix-org/matrix-js-sdk/pull/1375)
- * Add simple browserify browser-matrix.js tests
-   [\#1241](https://github.com/matrix-org/matrix-js-sdk/pull/1241)
- * support new key agreement method for SAS
-   [\#1376](https://github.com/matrix-org/matrix-js-sdk/pull/1376)
-
-Changes in [6.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0) (2020-05-19)
-================================================================================================
+-   Make auth argument in the register request compliant with r0.6.0
+    [\#1304](https://github.com/matrix-org/matrix-js-sdk/pull/1304)
+-   Send the wrong auth params with the right auth params
+    [\#1393](https://github.com/matrix-org/matrix-js-sdk/pull/1393)
+-   encrypt cached keys with pickle key
+    [\#1387](https://github.com/matrix-org/matrix-js-sdk/pull/1387)
+-   Fix replying to key share requests
+    [\#1385](https://github.com/matrix-org/matrix-js-sdk/pull/1385)
+-   Add dist to package.json files so CDNs can serve it
+    [\#1384](https://github.com/matrix-org/matrix-js-sdk/pull/1384)
+-   Fix getVersion warning saying undefined room
+    [\#1382](https://github.com/matrix-org/matrix-js-sdk/pull/1382)
+-   Combine the two places we processed client-level default push rules
+    [\#1379](https://github.com/matrix-org/matrix-js-sdk/pull/1379)
+-   make MAC check robust against unpadded vs padded base64 differences
+    [\#1378](https://github.com/matrix-org/matrix-js-sdk/pull/1378)
+-   Remove key backup format migration
+    [\#1375](https://github.com/matrix-org/matrix-js-sdk/pull/1375)
+-   Add simple browserify browser-matrix.js tests
+    [\#1241](https://github.com/matrix-org/matrix-js-sdk/pull/1241)
+-   support new key agreement method for SAS
+    [\#1376](https://github.com/matrix-org/matrix-js-sdk/pull/1376)
+
+# Changes in [6.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0) (2020-05-19)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.1.0-rc.1...v6.1.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [6.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0-rc.1) (2020-05-14)
 
-Changes in [6.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0-rc.1) (2020-05-14)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.0.0...v6.1.0-rc.1)
 
- * Remove support for asymmetric 4S encryption
-   [\#1373](https://github.com/matrix-org/matrix-js-sdk/pull/1373)
- * Increase timeout for 2nd phase of Olm session creation
-   [\#1367](https://github.com/matrix-org/matrix-js-sdk/pull/1367)
- * Add logging on decryption retries
-   [\#1366](https://github.com/matrix-org/matrix-js-sdk/pull/1366)
- * Emit event when a trusted self-key is stored
-   [\#1364](https://github.com/matrix-org/matrix-js-sdk/pull/1364)
- * Customize error payload for oversized messages
-   [\#1352](https://github.com/matrix-org/matrix-js-sdk/pull/1352)
- * Return null for key backup state when we haven't checked yet
-   [\#1363](https://github.com/matrix-org/matrix-js-sdk/pull/1363)
- * Added a progressCallback for backup key loading
-   [\#1351](https://github.com/matrix-org/matrix-js-sdk/pull/1351)
- * Add initialFetch param to willUpdateDevices / devicesUpdated
-   [\#1360](https://github.com/matrix-org/matrix-js-sdk/pull/1360)
- * Fix race between sending .request and receiving .ready over to_device
-   [\#1359](https://github.com/matrix-org/matrix-js-sdk/pull/1359)
- * Handle race between sending and await next event from other party
-   [\#1357](https://github.com/matrix-org/matrix-js-sdk/pull/1357)
- * Add crypto.willUpdateDevices event and make
-   getStoredDevices/getStoredDevicesForUser synchronous
-   [\#1354](https://github.com/matrix-org/matrix-js-sdk/pull/1354)
- * Fix sender of local echo events in unsigned redactions
-   [\#1350](https://github.com/matrix-org/matrix-js-sdk/pull/1350)
- * Remove redundant key backup setup path
-   [\#1353](https://github.com/matrix-org/matrix-js-sdk/pull/1353)
- * Remove some dead code from _retryDecryption
-   [\#1349](https://github.com/matrix-org/matrix-js-sdk/pull/1349)
- * Don't send key requests until after sync processing is finished
-   [\#1348](https://github.com/matrix-org/matrix-js-sdk/pull/1348)
- * Prevent attempts to send olm messages to ourselves
-   [\#1346](https://github.com/matrix-org/matrix-js-sdk/pull/1346)
- * Retry account data upload requests
-   [\#1345](https://github.com/matrix-org/matrix-js-sdk/pull/1345)
- * Log first known index with megolm session updates
-   [\#1344](https://github.com/matrix-org/matrix-js-sdk/pull/1344)
- * Prune to_device messages to avoid sending empty messages
-   [\#1343](https://github.com/matrix-org/matrix-js-sdk/pull/1343)
- * Convert bunch of things to TypeScript
-   [\#1335](https://github.com/matrix-org/matrix-js-sdk/pull/1335)
- * Add logging when making new Olm sessions
-   [\#1342](https://github.com/matrix-org/matrix-js-sdk/pull/1342)
- * Fix: handle filter not found
-   [\#1340](https://github.com/matrix-org/matrix-js-sdk/pull/1340)
- * Make getAccountDataFromServer return null if not found
-   [\#1338](https://github.com/matrix-org/matrix-js-sdk/pull/1338)
- * Fix setDefaultKeyId to fail if the request fails
-   [\#1336](https://github.com/matrix-org/matrix-js-sdk/pull/1336)
- * Document setRoomEncryption not modifying room state
-   [\#1328](https://github.com/matrix-org/matrix-js-sdk/pull/1328)
- * Fix: don't do extra /filter request when enabling lazy loading of members
-   [\#1332](https://github.com/matrix-org/matrix-js-sdk/pull/1332)
- * Reject attemptAuth promise if no auth flow found
-   [\#1329](https://github.com/matrix-org/matrix-js-sdk/pull/1329)
- * Fix FilterComponent allowed_values check
-   [\#1327](https://github.com/matrix-org/matrix-js-sdk/pull/1327)
- * Serialise Olm prekey decryptions
-   [\#1326](https://github.com/matrix-org/matrix-js-sdk/pull/1326)
- * Fix: crash when backup key needs fixing from corruption issue
-   [\#1324](https://github.com/matrix-org/matrix-js-sdk/pull/1324)
- * Fix cross-signing/SSSS reset
-   [\#1322](https://github.com/matrix-org/matrix-js-sdk/pull/1322)
- * Implement QR code reciprocate for self-verification with untrusted MSK
-   [\#1320](https://github.com/matrix-org/matrix-js-sdk/pull/1320)
-
-Changes in [6.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0) (2020-05-05)
-================================================================================================
+-   Remove support for asymmetric 4S encryption
+    [\#1373](https://github.com/matrix-org/matrix-js-sdk/pull/1373)
+-   Increase timeout for 2nd phase of Olm session creation
+    [\#1367](https://github.com/matrix-org/matrix-js-sdk/pull/1367)
+-   Add logging on decryption retries
+    [\#1366](https://github.com/matrix-org/matrix-js-sdk/pull/1366)
+-   Emit event when a trusted self-key is stored
+    [\#1364](https://github.com/matrix-org/matrix-js-sdk/pull/1364)
+-   Customize error payload for oversized messages
+    [\#1352](https://github.com/matrix-org/matrix-js-sdk/pull/1352)
+-   Return null for key backup state when we haven't checked yet
+    [\#1363](https://github.com/matrix-org/matrix-js-sdk/pull/1363)
+-   Added a progressCallback for backup key loading
+    [\#1351](https://github.com/matrix-org/matrix-js-sdk/pull/1351)
+-   Add initialFetch param to willUpdateDevices / devicesUpdated
+    [\#1360](https://github.com/matrix-org/matrix-js-sdk/pull/1360)
+-   Fix race between sending .request and receiving .ready over to_device
+    [\#1359](https://github.com/matrix-org/matrix-js-sdk/pull/1359)
+-   Handle race between sending and await next event from other party
+    [\#1357](https://github.com/matrix-org/matrix-js-sdk/pull/1357)
+-   Add crypto.willUpdateDevices event and make
+    getStoredDevices/getStoredDevicesForUser synchronous
+    [\#1354](https://github.com/matrix-org/matrix-js-sdk/pull/1354)
+-   Fix sender of local echo events in unsigned redactions
+    [\#1350](https://github.com/matrix-org/matrix-js-sdk/pull/1350)
+-   Remove redundant key backup setup path
+    [\#1353](https://github.com/matrix-org/matrix-js-sdk/pull/1353)
+-   Remove some dead code from \_retryDecryption
+    [\#1349](https://github.com/matrix-org/matrix-js-sdk/pull/1349)
+-   Don't send key requests until after sync processing is finished
+    [\#1348](https://github.com/matrix-org/matrix-js-sdk/pull/1348)
+-   Prevent attempts to send olm messages to ourselves
+    [\#1346](https://github.com/matrix-org/matrix-js-sdk/pull/1346)
+-   Retry account data upload requests
+    [\#1345](https://github.com/matrix-org/matrix-js-sdk/pull/1345)
+-   Log first known index with megolm session updates
+    [\#1344](https://github.com/matrix-org/matrix-js-sdk/pull/1344)
+-   Prune to_device messages to avoid sending empty messages
+    [\#1343](https://github.com/matrix-org/matrix-js-sdk/pull/1343)
+-   Convert bunch of things to TypeScript
+    [\#1335](https://github.com/matrix-org/matrix-js-sdk/pull/1335)
+-   Add logging when making new Olm sessions
+    [\#1342](https://github.com/matrix-org/matrix-js-sdk/pull/1342)
+-   Fix: handle filter not found
+    [\#1340](https://github.com/matrix-org/matrix-js-sdk/pull/1340)
+-   Make getAccountDataFromServer return null if not found
+    [\#1338](https://github.com/matrix-org/matrix-js-sdk/pull/1338)
+-   Fix setDefaultKeyId to fail if the request fails
+    [\#1336](https://github.com/matrix-org/matrix-js-sdk/pull/1336)
+-   Document setRoomEncryption not modifying room state
+    [\#1328](https://github.com/matrix-org/matrix-js-sdk/pull/1328)
+-   Fix: don't do extra /filter request when enabling lazy loading of members
+    [\#1332](https://github.com/matrix-org/matrix-js-sdk/pull/1332)
+-   Reject attemptAuth promise if no auth flow found
+    [\#1329](https://github.com/matrix-org/matrix-js-sdk/pull/1329)
+-   Fix FilterComponent allowed_values check
+    [\#1327](https://github.com/matrix-org/matrix-js-sdk/pull/1327)
+-   Serialise Olm prekey decryptions
+    [\#1326](https://github.com/matrix-org/matrix-js-sdk/pull/1326)
+-   Fix: crash when backup key needs fixing from corruption issue
+    [\#1324](https://github.com/matrix-org/matrix-js-sdk/pull/1324)
+-   Fix cross-signing/SSSS reset
+    [\#1322](https://github.com/matrix-org/matrix-js-sdk/pull/1322)
+-   Implement QR code reciprocate for self-verification with untrusted MSK
+    [\#1320](https://github.com/matrix-org/matrix-js-sdk/pull/1320)
+
+# Changes in [6.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0) (2020-05-05)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.0.0-rc.2...v6.0.0)
 
- * Add progress callback for key backups
-   [\#1368](https://github.com/matrix-org/matrix-js-sdk/pull/1368)
+-   Add progress callback for key backups
+    [\#1368](https://github.com/matrix-org/matrix-js-sdk/pull/1368)
+
+# Changes in [6.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.2) (2020-05-01)
 
-Changes in [6.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.2) (2020-05-01)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.0.0-rc.1...v6.0.0-rc.2)
 
- * Emit event when a trusted self-key is stored
-   [\#1365](https://github.com/matrix-org/matrix-js-sdk/pull/1365)
+-   Emit event when a trusted self-key is stored
+    [\#1365](https://github.com/matrix-org/matrix-js-sdk/pull/1365)
+
+# Changes in [6.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.1) (2020-04-30)
 
-Changes in [6.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.1) (2020-04-30)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.4...v6.0.0-rc.1)
 
-BREAKING CHANGES
----
+## BREAKING CHANGES
 
- * client.getStoredDevicesForUser and client.getStoredDevices are no longer async
+-   client.getStoredDevicesForUser and client.getStoredDevices are no longer async
 
-All Changes
----
+## All Changes
 
- * Add initialFetch param to willUpdateDevices / devicesUpdated
-   [\#1362](https://github.com/matrix-org/matrix-js-sdk/pull/1362)
- * Fix race between sending .request and receiving .ready over to_device
-   [\#1361](https://github.com/matrix-org/matrix-js-sdk/pull/1361)
- * Handle race between sending and await next event from other party
-   [\#1358](https://github.com/matrix-org/matrix-js-sdk/pull/1358)
- * Add crypto.willUpdateDevices event and make
-   getStoredDevices/getStoredDevicesForUser synchronous
-   [\#1356](https://github.com/matrix-org/matrix-js-sdk/pull/1356)
- * Remove redundant key backup setup path
-   [\#1355](https://github.com/matrix-org/matrix-js-sdk/pull/1355)
+-   Add initialFetch param to willUpdateDevices / devicesUpdated
+    [\#1362](https://github.com/matrix-org/matrix-js-sdk/pull/1362)
+-   Fix race between sending .request and receiving .ready over to_device
+    [\#1361](https://github.com/matrix-org/matrix-js-sdk/pull/1361)
+-   Handle race between sending and await next event from other party
+    [\#1358](https://github.com/matrix-org/matrix-js-sdk/pull/1358)
+-   Add crypto.willUpdateDevices event and make
+    getStoredDevices/getStoredDevicesForUser synchronous
+    [\#1356](https://github.com/matrix-org/matrix-js-sdk/pull/1356)
+-   Remove redundant key backup setup path
+    [\#1355](https://github.com/matrix-org/matrix-js-sdk/pull/1355)
+
+# Changes in [5.3.1-rc.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.4) (2020-04-23)
 
-Changes in [5.3.1-rc.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.4) (2020-04-23)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.3...v5.3.1-rc.4)
 
- * Retry account data upload requests
-   [\#1347](https://github.com/matrix-org/matrix-js-sdk/pull/1347)
- * Fix: handle filter not found
-   [\#1341](https://github.com/matrix-org/matrix-js-sdk/pull/1341)
- * Make getAccountDataFromServer return null if not found
-   [\#1339](https://github.com/matrix-org/matrix-js-sdk/pull/1339)
- * Fix setDefaultKeyId to fail if the request fails
-   [\#1337](https://github.com/matrix-org/matrix-js-sdk/pull/1337)
- * Fix: don't do extra /filter request when enabling lazy loading of members
-   [\#1333](https://github.com/matrix-org/matrix-js-sdk/pull/1333)
- * Reject attemptAuth promise if no auth flow found
-   [\#1331](https://github.com/matrix-org/matrix-js-sdk/pull/1331)
- * Serialise Olm prekey decryptions
-   [\#1330](https://github.com/matrix-org/matrix-js-sdk/pull/1330)
-
-Changes in [5.3.1-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.3) (2020-04-17)
-==========================================================================================================
+-   Retry account data upload requests
+    [\#1347](https://github.com/matrix-org/matrix-js-sdk/pull/1347)
+-   Fix: handle filter not found
+    [\#1341](https://github.com/matrix-org/matrix-js-sdk/pull/1341)
+-   Make getAccountDataFromServer return null if not found
+    [\#1339](https://github.com/matrix-org/matrix-js-sdk/pull/1339)
+-   Fix setDefaultKeyId to fail if the request fails
+    [\#1337](https://github.com/matrix-org/matrix-js-sdk/pull/1337)
+-   Fix: don't do extra /filter request when enabling lazy loading of members
+    [\#1333](https://github.com/matrix-org/matrix-js-sdk/pull/1333)
+-   Reject attemptAuth promise if no auth flow found
+    [\#1331](https://github.com/matrix-org/matrix-js-sdk/pull/1331)
+-   Serialise Olm prekey decryptions
+    [\#1330](https://github.com/matrix-org/matrix-js-sdk/pull/1330)
+
+# Changes in [5.3.1-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.3) (2020-04-17)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.2...v5.3.1-rc.3)
 
- * Fix cross-signing/SSSS reset
-   [\#1323](https://github.com/matrix-org/matrix-js-sdk/pull/1323)
- * Fix: crash when backup key needs fixing from corruption issue
-   [\#1325](https://github.com/matrix-org/matrix-js-sdk/pull/1325)
+-   Fix cross-signing/SSSS reset
+    [\#1323](https://github.com/matrix-org/matrix-js-sdk/pull/1323)
+-   Fix: crash when backup key needs fixing from corruption issue
+    [\#1325](https://github.com/matrix-org/matrix-js-sdk/pull/1325)
+
+# Changes in [5.3.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.2) (2020-04-16)
 
-Changes in [5.3.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.2) (2020-04-16)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.1...v5.3.1-rc.2)
 
- * Implement QR code reciprocate for self-verification with untrusted MSK
-   [\#1321](https://github.com/matrix-org/matrix-js-sdk/pull/1321)
+-   Implement QR code reciprocate for self-verification with untrusted MSK
+    [\#1321](https://github.com/matrix-org/matrix-js-sdk/pull/1321)
+
+# Changes in [5.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.1) (2020-04-15)
 
-Changes in [5.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.1) (2020-04-15)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.0-rc.1...v5.3.1-rc.1)
 
- * Adapt release script for riot-desktop
-   [\#1319](https://github.com/matrix-org/matrix-js-sdk/pull/1319)
- * Fix: prevent spurious notifications from indexer
-   [\#1318](https://github.com/matrix-org/matrix-js-sdk/pull/1318)
- * Always create our own user object
-   [\#1317](https://github.com/matrix-org/matrix-js-sdk/pull/1317)
- * Fix incorrect backup key format in SSSS
-   [\#1311](https://github.com/matrix-org/matrix-js-sdk/pull/1311)
- * Fix e2ee crash after refreshing after having received a cross-singing key
-   reset
-   [\#1315](https://github.com/matrix-org/matrix-js-sdk/pull/1315)
- * Fix: catch send errors in SAS verifier
-   [\#1314](https://github.com/matrix-org/matrix-js-sdk/pull/1314)
- * Clear cross-signing keys when detecting the keys have changed
-   [\#1312](https://github.com/matrix-org/matrix-js-sdk/pull/1312)
- * Upgrade deps
-   [\#1310](https://github.com/matrix-org/matrix-js-sdk/pull/1310)
-
-Changes in [5.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.0-rc.1) (2020-04-08)
-==========================================================================================================
+-   Adapt release script for riot-desktop
+    [\#1319](https://github.com/matrix-org/matrix-js-sdk/pull/1319)
+-   Fix: prevent spurious notifications from indexer
+    [\#1318](https://github.com/matrix-org/matrix-js-sdk/pull/1318)
+-   Always create our own user object
+    [\#1317](https://github.com/matrix-org/matrix-js-sdk/pull/1317)
+-   Fix incorrect backup key format in SSSS
+    [\#1311](https://github.com/matrix-org/matrix-js-sdk/pull/1311)
+-   Fix e2ee crash after refreshing after having received a cross-singing key
+    reset
+    [\#1315](https://github.com/matrix-org/matrix-js-sdk/pull/1315)
+-   Fix: catch send errors in SAS verifier
+    [\#1314](https://github.com/matrix-org/matrix-js-sdk/pull/1314)
+-   Clear cross-signing keys when detecting the keys have changed
+    [\#1312](https://github.com/matrix-org/matrix-js-sdk/pull/1312)
+-   Upgrade deps
+    [\#1310](https://github.com/matrix-org/matrix-js-sdk/pull/1310)
+
+# Changes in [5.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.0-rc.1) (2020-04-08)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.2.0...v5.3.0-rc.1)
 
- * Store key backup key in cache as Uint8Array
-   [\#1308](https://github.com/matrix-org/matrix-js-sdk/pull/1308)
- * Use the correct request body for the /keys/query endpoint.
-   [\#1307](https://github.com/matrix-org/matrix-js-sdk/pull/1307)
- * Avoid creating two devices on registration
-   [\#1305](https://github.com/matrix-org/matrix-js-sdk/pull/1305)
- * Lower max-warnings to 81
-   [\#1306](https://github.com/matrix-org/matrix-js-sdk/pull/1306)
- * Move key backup key creation before caching
-   [\#1303](https://github.com/matrix-org/matrix-js-sdk/pull/1303)
- * Expose function to force-reset outgoing room key requests
-   [\#1298](https://github.com/matrix-org/matrix-js-sdk/pull/1298)
- * Add isSelfVerification property to VerificationRequest
-   [\#1302](https://github.com/matrix-org/matrix-js-sdk/pull/1302)
- * QR code reciprocation
-   [\#1297](https://github.com/matrix-org/matrix-js-sdk/pull/1297)
- * Add ability to check symmetric SSSS key before we try to use it
-   [\#1294](https://github.com/matrix-org/matrix-js-sdk/pull/1294)
- * Add some debug logging for events stuck to bottom of timeline
-   [\#1296](https://github.com/matrix-org/matrix-js-sdk/pull/1296)
- * Fix: spontanous verification request cancellation under some circumstances
-   [\#1295](https://github.com/matrix-org/matrix-js-sdk/pull/1295)
- * Receive private key for caching from the app layer
-   [\#1293](https://github.com/matrix-org/matrix-js-sdk/pull/1293)
- * Track whether we have verified a user before
-   [\#1292](https://github.com/matrix-org/matrix-js-sdk/pull/1292)
- * Fix: error during tests
-   [\#1222](https://github.com/matrix-org/matrix-js-sdk/pull/1222)
- * Send .done event for to_device verification
-   [\#1288](https://github.com/matrix-org/matrix-js-sdk/pull/1288)
- * Request the key backup key & restore backup
-   [\#1291](https://github.com/matrix-org/matrix-js-sdk/pull/1291)
- * Make screen sharing works on Chrome using getDisplayMedia()
-   [\#1276](https://github.com/matrix-org/matrix-js-sdk/pull/1276)
- * Fix isVerified returning false
-   [\#1289](https://github.com/matrix-org/matrix-js-sdk/pull/1289)
- * Fix: verification gets cancelled when event gets duplicated
-   [\#1286](https://github.com/matrix-org/matrix-js-sdk/pull/1286)
- * Use requestSecret on the client to request secrets
-   [\#1287](https://github.com/matrix-org/matrix-js-sdk/pull/1287)
- * Allow guests to fetch TURN servers
-   [\#1277](https://github.com/matrix-org/matrix-js-sdk/pull/1277)
-
-Changes in [5.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0) (2020-03-30)
-================================================================================================
+-   Store key backup key in cache as Uint8Array
+    [\#1308](https://github.com/matrix-org/matrix-js-sdk/pull/1308)
+-   Use the correct request body for the /keys/query endpoint.
+    [\#1307](https://github.com/matrix-org/matrix-js-sdk/pull/1307)
+-   Avoid creating two devices on registration
+    [\#1305](https://github.com/matrix-org/matrix-js-sdk/pull/1305)
+-   Lower max-warnings to 81
+    [\#1306](https://github.com/matrix-org/matrix-js-sdk/pull/1306)
+-   Move key backup key creation before caching
+    [\#1303](https://github.com/matrix-org/matrix-js-sdk/pull/1303)
+-   Expose function to force-reset outgoing room key requests
+    [\#1298](https://github.com/matrix-org/matrix-js-sdk/pull/1298)
+-   Add isSelfVerification property to VerificationRequest
+    [\#1302](https://github.com/matrix-org/matrix-js-sdk/pull/1302)
+-   QR code reciprocation
+    [\#1297](https://github.com/matrix-org/matrix-js-sdk/pull/1297)
+-   Add ability to check symmetric SSSS key before we try to use it
+    [\#1294](https://github.com/matrix-org/matrix-js-sdk/pull/1294)
+-   Add some debug logging for events stuck to bottom of timeline
+    [\#1296](https://github.com/matrix-org/matrix-js-sdk/pull/1296)
+-   Fix: spontanous verification request cancellation under some circumstances
+    [\#1295](https://github.com/matrix-org/matrix-js-sdk/pull/1295)
+-   Receive private key for caching from the app layer
+    [\#1293](https://github.com/matrix-org/matrix-js-sdk/pull/1293)
+-   Track whether we have verified a user before
+    [\#1292](https://github.com/matrix-org/matrix-js-sdk/pull/1292)
+-   Fix: error during tests
+    [\#1222](https://github.com/matrix-org/matrix-js-sdk/pull/1222)
+-   Send .done event for to_device verification
+    [\#1288](https://github.com/matrix-org/matrix-js-sdk/pull/1288)
+-   Request the key backup key & restore backup
+    [\#1291](https://github.com/matrix-org/matrix-js-sdk/pull/1291)
+-   Make screen sharing works on Chrome using getDisplayMedia()
+    [\#1276](https://github.com/matrix-org/matrix-js-sdk/pull/1276)
+-   Fix isVerified returning false
+    [\#1289](https://github.com/matrix-org/matrix-js-sdk/pull/1289)
+-   Fix: verification gets cancelled when event gets duplicated
+    [\#1286](https://github.com/matrix-org/matrix-js-sdk/pull/1286)
+-   Use requestSecret on the client to request secrets
+    [\#1287](https://github.com/matrix-org/matrix-js-sdk/pull/1287)
+-   Allow guests to fetch TURN servers
+    [\#1277](https://github.com/matrix-org/matrix-js-sdk/pull/1277)
+
+# Changes in [5.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0) (2020-03-30)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.2.0-rc.1...v5.2.0)
 
- * Fix isVerified returning false
-   [\#1290](https://github.com/matrix-org/matrix-js-sdk/pull/1290)
+-   Fix isVerified returning false
+    [\#1290](https://github.com/matrix-org/matrix-js-sdk/pull/1290)
+
+# Changes in [5.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0-rc.1) (2020-03-26)
 
-Changes in [5.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0-rc.1) (2020-03-26)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.1...v5.2.0-rc.1)
 
- * Add a flag for whether cross signing signatures are trusted
-   [\#1285](https://github.com/matrix-org/matrix-js-sdk/pull/1285)
- * Cache user and self signing keys during bootstrap
-   [\#1282](https://github.com/matrix-org/matrix-js-sdk/pull/1282)
- * remove unnecessary promise
-   [\#1283](https://github.com/matrix-org/matrix-js-sdk/pull/1283)
- * Functions to cache session backups key automatically
-   [\#1281](https://github.com/matrix-org/matrix-js-sdk/pull/1281)
- * Add function for checking cross-signing is ready
-   [\#1279](https://github.com/matrix-org/matrix-js-sdk/pull/1279)
- * Use symmetric encryption for SSSS
-   [\#1228](https://github.com/matrix-org/matrix-js-sdk/pull/1228)
- * Migrate SSSS to use symmetric algorithm
-   [\#1238](https://github.com/matrix-org/matrix-js-sdk/pull/1238)
- * Migration to symmetric SSSS
-   [\#1272](https://github.com/matrix-org/matrix-js-sdk/pull/1272)
- * Reduce number of one-time-key requests
-   [\#1280](https://github.com/matrix-org/matrix-js-sdk/pull/1280)
- * Fix: assume the requested method is supported by other party with to_device
-   [\#1275](https://github.com/matrix-org/matrix-js-sdk/pull/1275)
- * Use checkDeviceTrust when computing untrusted devices
-   [\#1278](https://github.com/matrix-org/matrix-js-sdk/pull/1278)
- * Add a store for backup keys
-   [\#1271](https://github.com/matrix-org/matrix-js-sdk/pull/1271)
- * Upload only new device signature of master key
-   [\#1268](https://github.com/matrix-org/matrix-js-sdk/pull/1268)
- * Expose prepareToEncrypt in the client API
-   [\#1270](https://github.com/matrix-org/matrix-js-sdk/pull/1270)
- * Don't kill the whole device download if one device gives an error
-   [\#1269](https://github.com/matrix-org/matrix-js-sdk/pull/1269)
- * Handle racing .start event during self verification
-   [\#1267](https://github.com/matrix-org/matrix-js-sdk/pull/1267)
- * A crypto.keySignatureUploadFailure event reported the wrong source
-   [\#1266](https://github.com/matrix-org/matrix-js-sdk/pull/1266)
- * Fix editing of unsent messages by waiting for actual event id
-   [\#1263](https://github.com/matrix-org/matrix-js-sdk/pull/1263)
- * Fix: ensureOlmSessionsForDevices parameter format
-   [\#1264](https://github.com/matrix-org/matrix-js-sdk/pull/1264)
- * Remove stuff that yarn install doesn't think we need
-   [\#1261](https://github.com/matrix-org/matrix-js-sdk/pull/1261)
- * Fix: prevent error being thrown during sync in some cases
-   [\#1258](https://github.com/matrix-org/matrix-js-sdk/pull/1258)
- * Force `is_verified` for key backups to bool and fix computation
-   [\#1259](https://github.com/matrix-org/matrix-js-sdk/pull/1259)
- * Add a method for legacy single device verification, returning a verification
-   request
-   [\#1257](https://github.com/matrix-org/matrix-js-sdk/pull/1257)
- * yarn upgrade
-   [\#1256](https://github.com/matrix-org/matrix-js-sdk/pull/1256)
-
-Changes in [5.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1) (2020-03-17)
-================================================================================================
+-   Add a flag for whether cross signing signatures are trusted
+    [\#1285](https://github.com/matrix-org/matrix-js-sdk/pull/1285)
+-   Cache user and self signing keys during bootstrap
+    [\#1282](https://github.com/matrix-org/matrix-js-sdk/pull/1282)
+-   remove unnecessary promise
+    [\#1283](https://github.com/matrix-org/matrix-js-sdk/pull/1283)
+-   Functions to cache session backups key automatically
+    [\#1281](https://github.com/matrix-org/matrix-js-sdk/pull/1281)
+-   Add function for checking cross-signing is ready
+    [\#1279](https://github.com/matrix-org/matrix-js-sdk/pull/1279)
+-   Use symmetric encryption for SSSS
+    [\#1228](https://github.com/matrix-org/matrix-js-sdk/pull/1228)
+-   Migrate SSSS to use symmetric algorithm
+    [\#1238](https://github.com/matrix-org/matrix-js-sdk/pull/1238)
+-   Migration to symmetric SSSS
+    [\#1272](https://github.com/matrix-org/matrix-js-sdk/pull/1272)
+-   Reduce number of one-time-key requests
+    [\#1280](https://github.com/matrix-org/matrix-js-sdk/pull/1280)
+-   Fix: assume the requested method is supported by other party with to_device
+    [\#1275](https://github.com/matrix-org/matrix-js-sdk/pull/1275)
+-   Use checkDeviceTrust when computing untrusted devices
+    [\#1278](https://github.com/matrix-org/matrix-js-sdk/pull/1278)
+-   Add a store for backup keys
+    [\#1271](https://github.com/matrix-org/matrix-js-sdk/pull/1271)
+-   Upload only new device signature of master key
+    [\#1268](https://github.com/matrix-org/matrix-js-sdk/pull/1268)
+-   Expose prepareToEncrypt in the client API
+    [\#1270](https://github.com/matrix-org/matrix-js-sdk/pull/1270)
+-   Don't kill the whole device download if one device gives an error
+    [\#1269](https://github.com/matrix-org/matrix-js-sdk/pull/1269)
+-   Handle racing .start event during self verification
+    [\#1267](https://github.com/matrix-org/matrix-js-sdk/pull/1267)
+-   A crypto.keySignatureUploadFailure event reported the wrong source
+    [\#1266](https://github.com/matrix-org/matrix-js-sdk/pull/1266)
+-   Fix editing of unsent messages by waiting for actual event id
+    [\#1263](https://github.com/matrix-org/matrix-js-sdk/pull/1263)
+-   Fix: ensureOlmSessionsForDevices parameter format
+    [\#1264](https://github.com/matrix-org/matrix-js-sdk/pull/1264)
+-   Remove stuff that yarn install doesn't think we need
+    [\#1261](https://github.com/matrix-org/matrix-js-sdk/pull/1261)
+-   Fix: prevent error being thrown during sync in some cases
+    [\#1258](https://github.com/matrix-org/matrix-js-sdk/pull/1258)
+-   Force `is_verified` for key backups to bool and fix computation
+    [\#1259](https://github.com/matrix-org/matrix-js-sdk/pull/1259)
+-   Add a method for legacy single device verification, returning a verification
+    request
+    [\#1257](https://github.com/matrix-org/matrix-js-sdk/pull/1257)
+-   yarn upgrade
+    [\#1256](https://github.com/matrix-org/matrix-js-sdk/pull/1256)
+
+# Changes in [5.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1) (2020-03-17)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.1-rc.1...v5.1.1)
 
- * Fix: ensureOlmSessionsForDevices parameter format
-   [\#1265](https://github.com/matrix-org/matrix-js-sdk/pull/1265)
- * Fix: prevent error being thrown during sync in some cases
-   [\#1262](https://github.com/matrix-org/matrix-js-sdk/pull/1262)
- * Force `is_verified` for key backups to bool and fix computation
-   [\#1260](https://github.com/matrix-org/matrix-js-sdk/pull/1260)
+-   Fix: ensureOlmSessionsForDevices parameter format
+    [\#1265](https://github.com/matrix-org/matrix-js-sdk/pull/1265)
+-   Fix: prevent error being thrown during sync in some cases
+    [\#1262](https://github.com/matrix-org/matrix-js-sdk/pull/1262)
+-   Force `is_verified` for key backups to bool and fix computation
+    [\#1260](https://github.com/matrix-org/matrix-js-sdk/pull/1260)
+
+# Changes in [5.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1-rc.1) (2020-03-11)
 
-Changes in [5.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1-rc.1) (2020-03-11)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.0...v5.1.1-rc.1)
 
- * refactor megolm encryption to improve perceived speed
-   [\#1252](https://github.com/matrix-org/matrix-js-sdk/pull/1252)
- * Remove v1 identity server fallbacks
-   [\#1253](https://github.com/matrix-org/matrix-js-sdk/pull/1253)
- * Use alt_aliases instead of local ones for room names
-   [\#1251](https://github.com/matrix-org/matrix-js-sdk/pull/1251)
- * Upload cross-signing key signatures in the background
-   [\#1250](https://github.com/matrix-org/matrix-js-sdk/pull/1250)
- * Fix secret sharing names to match spec
-   [\#1249](https://github.com/matrix-org/matrix-js-sdk/pull/1249)
- * Cleanup: remove crypto.verification.start event
-   [\#1248](https://github.com/matrix-org/matrix-js-sdk/pull/1248)
- * Fix regression in key backup request params
-   [\#1246](https://github.com/matrix-org/matrix-js-sdk/pull/1246)
- * Use cross-signing trust to mark backups verified
-   [\#1244](https://github.com/matrix-org/matrix-js-sdk/pull/1244)
- * Check both cross-signing and local trust for key sharing
-   [\#1243](https://github.com/matrix-org/matrix-js-sdk/pull/1243)
- * Fixed up tests to match new way that crypto stores are created
-   [\#1242](https://github.com/matrix-org/matrix-js-sdk/pull/1242)
- * Store USK and SSK locally
-   [\#1235](https://github.com/matrix-org/matrix-js-sdk/pull/1235)
- * Use unpadded base64 for QR code secrets
-   [\#1236](https://github.com/matrix-org/matrix-js-sdk/pull/1236)
- * Don't require .done event for finishing self-verification
-   [\#1239](https://github.com/matrix-org/matrix-js-sdk/pull/1239)
- * Don't cancel as 3rd party in verification request
-   [\#1237](https://github.com/matrix-org/matrix-js-sdk/pull/1237)
- * Verification: log when switching start event
-   [\#1234](https://github.com/matrix-org/matrix-js-sdk/pull/1234)
- * Perform crypto store operations directly after transaction
-   [\#1233](https://github.com/matrix-org/matrix-js-sdk/pull/1233)
- * More verification request logging
-   [\#1232](https://github.com/matrix-org/matrix-js-sdk/pull/1232)
- * Upgrade deps
-   [\#1231](https://github.com/matrix-org/matrix-js-sdk/pull/1231)
-
-Changes in [5.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0) (2020-03-02)
-================================================================================================
+-   refactor megolm encryption to improve perceived speed
+    [\#1252](https://github.com/matrix-org/matrix-js-sdk/pull/1252)
+-   Remove v1 identity server fallbacks
+    [\#1253](https://github.com/matrix-org/matrix-js-sdk/pull/1253)
+-   Use alt_aliases instead of local ones for room names
+    [\#1251](https://github.com/matrix-org/matrix-js-sdk/pull/1251)
+-   Upload cross-signing key signatures in the background
+    [\#1250](https://github.com/matrix-org/matrix-js-sdk/pull/1250)
+-   Fix secret sharing names to match spec
+    [\#1249](https://github.com/matrix-org/matrix-js-sdk/pull/1249)
+-   Cleanup: remove crypto.verification.start event
+    [\#1248](https://github.com/matrix-org/matrix-js-sdk/pull/1248)
+-   Fix regression in key backup request params
+    [\#1246](https://github.com/matrix-org/matrix-js-sdk/pull/1246)
+-   Use cross-signing trust to mark backups verified
+    [\#1244](https://github.com/matrix-org/matrix-js-sdk/pull/1244)
+-   Check both cross-signing and local trust for key sharing
+    [\#1243](https://github.com/matrix-org/matrix-js-sdk/pull/1243)
+-   Fixed up tests to match new way that crypto stores are created
+    [\#1242](https://github.com/matrix-org/matrix-js-sdk/pull/1242)
+-   Store USK and SSK locally
+    [\#1235](https://github.com/matrix-org/matrix-js-sdk/pull/1235)
+-   Use unpadded base64 for QR code secrets
+    [\#1236](https://github.com/matrix-org/matrix-js-sdk/pull/1236)
+-   Don't require .done event for finishing self-verification
+    [\#1239](https://github.com/matrix-org/matrix-js-sdk/pull/1239)
+-   Don't cancel as 3rd party in verification request
+    [\#1237](https://github.com/matrix-org/matrix-js-sdk/pull/1237)
+-   Verification: log when switching start event
+    [\#1234](https://github.com/matrix-org/matrix-js-sdk/pull/1234)
+-   Perform crypto store operations directly after transaction
+    [\#1233](https://github.com/matrix-org/matrix-js-sdk/pull/1233)
+-   More verification request logging
+    [\#1232](https://github.com/matrix-org/matrix-js-sdk/pull/1232)
+-   Upgrade deps
+    [\#1231](https://github.com/matrix-org/matrix-js-sdk/pull/1231)
+
+# Changes in [5.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0) (2020-03-02)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.0-rc.1...v5.1.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [5.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0-rc.1) (2020-02-26)
 
-Changes in [5.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0-rc.1) (2020-02-26)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.0.1...v5.1.0-rc.1)
 
- * Add latest dist-tag for releases
-   [\#1230](https://github.com/matrix-org/matrix-js-sdk/pull/1230)
- * Add room method for alt_aliases
-   [\#1225](https://github.com/matrix-org/matrix-js-sdk/pull/1225)
- * Remove buildkite pipeline
-   [\#1227](https://github.com/matrix-org/matrix-js-sdk/pull/1227)
- * don't assume verify has been called when receiving a cancellation in
-   verifier
-   [\#1226](https://github.com/matrix-org/matrix-js-sdk/pull/1226)
- * Reduce secret size for new binary packing
-   [\#1221](https://github.com/matrix-org/matrix-js-sdk/pull/1221)
- * misc rageshake fixes
-   [\#1223](https://github.com/matrix-org/matrix-js-sdk/pull/1223)
- * Fix cancelled historical requests not appearing as cancelled
-   [\#1220](https://github.com/matrix-org/matrix-js-sdk/pull/1220)
- * Fix renaming error that broke QR code verification
-   [\#1217](https://github.com/matrix-org/matrix-js-sdk/pull/1217)
-
-Changes in [5.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.1) (2020-02-19)
-================================================================================================
+-   Add latest dist-tag for releases
+    [\#1230](https://github.com/matrix-org/matrix-js-sdk/pull/1230)
+-   Add room method for alt_aliases
+    [\#1225](https://github.com/matrix-org/matrix-js-sdk/pull/1225)
+-   Remove buildkite pipeline
+    [\#1227](https://github.com/matrix-org/matrix-js-sdk/pull/1227)
+-   don't assume verify has been called when receiving a cancellation in
+    verifier
+    [\#1226](https://github.com/matrix-org/matrix-js-sdk/pull/1226)
+-   Reduce secret size for new binary packing
+    [\#1221](https://github.com/matrix-org/matrix-js-sdk/pull/1221)
+-   misc rageshake fixes
+    [\#1223](https://github.com/matrix-org/matrix-js-sdk/pull/1223)
+-   Fix cancelled historical requests not appearing as cancelled
+    [\#1220](https://github.com/matrix-org/matrix-js-sdk/pull/1220)
+-   Fix renaming error that broke QR code verification
+    [\#1217](https://github.com/matrix-org/matrix-js-sdk/pull/1217)
+
+# Changes in [5.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.1) (2020-02-19)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.0.0...v5.0.1)
 
- * add method for new /aliases endpoint
-   [\#1219](https://github.com/matrix-org/matrix-js-sdk/pull/1219)
- * method for checking if other party supports verification method
-   [\#1213](https://github.com/matrix-org/matrix-js-sdk/pull/1213)
- * add local echo state for accepting or declining a verif req
-   [\#1210](https://github.com/matrix-org/matrix-js-sdk/pull/1210)
- * make logging compatible with rageshakes
-   [\#1214](https://github.com/matrix-org/matrix-js-sdk/pull/1214)
- * Find existing requests when starting a new verification request
-   [\#1209](https://github.com/matrix-org/matrix-js-sdk/pull/1209)
- * log MAC calculation during SAS
-   [\#1211](https://github.com/matrix-org/matrix-js-sdk/pull/1211)
-
-Changes in [5.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0) (2020-02-17)
-================================================================================================
+-   add method for new /aliases endpoint
+    [\#1219](https://github.com/matrix-org/matrix-js-sdk/pull/1219)
+-   method for checking if other party supports verification method
+    [\#1213](https://github.com/matrix-org/matrix-js-sdk/pull/1213)
+-   add local echo state for accepting or declining a verif req
+    [\#1210](https://github.com/matrix-org/matrix-js-sdk/pull/1210)
+-   make logging compatible with rageshakes
+    [\#1214](https://github.com/matrix-org/matrix-js-sdk/pull/1214)
+-   Find existing requests when starting a new verification request
+    [\#1209](https://github.com/matrix-org/matrix-js-sdk/pull/1209)
+-   log MAC calculation during SAS
+    [\#1211](https://github.com/matrix-org/matrix-js-sdk/pull/1211)
+
+# Changes in [5.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0) (2020-02-17)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.0.0-rc.1...v5.0.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [5.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0-rc.1) (2020-02-13)
 
-Changes in [5.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0-rc.1) (2020-02-13)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v4.0.0...v5.0.0-rc.1)
 
-BREAKING CHANGES
----
-
- * The verification methods API has removed an argument ([\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206))
-
-All Changes
----
-
- * Remove methods argument to verification
-   [\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206)
- * don't do a dynamic import of request
-   [\#1207](https://github.com/matrix-org/matrix-js-sdk/pull/1207)
- * QR self-verification fixes
-   [\#1201](https://github.com/matrix-org/matrix-js-sdk/pull/1201)
- * Log every verification event
-   [\#1204](https://github.com/matrix-org/matrix-js-sdk/pull/1204)
- * dont require .done event from other party
-   [\#1203](https://github.com/matrix-org/matrix-js-sdk/pull/1203)
- * New option to fully reset Secret Storage keys in boostrapSecretStorage
-   [\#1202](https://github.com/matrix-org/matrix-js-sdk/pull/1202)
- * Add function to estimate target device for a VerificationRequest
-   [\#1190](https://github.com/matrix-org/matrix-js-sdk/pull/1190)
- * pass ssss item name to callback so we can differentiate UI on it
-   [\#1200](https://github.com/matrix-org/matrix-js-sdk/pull/1200)
- * add export/import of Olm devices
-   [\#1167](https://github.com/matrix-org/matrix-js-sdk/pull/1167)
- * Convert utils.js -> utils.ts
-   [\#1199](https://github.com/matrix-org/matrix-js-sdk/pull/1199)
- * Don't sign ourselves as a user
-   [\#1197](https://github.com/matrix-org/matrix-js-sdk/pull/1197)
- * Add a bunch of logging to verification
-   [\#1196](https://github.com/matrix-org/matrix-js-sdk/pull/1196)
- * Fix: always return a valid string from InRoomChannel.getEventType
-   [\#1198](https://github.com/matrix-org/matrix-js-sdk/pull/1198)
- * add logging when a request is being cancelled
-   [\#1195](https://github.com/matrix-org/matrix-js-sdk/pull/1195)
- * Don't explode verification validation if we don't have an event type
-   [\#1194](https://github.com/matrix-org/matrix-js-sdk/pull/1194)
- * Fix: verification request appearing for users that are not the receiver or
-   sender if they are in room
-   [\#1193](https://github.com/matrix-org/matrix-js-sdk/pull/1193)
- * Fix getting secrets encoded with passthrough keys
-   [\#1192](https://github.com/matrix-org/matrix-js-sdk/pull/1192)
- * Update QR code handling for new spec
-   [\#1175](https://github.com/matrix-org/matrix-js-sdk/pull/1175)
- * Don't add ephemeral events to timeline when peeking
-   [\#1188](https://github.com/matrix-org/matrix-js-sdk/pull/1188)
- * Fix typo
-   [\#1189](https://github.com/matrix-org/matrix-js-sdk/pull/1189)
- * Verification: resolve race between .start events from both parties
-   [\#1187](https://github.com/matrix-org/matrix-js-sdk/pull/1187)
- * Add option to bootstrap to start new key backup
-   [\#1184](https://github.com/matrix-org/matrix-js-sdk/pull/1184)
- * Add a bunch of null guards to feature checks
-   [\#1182](https://github.com/matrix-org/matrix-js-sdk/pull/1182)
- * docs: fix MatrixClient reference
-   [\#1183](https://github.com/matrix-org/matrix-js-sdk/pull/1183)
- * Add helper to obtain the cancellation code for a verification request
-   [\#1180](https://github.com/matrix-org/matrix-js-sdk/pull/1180)
- * Publish pre-releases as a separate tag on npm
-   [\#1178](https://github.com/matrix-org/matrix-js-sdk/pull/1178)
- * Fix support for passthrough keys
-   [\#1177](https://github.com/matrix-org/matrix-js-sdk/pull/1177)
- * Trust our own cross-signing keys if we verify them with another device
-   [\#1174](https://github.com/matrix-org/matrix-js-sdk/pull/1174)
- * Ensure cross-signing keys are downloaded when checking trust
-   [\#1176](https://github.com/matrix-org/matrix-js-sdk/pull/1176)
- * Don't log verification validation errors for normal messages
-   [\#1172](https://github.com/matrix-org/matrix-js-sdk/pull/1172)
- * Fix bootstrap cleanup
-   [\#1173](https://github.com/matrix-org/matrix-js-sdk/pull/1173)
- * QR code verification
-   [\#1155](https://github.com/matrix-org/matrix-js-sdk/pull/1155)
- * expose deviceId prop on device channel
-   [\#1171](https://github.com/matrix-org/matrix-js-sdk/pull/1171)
- * Move & upgrade babel runtime into dependencies (like it wants)
-   [\#1169](https://github.com/matrix-org/matrix-js-sdk/pull/1169)
- * Add unit tests for verifying your own device, remove .event property on
-   verification request
-   [\#1166](https://github.com/matrix-org/matrix-js-sdk/pull/1166)
- * For dm-verification, also consider events sent by other devices of same user
-   as "our" events
-   [\#1163](https://github.com/matrix-org/matrix-js-sdk/pull/1163)
- * Add a prepare script
-   [\#1161](https://github.com/matrix-org/matrix-js-sdk/pull/1161)
- * Remove :deviceId from /keys/upload/:deviceId as not spec-compliant
-   [\#1162](https://github.com/matrix-org/matrix-js-sdk/pull/1162)
- * Refactor and expose some logic publicly for the TimelineWindow class.
-   [\#1159](https://github.com/matrix-org/matrix-js-sdk/pull/1159)
- * Allow a device key upload request without auth
-   [\#1158](https://github.com/matrix-org/matrix-js-sdk/pull/1158)
- * Support for .ready verification event (MSC2366) & other things
-   [\#1140](https://github.com/matrix-org/matrix-js-sdk/pull/1140)
-
-Changes in [4.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0) (2020-01-27)
-================================================================================================
+## BREAKING CHANGES
+
+-   The verification methods API has removed an argument ([\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206))
+
+## All Changes
+
+-   Remove methods argument to verification
+    [\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206)
+-   don't do a dynamic import of request
+    [\#1207](https://github.com/matrix-org/matrix-js-sdk/pull/1207)
+-   QR self-verification fixes
+    [\#1201](https://github.com/matrix-org/matrix-js-sdk/pull/1201)
+-   Log every verification event
+    [\#1204](https://github.com/matrix-org/matrix-js-sdk/pull/1204)
+-   dont require .done event from other party
+    [\#1203](https://github.com/matrix-org/matrix-js-sdk/pull/1203)
+-   New option to fully reset Secret Storage keys in boostrapSecretStorage
+    [\#1202](https://github.com/matrix-org/matrix-js-sdk/pull/1202)
+-   Add function to estimate target device for a VerificationRequest
+    [\#1190](https://github.com/matrix-org/matrix-js-sdk/pull/1190)
+-   pass ssss item name to callback so we can differentiate UI on it
+    [\#1200](https://github.com/matrix-org/matrix-js-sdk/pull/1200)
+-   add export/import of Olm devices
+    [\#1167](https://github.com/matrix-org/matrix-js-sdk/pull/1167)
+-   Convert utils.js -> utils.ts
+    [\#1199](https://github.com/matrix-org/matrix-js-sdk/pull/1199)
+-   Don't sign ourselves as a user
+    [\#1197](https://github.com/matrix-org/matrix-js-sdk/pull/1197)
+-   Add a bunch of logging to verification
+    [\#1196](https://github.com/matrix-org/matrix-js-sdk/pull/1196)
+-   Fix: always return a valid string from InRoomChannel.getEventType
+    [\#1198](https://github.com/matrix-org/matrix-js-sdk/pull/1198)
+-   add logging when a request is being cancelled
+    [\#1195](https://github.com/matrix-org/matrix-js-sdk/pull/1195)
+-   Don't explode verification validation if we don't have an event type
+    [\#1194](https://github.com/matrix-org/matrix-js-sdk/pull/1194)
+-   Fix: verification request appearing for users that are not the receiver or
+    sender if they are in room
+    [\#1193](https://github.com/matrix-org/matrix-js-sdk/pull/1193)
+-   Fix getting secrets encoded with passthrough keys
+    [\#1192](https://github.com/matrix-org/matrix-js-sdk/pull/1192)
+-   Update QR code handling for new spec
+    [\#1175](https://github.com/matrix-org/matrix-js-sdk/pull/1175)
+-   Don't add ephemeral events to timeline when peeking
+    [\#1188](https://github.com/matrix-org/matrix-js-sdk/pull/1188)
+-   Fix typo
+    [\#1189](https://github.com/matrix-org/matrix-js-sdk/pull/1189)
+-   Verification: resolve race between .start events from both parties
+    [\#1187](https://github.com/matrix-org/matrix-js-sdk/pull/1187)
+-   Add option to bootstrap to start new key backup
+    [\#1184](https://github.com/matrix-org/matrix-js-sdk/pull/1184)
+-   Add a bunch of null guards to feature checks
+    [\#1182](https://github.com/matrix-org/matrix-js-sdk/pull/1182)
+-   docs: fix MatrixClient reference
+    [\#1183](https://github.com/matrix-org/matrix-js-sdk/pull/1183)
+-   Add helper to obtain the cancellation code for a verification request
+    [\#1180](https://github.com/matrix-org/matrix-js-sdk/pull/1180)
+-   Publish pre-releases as a separate tag on npm
+    [\#1178](https://github.com/matrix-org/matrix-js-sdk/pull/1178)
+-   Fix support for passthrough keys
+    [\#1177](https://github.com/matrix-org/matrix-js-sdk/pull/1177)
+-   Trust our own cross-signing keys if we verify them with another device
+    [\#1174](https://github.com/matrix-org/matrix-js-sdk/pull/1174)
+-   Ensure cross-signing keys are downloaded when checking trust
+    [\#1176](https://github.com/matrix-org/matrix-js-sdk/pull/1176)
+-   Don't log verification validation errors for normal messages
+    [\#1172](https://github.com/matrix-org/matrix-js-sdk/pull/1172)
+-   Fix bootstrap cleanup
+    [\#1173](https://github.com/matrix-org/matrix-js-sdk/pull/1173)
+-   QR code verification
+    [\#1155](https://github.com/matrix-org/matrix-js-sdk/pull/1155)
+-   expose deviceId prop on device channel
+    [\#1171](https://github.com/matrix-org/matrix-js-sdk/pull/1171)
+-   Move & upgrade babel runtime into dependencies (like it wants)
+    [\#1169](https://github.com/matrix-org/matrix-js-sdk/pull/1169)
+-   Add unit tests for verifying your own device, remove .event property on
+    verification request
+    [\#1166](https://github.com/matrix-org/matrix-js-sdk/pull/1166)
+-   For dm-verification, also consider events sent by other devices of same user
+    as "our" events
+    [\#1163](https://github.com/matrix-org/matrix-js-sdk/pull/1163)
+-   Add a prepare script
+    [\#1161](https://github.com/matrix-org/matrix-js-sdk/pull/1161)
+-   Remove :deviceId from /keys/upload/:deviceId as not spec-compliant
+    [\#1162](https://github.com/matrix-org/matrix-js-sdk/pull/1162)
+-   Refactor and expose some logic publicly for the TimelineWindow class.
+    [\#1159](https://github.com/matrix-org/matrix-js-sdk/pull/1159)
+-   Allow a device key upload request without auth
+    [\#1158](https://github.com/matrix-org/matrix-js-sdk/pull/1158)
+-   Support for .ready verification event (MSC2366) & other things
+    [\#1140](https://github.com/matrix-org/matrix-js-sdk/pull/1140)
+
+# Changes in [4.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0) (2020-01-27)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v4.0.0-rc.1...v4.0.0)
 
- * Move & upgrade babel runtime into dependencies (like it wants)
-   [\#1170](https://github.com/matrix-org/matrix-js-sdk/pull/1170)
- * Add a prepare script
-   [\#1164](https://github.com/matrix-org/matrix-js-sdk/pull/1164)
+-   Move & upgrade babel runtime into dependencies (like it wants)
+    [\#1170](https://github.com/matrix-org/matrix-js-sdk/pull/1170)
+-   Add a prepare script
+    [\#1164](https://github.com/matrix-org/matrix-js-sdk/pull/1164)
+
+# Changes in [4.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0-rc.1) (2020-01-20)
 
-Changes in [4.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0-rc.1) (2020-01-20)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v3.0.0...v4.0.0-rc.1)
 
-BREAKING CHANGES
-================
- * The js-sdk node module now exports ES6 rather than ES5. If you
-   wish to supports target that aren't compatible with ES6, you
-   will need to transpile the js-sdk to a suitable dialect.
-
-All Changes
-===========
- * Convert secret storage to new account data API
-   [\#1154](https://github.com/matrix-org/matrix-js-sdk/pull/1154)
- * Add v5 as a safe room version
-   [\#1157](https://github.com/matrix-org/matrix-js-sdk/pull/1157)
- * Add API to get account data from server
-   [\#1153](https://github.com/matrix-org/matrix-js-sdk/pull/1153)
- * Fix sourcemaps by refactoring the build system
-   [\#1151](https://github.com/matrix-org/matrix-js-sdk/pull/1151)
- * record, report, and notify about olm errors
-   [\#1146](https://github.com/matrix-org/matrix-js-sdk/pull/1146)
- * Send device messages for the same user in same API call.
-   [\#1148](https://github.com/matrix-org/matrix-js-sdk/pull/1148)
- * Add an option to ignore unverified devices
-   [\#1150](https://github.com/matrix-org/matrix-js-sdk/pull/1150)
- * Sign key backup with cross-signing key on upgrade
-   [\#1144](https://github.com/matrix-org/matrix-js-sdk/pull/1144)
- * Emoji verification: Change name of 🔒 to lock
-   [\#1145](https://github.com/matrix-org/matrix-js-sdk/pull/1145)
- * use a separate object for each encrypted content
-   [\#1147](https://github.com/matrix-org/matrix-js-sdk/pull/1147)
- * Sourcemaps: develop -> feature branch
-   [\#1143](https://github.com/matrix-org/matrix-js-sdk/pull/1143)
- * Use a safer import/export scheme for the ContentRepo utilities
-   [\#1134](https://github.com/matrix-org/matrix-js-sdk/pull/1134)
- * Fix error handling in decryptGroupMessage
-   [\#1142](https://github.com/matrix-org/matrix-js-sdk/pull/1142)
- * Add additional properties to package.json for riot-web's webpack
-   [\#1131](https://github.com/matrix-org/matrix-js-sdk/pull/1131)
- * Fix import for indexeddb crypto store
-   [\#1133](https://github.com/matrix-org/matrix-js-sdk/pull/1133)
- * Use the right request when creating clients
-   [\#1132](https://github.com/matrix-org/matrix-js-sdk/pull/1132)
- * Target NodeJS 10, minified browser bundle, and other publishing/package
-   things
-   [\#1127](https://github.com/matrix-org/matrix-js-sdk/pull/1127)
- * Re-focus sourcemap generation
-   [\#1126](https://github.com/matrix-org/matrix-js-sdk/pull/1126)
- * Remove ancient polyfill for prototype inheritance
-   [\#1125](https://github.com/matrix-org/matrix-js-sdk/pull/1125)
- * Remove "source-map-support" from tests because it makes sourcemaps worse
-   [\#1124](https://github.com/matrix-org/matrix-js-sdk/pull/1124)
- * Remove ancient "use strict" annotations
-   [\#1123](https://github.com/matrix-org/matrix-js-sdk/pull/1123)
- * Use ES6 imports/exports instead of older CommonJS ones
-   [\#1122](https://github.com/matrix-org/matrix-js-sdk/pull/1122)
- * [BREAKING] Refactor the entire build process
-   [\#1113](https://github.com/matrix-org/matrix-js-sdk/pull/1113)
-
-Changes in [3.42.2-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.42.2-rc.3) (2022-04-08)
-============================================================================================================
+# BREAKING CHANGES
+
+-   The js-sdk node module now exports ES6 rather than ES5. If you
+    wish to supports target that aren't compatible with ES6, you
+    will need to transpile the js-sdk to a suitable dialect.
+
+# All Changes
+
+-   Convert secret storage to new account data API
+    [\#1154](https://github.com/matrix-org/matrix-js-sdk/pull/1154)
+-   Add v5 as a safe room version
+    [\#1157](https://github.com/matrix-org/matrix-js-sdk/pull/1157)
+-   Add API to get account data from server
+    [\#1153](https://github.com/matrix-org/matrix-js-sdk/pull/1153)
+-   Fix sourcemaps by refactoring the build system
+    [\#1151](https://github.com/matrix-org/matrix-js-sdk/pull/1151)
+-   record, report, and notify about olm errors
+    [\#1146](https://github.com/matrix-org/matrix-js-sdk/pull/1146)
+-   Send device messages for the same user in same API call.
+    [\#1148](https://github.com/matrix-org/matrix-js-sdk/pull/1148)
+-   Add an option to ignore unverified devices
+    [\#1150](https://github.com/matrix-org/matrix-js-sdk/pull/1150)
+-   Sign key backup with cross-signing key on upgrade
+    [\#1144](https://github.com/matrix-org/matrix-js-sdk/pull/1144)
+-   Emoji verification: Change name of 🔒 to lock
+    [\#1145](https://github.com/matrix-org/matrix-js-sdk/pull/1145)
+-   use a separate object for each encrypted content
+    [\#1147](https://github.com/matrix-org/matrix-js-sdk/pull/1147)
+-   Sourcemaps: develop -> feature branch
+    [\#1143](https://github.com/matrix-org/matrix-js-sdk/pull/1143)
+-   Use a safer import/export scheme for the ContentRepo utilities
+    [\#1134](https://github.com/matrix-org/matrix-js-sdk/pull/1134)
+-   Fix error handling in decryptGroupMessage
+    [\#1142](https://github.com/matrix-org/matrix-js-sdk/pull/1142)
+-   Add additional properties to package.json for riot-web's webpack
+    [\#1131](https://github.com/matrix-org/matrix-js-sdk/pull/1131)
+-   Fix import for indexeddb crypto store
+    [\#1133](https://github.com/matrix-org/matrix-js-sdk/pull/1133)
+-   Use the right request when creating clients
+    [\#1132](https://github.com/matrix-org/matrix-js-sdk/pull/1132)
+-   Target NodeJS 10, minified browser bundle, and other publishing/package
+    things
+    [\#1127](https://github.com/matrix-org/matrix-js-sdk/pull/1127)
+-   Re-focus sourcemap generation
+    [\#1126](https://github.com/matrix-org/matrix-js-sdk/pull/1126)
+-   Remove ancient polyfill for prototype inheritance
+    [\#1125](https://github.com/matrix-org/matrix-js-sdk/pull/1125)
+-   Remove "source-map-support" from tests because it makes sourcemaps worse
+    [\#1124](https://github.com/matrix-org/matrix-js-sdk/pull/1124)
+-   Remove ancient "use strict" annotations
+    [\#1123](https://github.com/matrix-org/matrix-js-sdk/pull/1123)
+-   Use ES6 imports/exports instead of older CommonJS ones
+    [\#1122](https://github.com/matrix-org/matrix-js-sdk/pull/1122)
+-   [BREAKING] Refactor the entire build process
+    [\#1113](https://github.com/matrix-org/matrix-js-sdk/pull/1113)
+
+# Changes in [3.42.2-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.42.2-rc.3) (2022-04-08)
 
 ## 🐛 Bug Fixes
- * Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
 
-Changes in [3.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0) (2020-01-13)
-================================================================================================
+-   Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
+
+# Changes in [3.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0) (2020-01-13)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v3.0.0-rc.1...v3.0.0)
 
- * No changes from rc.1
+-   No changes from rc.1
+
+# Changes in [3.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0-rc.1) (2020-01-06)
 
-Changes in [3.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0-rc.1) (2020-01-06)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.6...v3.0.0-rc.1)
 
-BREAKING CHANGES
-================
- * matrix-js-sdk no longer uses bluebird promises, so promises returned
-   by the js-sdk no longer support the done() method. Code that calls
-   done() on promises returned by the js-sdk will break and will need
-   to be updated to remove the done() call.
-
-All Changes
-===========
- * Make displayName disambiguation more fuzzy especially against RTL/LTR
-   content
-   [\#1141](https://github.com/matrix-org/matrix-js-sdk/pull/1141)
- * stop trying to resend event if we get M_TOO_LARGE
-   [\#1129](https://github.com/matrix-org/matrix-js-sdk/pull/1129)
- * Fix creating a key backup with cross signing diabled
-   [\#1139](https://github.com/matrix-org/matrix-js-sdk/pull/1139)
- * Use checkDeviceTrust with key backup
-   [\#1138](https://github.com/matrix-org/matrix-js-sdk/pull/1138)
- * Add support for passthrough SSSS secrets
-   [\#1128](https://github.com/matrix-org/matrix-js-sdk/pull/1128)
- * Add support for key backups using secret storage
-   [\#1118](https://github.com/matrix-org/matrix-js-sdk/pull/1118)
- * Remove unused user verification event
-   [\#1117](https://github.com/matrix-org/matrix-js-sdk/pull/1117)
- * Fix check for private keys
-   [\#1116](https://github.com/matrix-org/matrix-js-sdk/pull/1116)
- * Restore watching mode for `start:watch`
-   [\#1115](https://github.com/matrix-org/matrix-js-sdk/pull/1115)
- * Add secret storage bootstrap flow
-   [\#1079](https://github.com/matrix-org/matrix-js-sdk/pull/1079)
- * Part 1 of many: Upgrade to babel@7 and TypeScript
-   [\#1112](https://github.com/matrix-org/matrix-js-sdk/pull/1112)
- * Remove Bluebird: phase 2.5
-   [\#1100](https://github.com/matrix-org/matrix-js-sdk/pull/1100)
- * Remove Bluebird: phase 3
-   [\#1088](https://github.com/matrix-org/matrix-js-sdk/pull/1088)
- * ignore m.key.verification.done messages when we don't expect any more
-   messages
-   [\#1104](https://github.com/matrix-org/matrix-js-sdk/pull/1104)
- * dont cancel on remote echo of own .request event
-   [\#1111](https://github.com/matrix-org/matrix-js-sdk/pull/1111)
- * Refactor verification request code
-   [\#1109](https://github.com/matrix-org/matrix-js-sdk/pull/1109)
- * Fix device list's cross-signing storage path
-   [\#1105](https://github.com/matrix-org/matrix-js-sdk/pull/1105)
- * yarn upgrade
-   [\#1103](https://github.com/matrix-org/matrix-js-sdk/pull/1103)
-
-Changes in [2.4.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6) (2019-12-09)
-================================================================================================
+# BREAKING CHANGES
+
+-   matrix-js-sdk no longer uses bluebird promises, so promises returned
+    by the js-sdk no longer support the done() method. Code that calls
+    done() on promises returned by the js-sdk will break and will need
+    to be updated to remove the done() call.
+
+# All Changes
+
+-   Make displayName disambiguation more fuzzy especially against RTL/LTR
+    content
+    [\#1141](https://github.com/matrix-org/matrix-js-sdk/pull/1141)
+-   stop trying to resend event if we get M_TOO_LARGE
+    [\#1129](https://github.com/matrix-org/matrix-js-sdk/pull/1129)
+-   Fix creating a key backup with cross signing diabled
+    [\#1139](https://github.com/matrix-org/matrix-js-sdk/pull/1139)
+-   Use checkDeviceTrust with key backup
+    [\#1138](https://github.com/matrix-org/matrix-js-sdk/pull/1138)
+-   Add support for passthrough SSSS secrets
+    [\#1128](https://github.com/matrix-org/matrix-js-sdk/pull/1128)
+-   Add support for key backups using secret storage
+    [\#1118](https://github.com/matrix-org/matrix-js-sdk/pull/1118)
+-   Remove unused user verification event
+    [\#1117](https://github.com/matrix-org/matrix-js-sdk/pull/1117)
+-   Fix check for private keys
+    [\#1116](https://github.com/matrix-org/matrix-js-sdk/pull/1116)
+-   Restore watching mode for `start:watch`
+    [\#1115](https://github.com/matrix-org/matrix-js-sdk/pull/1115)
+-   Add secret storage bootstrap flow
+    [\#1079](https://github.com/matrix-org/matrix-js-sdk/pull/1079)
+-   Part 1 of many: Upgrade to babel@7 and TypeScript
+    [\#1112](https://github.com/matrix-org/matrix-js-sdk/pull/1112)
+-   Remove Bluebird: phase 2.5
+    [\#1100](https://github.com/matrix-org/matrix-js-sdk/pull/1100)
+-   Remove Bluebird: phase 3
+    [\#1088](https://github.com/matrix-org/matrix-js-sdk/pull/1088)
+-   ignore m.key.verification.done messages when we don't expect any more
+    messages
+    [\#1104](https://github.com/matrix-org/matrix-js-sdk/pull/1104)
+-   dont cancel on remote echo of own .request event
+    [\#1111](https://github.com/matrix-org/matrix-js-sdk/pull/1111)
+-   Refactor verification request code
+    [\#1109](https://github.com/matrix-org/matrix-js-sdk/pull/1109)
+-   Fix device list's cross-signing storage path
+    [\#1105](https://github.com/matrix-org/matrix-js-sdk/pull/1105)
+-   yarn upgrade
+    [\#1103](https://github.com/matrix-org/matrix-js-sdk/pull/1103)
+
+# Changes in [2.4.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6) (2019-12-09)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.6-rc.1...v2.4.6)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [2.4.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6-rc.1) (2019-12-04)
 
-Changes in [2.4.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6-rc.1) (2019-12-04)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.5...v2.4.6-rc.1)
 
- * Update alias handling
-   [\#1102](https://github.com/matrix-org/matrix-js-sdk/pull/1102)
- * increase timeout on flush to fix failing unit test
-   [\#1096](https://github.com/matrix-org/matrix-js-sdk/pull/1096)
- * Disable broken cross-signing test
-   [\#1095](https://github.com/matrix-org/matrix-js-sdk/pull/1095)
- * Fix a couple SAS tests
-   [\#1094](https://github.com/matrix-org/matrix-js-sdk/pull/1094)
- * Fix Olm unwedging test
-   [\#1093](https://github.com/matrix-org/matrix-js-sdk/pull/1093)
- * Fix empty string handling in push notifications
-   [\#1089](https://github.com/matrix-org/matrix-js-sdk/pull/1089)
- * expand e2ee logging to better debug UISIs
-   [\#1090](https://github.com/matrix-org/matrix-js-sdk/pull/1090)
- * Remove Bluebird: phase 2
-   [\#1087](https://github.com/matrix-org/matrix-js-sdk/pull/1087)
- * Relax identity server discovery checks to FAIL_PROMPT
-   [\#1062](https://github.com/matrix-org/matrix-js-sdk/pull/1062)
- * Fix incorrect return value of MatrixClient.prototype.uploadKeys
-   [\#1061](https://github.com/matrix-org/matrix-js-sdk/pull/1061)
- * Fix calls in e2e rooms
-   [\#1086](https://github.com/matrix-org/matrix-js-sdk/pull/1086)
- * Monitor verification request over DM as well
-   [\#1085](https://github.com/matrix-org/matrix-js-sdk/pull/1085)
- * Remove 'check' npm script
-   [\#1084](https://github.com/matrix-org/matrix-js-sdk/pull/1084)
- * Always process call events in batches
-   [\#1083](https://github.com/matrix-org/matrix-js-sdk/pull/1083)
- * Fix ringing chirp on loading
-   [\#1082](https://github.com/matrix-org/matrix-js-sdk/pull/1082)
- * Remove *most* bluebird specific things
-   [\#1081](https://github.com/matrix-org/matrix-js-sdk/pull/1081)
- * Switch to Jest
-   [\#1080](https://github.com/matrix-org/matrix-js-sdk/pull/1080)
-
-Changes in [2.4.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.5) (2019-11-27)
-================================================================================================
+-   Update alias handling
+    [\#1102](https://github.com/matrix-org/matrix-js-sdk/pull/1102)
+-   increase timeout on flush to fix failing unit test
+    [\#1096](https://github.com/matrix-org/matrix-js-sdk/pull/1096)
+-   Disable broken cross-signing test
+    [\#1095](https://github.com/matrix-org/matrix-js-sdk/pull/1095)
+-   Fix a couple SAS tests
+    [\#1094](https://github.com/matrix-org/matrix-js-sdk/pull/1094)
+-   Fix Olm unwedging test
+    [\#1093](https://github.com/matrix-org/matrix-js-sdk/pull/1093)
+-   Fix empty string handling in push notifications
+    [\#1089](https://github.com/matrix-org/matrix-js-sdk/pull/1089)
+-   expand e2ee logging to better debug UISIs
+    [\#1090](https://github.com/matrix-org/matrix-js-sdk/pull/1090)
+-   Remove Bluebird: phase 2
+    [\#1087](https://github.com/matrix-org/matrix-js-sdk/pull/1087)
+-   Relax identity server discovery checks to FAIL_PROMPT
+    [\#1062](https://github.com/matrix-org/matrix-js-sdk/pull/1062)
+-   Fix incorrect return value of MatrixClient.prototype.uploadKeys
+    [\#1061](https://github.com/matrix-org/matrix-js-sdk/pull/1061)
+-   Fix calls in e2e rooms
+    [\#1086](https://github.com/matrix-org/matrix-js-sdk/pull/1086)
+-   Monitor verification request over DM as well
+    [\#1085](https://github.com/matrix-org/matrix-js-sdk/pull/1085)
+-   Remove 'check' npm script
+    [\#1084](https://github.com/matrix-org/matrix-js-sdk/pull/1084)
+-   Always process call events in batches
+    [\#1083](https://github.com/matrix-org/matrix-js-sdk/pull/1083)
+-   Fix ringing chirp on loading
+    [\#1082](https://github.com/matrix-org/matrix-js-sdk/pull/1082)
+-   Remove _most_ bluebird specific things
+    [\#1081](https://github.com/matrix-org/matrix-js-sdk/pull/1081)
+-   Switch to Jest
+    [\#1080](https://github.com/matrix-org/matrix-js-sdk/pull/1080)
+
+# Changes in [2.4.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.5) (2019-11-27)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.4...v2.4.5)
 
-* Relax identity server discovery checks to FAIL_PROMPT
-* Expand E2EE debug logging to diagnose "unable to decrypt" errors
+-   Relax identity server discovery checks to FAIL_PROMPT
+-   Expand E2EE debug logging to diagnose "unable to decrypt" errors
+
+# Changes in [2.4.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4) (2019-11-25)
 
-Changes in [2.4.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4) (2019-11-25)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.4-rc.1...v2.4.4)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [2.4.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4-rc.1) (2019-11-20)
 
-Changes in [2.4.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4-rc.1) (2019-11-20)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.3...v2.4.4-rc.1)
 
- * Fix SAS verification in encrypted DMs
-   [\#1077](https://github.com/matrix-org/matrix-js-sdk/pull/1077)
- * Cross-signing / secret storage tweaks
-   [\#1078](https://github.com/matrix-org/matrix-js-sdk/pull/1078)
- * Fix local trust for key backups
-   [\#1075](https://github.com/matrix-org/matrix-js-sdk/pull/1075)
- * Add method to get last active timestamp in room
-   [\#1072](https://github.com/matrix-org/matrix-js-sdk/pull/1072)
- * Check the right Synapse endpoint for determining admin capabilities
-   [\#1071](https://github.com/matrix-org/matrix-js-sdk/pull/1071)
- * Cross Signing Support
-   [\#832](https://github.com/matrix-org/matrix-js-sdk/pull/832)
- * Don't double cancel verification request
-   [\#1064](https://github.com/matrix-org/matrix-js-sdk/pull/1064)
- * Support for verification requests in the timeline
-   [\#1067](https://github.com/matrix-org/matrix-js-sdk/pull/1067)
- * Use stable API prefix for 3PID APIs when supported
-   [\#1066](https://github.com/matrix-org/matrix-js-sdk/pull/1066)
- * Remove Jenkins scripts
-   [\#1063](https://github.com/matrix-org/matrix-js-sdk/pull/1063)
-
-Changes in [2.4.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3) (2019-11-04)
-================================================================================================
+-   Fix SAS verification in encrypted DMs
+    [\#1077](https://github.com/matrix-org/matrix-js-sdk/pull/1077)
+-   Cross-signing / secret storage tweaks
+    [\#1078](https://github.com/matrix-org/matrix-js-sdk/pull/1078)
+-   Fix local trust for key backups
+    [\#1075](https://github.com/matrix-org/matrix-js-sdk/pull/1075)
+-   Add method to get last active timestamp in room
+    [\#1072](https://github.com/matrix-org/matrix-js-sdk/pull/1072)
+-   Check the right Synapse endpoint for determining admin capabilities
+    [\#1071](https://github.com/matrix-org/matrix-js-sdk/pull/1071)
+-   Cross Signing Support
+    [\#832](https://github.com/matrix-org/matrix-js-sdk/pull/832)
+-   Don't double cancel verification request
+    [\#1064](https://github.com/matrix-org/matrix-js-sdk/pull/1064)
+-   Support for verification requests in the timeline
+    [\#1067](https://github.com/matrix-org/matrix-js-sdk/pull/1067)
+-   Use stable API prefix for 3PID APIs when supported
+    [\#1066](https://github.com/matrix-org/matrix-js-sdk/pull/1066)
+-   Remove Jenkins scripts
+    [\#1063](https://github.com/matrix-org/matrix-js-sdk/pull/1063)
+
+# Changes in [2.4.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3) (2019-11-04)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.3-rc.1...v2.4.3)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [2.4.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3-rc.1) (2019-10-30)
 
-Changes in [2.4.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3-rc.1) (2019-10-30)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.2...v2.4.3-rc.1)
 
- * fix the path in references to logger.js
-   [\#1056](https://github.com/matrix-org/matrix-js-sdk/pull/1056)
- * verification in DMs
-   [\#1050](https://github.com/matrix-org/matrix-js-sdk/pull/1050)
- * Properly documented the function possible returns
-   [\#1054](https://github.com/matrix-org/matrix-js-sdk/pull/1054)
- * Downgrade to Bluebird 3.5.5 to fix Firefox
-   [\#1055](https://github.com/matrix-org/matrix-js-sdk/pull/1055)
- * Upgrade safe deps to latest major version
-   [\#1053](https://github.com/matrix-org/matrix-js-sdk/pull/1053)
- * Don't include .js in the import string.
-   [\#1052](https://github.com/matrix-org/matrix-js-sdk/pull/1052)
-
-Changes in [2.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2) (2019-10-18)
-================================================================================================
+-   fix the path in references to logger.js
+    [\#1056](https://github.com/matrix-org/matrix-js-sdk/pull/1056)
+-   verification in DMs
+    [\#1050](https://github.com/matrix-org/matrix-js-sdk/pull/1050)
+-   Properly documented the function possible returns
+    [\#1054](https://github.com/matrix-org/matrix-js-sdk/pull/1054)
+-   Downgrade to Bluebird 3.5.5 to fix Firefox
+    [\#1055](https://github.com/matrix-org/matrix-js-sdk/pull/1055)
+-   Upgrade safe deps to latest major version
+    [\#1053](https://github.com/matrix-org/matrix-js-sdk/pull/1053)
+-   Don't include .js in the import string.
+    [\#1052](https://github.com/matrix-org/matrix-js-sdk/pull/1052)
+
+# Changes in [2.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2) (2019-10-18)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.2-rc.1...v2.4.2)
 
- * No changes since v2.4.2-rc.1
+-   No changes since v2.4.2-rc.1
+
+# Changes in [2.4.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2-rc.1) (2019-10-09)
 
-Changes in [2.4.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2-rc.1) (2019-10-09)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.1...v2.4.2-rc.1)
 
- * Log state of Olm sessions
-   [\#1047](https://github.com/matrix-org/matrix-js-sdk/pull/1047)
- * Add method to get access to all timelines
-   [\#1048](https://github.com/matrix-org/matrix-js-sdk/pull/1048)
+-   Log state of Olm sessions
+    [\#1047](https://github.com/matrix-org/matrix-js-sdk/pull/1047)
+-   Add method to get access to all timelines
+    [\#1048](https://github.com/matrix-org/matrix-js-sdk/pull/1048)
+
+# Changes in [2.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.1) (2019-10-01)
 
-Changes in [2.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.1) (2019-10-01)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.0...v2.4.1)
 
- * Upgrade deps
-   [\#1046](https://github.com/matrix-org/matrix-js-sdk/pull/1046)
- * Ignore crypto events with no content
-   [\#1043](https://github.com/matrix-org/matrix-js-sdk/pull/1043)
+-   Upgrade deps
+    [\#1046](https://github.com/matrix-org/matrix-js-sdk/pull/1046)
+-   Ignore crypto events with no content
+    [\#1043](https://github.com/matrix-org/matrix-js-sdk/pull/1043)
+
+# Changes in [2.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0) (2019-09-27)
 
-Changes in [2.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0) (2019-09-27)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.0-rc.1...v2.4.0)
 
- * Clean Yarn cache during release
-   [\#1045](https://github.com/matrix-org/matrix-js-sdk/pull/1045)
+-   Clean Yarn cache during release
+    [\#1045](https://github.com/matrix-org/matrix-js-sdk/pull/1045)
+
+# Changes in [2.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0-rc.1) (2019-09-25)
 
-Changes in [2.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0-rc.1) (2019-09-25)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.2...v2.4.0-rc.1)
 
- * Remove id_server from creds for interactive auth
-   [\#1044](https://github.com/matrix-org/matrix-js-sdk/pull/1044)
- * Remove IS details from requestToken to HS
-   [\#1041](https://github.com/matrix-org/matrix-js-sdk/pull/1041)
- * Add support for sending MSISDN tokens to alternate URLs
-   [\#1040](https://github.com/matrix-org/matrix-js-sdk/pull/1040)
- * Add separate 3PID add and bind APIs
-   [\#1038](https://github.com/matrix-org/matrix-js-sdk/pull/1038)
- * Bump eslint-utils from 1.4.0 to 1.4.2
-   [\#1037](https://github.com/matrix-org/matrix-js-sdk/pull/1037)
- * Handle WebRTC security errors as non-fatal
-   [\#1036](https://github.com/matrix-org/matrix-js-sdk/pull/1036)
- * Check for r0.6.0 support in addition to unstable feature flags
-   [\#1035](https://github.com/matrix-org/matrix-js-sdk/pull/1035)
- * Update room members on member event redaction
-   [\#1030](https://github.com/matrix-org/matrix-js-sdk/pull/1030)
- * Support hidden read receipts
-   [\#1028](https://github.com/matrix-org/matrix-js-sdk/pull/1028)
- * Do 3pid lookups in lowercase
-   [\#1029](https://github.com/matrix-org/matrix-js-sdk/pull/1029)
- * Add Synapse admin functions for deactivating a user
-   [\#1027](https://github.com/matrix-org/matrix-js-sdk/pull/1027)
- * Fix addPendingEvent with pending event order == chronological
-   [\#1026](https://github.com/matrix-org/matrix-js-sdk/pull/1026)
- * Add AutoDiscovery.getRawClientConfig() for easy .well-known lookups
-   [\#1024](https://github.com/matrix-org/matrix-js-sdk/pull/1024)
- * Don't convert errors to JSON if they are JSON already
-   [\#1025](https://github.com/matrix-org/matrix-js-sdk/pull/1025)
- * Send id_access_token to HS for use in proxied IS requests
-   [\#1022](https://github.com/matrix-org/matrix-js-sdk/pull/1022)
- * Clean up JSON handling in identity server requests
-   [\#1023](https://github.com/matrix-org/matrix-js-sdk/pull/1023)
- * Use the v2 (hashed) lookup for identity server queries
-   [\#1021](https://github.com/matrix-org/matrix-js-sdk/pull/1021)
- * Add getIdServer() & doesServerRequireIdServerParam()
-   [\#1018](https://github.com/matrix-org/matrix-js-sdk/pull/1018)
- * Make requestToken endpoints work without ID Server
-   [\#1019](https://github.com/matrix-org/matrix-js-sdk/pull/1019)
- * Fix setIdentityServer
-   [\#1016](https://github.com/matrix-org/matrix-js-sdk/pull/1016)
- * Change ICE fallback server and make fallback opt-in
-   [\#1015](https://github.com/matrix-org/matrix-js-sdk/pull/1015)
- * Throw an exception if trying to do an ID server request with no ID server
-   [\#1014](https://github.com/matrix-org/matrix-js-sdk/pull/1014)
- * Add setIdentityServerUrl
-   [\#1013](https://github.com/matrix-org/matrix-js-sdk/pull/1013)
- * Add matrix base API to report an event
-   [\#1011](https://github.com/matrix-org/matrix-js-sdk/pull/1011)
- * Fix POST body for v2 IS requests
-   [\#1010](https://github.com/matrix-org/matrix-js-sdk/pull/1010)
- * Add API for bulk lookup on the Identity Server
-   [\#1009](https://github.com/matrix-org/matrix-js-sdk/pull/1009)
- * Remove deprecated authedRequestWithPrefix and requestWithPrefix
-   [\#1000](https://github.com/matrix-org/matrix-js-sdk/pull/1000)
- * Add API for checking IS account info
-   [\#1007](https://github.com/matrix-org/matrix-js-sdk/pull/1007)
- * Support rewriting push rules when our internal defaults change
-   [\#1006](https://github.com/matrix-org/matrix-js-sdk/pull/1006)
- * Upgrade dependencies
-   [\#1005](https://github.com/matrix-org/matrix-js-sdk/pull/1005)
-
-Changes in [2.3.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2) (2019-09-16)
-================================================================================================
+-   Remove id_server from creds for interactive auth
+    [\#1044](https://github.com/matrix-org/matrix-js-sdk/pull/1044)
+-   Remove IS details from requestToken to HS
+    [\#1041](https://github.com/matrix-org/matrix-js-sdk/pull/1041)
+-   Add support for sending MSISDN tokens to alternate URLs
+    [\#1040](https://github.com/matrix-org/matrix-js-sdk/pull/1040)
+-   Add separate 3PID add and bind APIs
+    [\#1038](https://github.com/matrix-org/matrix-js-sdk/pull/1038)
+-   Bump eslint-utils from 1.4.0 to 1.4.2
+    [\#1037](https://github.com/matrix-org/matrix-js-sdk/pull/1037)
+-   Handle WebRTC security errors as non-fatal
+    [\#1036](https://github.com/matrix-org/matrix-js-sdk/pull/1036)
+-   Check for r0.6.0 support in addition to unstable feature flags
+    [\#1035](https://github.com/matrix-org/matrix-js-sdk/pull/1035)
+-   Update room members on member event redaction
+    [\#1030](https://github.com/matrix-org/matrix-js-sdk/pull/1030)
+-   Support hidden read receipts
+    [\#1028](https://github.com/matrix-org/matrix-js-sdk/pull/1028)
+-   Do 3pid lookups in lowercase
+    [\#1029](https://github.com/matrix-org/matrix-js-sdk/pull/1029)
+-   Add Synapse admin functions for deactivating a user
+    [\#1027](https://github.com/matrix-org/matrix-js-sdk/pull/1027)
+-   Fix addPendingEvent with pending event order == chronological
+    [\#1026](https://github.com/matrix-org/matrix-js-sdk/pull/1026)
+-   Add AutoDiscovery.getRawClientConfig() for easy .well-known lookups
+    [\#1024](https://github.com/matrix-org/matrix-js-sdk/pull/1024)
+-   Don't convert errors to JSON if they are JSON already
+    [\#1025](https://github.com/matrix-org/matrix-js-sdk/pull/1025)
+-   Send id_access_token to HS for use in proxied IS requests
+    [\#1022](https://github.com/matrix-org/matrix-js-sdk/pull/1022)
+-   Clean up JSON handling in identity server requests
+    [\#1023](https://github.com/matrix-org/matrix-js-sdk/pull/1023)
+-   Use the v2 (hashed) lookup for identity server queries
+    [\#1021](https://github.com/matrix-org/matrix-js-sdk/pull/1021)
+-   Add getIdServer() & doesServerRequireIdServerParam()
+    [\#1018](https://github.com/matrix-org/matrix-js-sdk/pull/1018)
+-   Make requestToken endpoints work without ID Server
+    [\#1019](https://github.com/matrix-org/matrix-js-sdk/pull/1019)
+-   Fix setIdentityServer
+    [\#1016](https://github.com/matrix-org/matrix-js-sdk/pull/1016)
+-   Change ICE fallback server and make fallback opt-in
+    [\#1015](https://github.com/matrix-org/matrix-js-sdk/pull/1015)
+-   Throw an exception if trying to do an ID server request with no ID server
+    [\#1014](https://github.com/matrix-org/matrix-js-sdk/pull/1014)
+-   Add setIdentityServerUrl
+    [\#1013](https://github.com/matrix-org/matrix-js-sdk/pull/1013)
+-   Add matrix base API to report an event
+    [\#1011](https://github.com/matrix-org/matrix-js-sdk/pull/1011)
+-   Fix POST body for v2 IS requests
+    [\#1010](https://github.com/matrix-org/matrix-js-sdk/pull/1010)
+-   Add API for bulk lookup on the Identity Server
+    [\#1009](https://github.com/matrix-org/matrix-js-sdk/pull/1009)
+-   Remove deprecated authedRequestWithPrefix and requestWithPrefix
+    [\#1000](https://github.com/matrix-org/matrix-js-sdk/pull/1000)
+-   Add API for checking IS account info
+    [\#1007](https://github.com/matrix-org/matrix-js-sdk/pull/1007)
+-   Support rewriting push rules when our internal defaults change
+    [\#1006](https://github.com/matrix-org/matrix-js-sdk/pull/1006)
+-   Upgrade dependencies
+    [\#1005](https://github.com/matrix-org/matrix-js-sdk/pull/1005)
+
+# Changes in [2.3.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2) (2019-09-16)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.2-rc.1...v2.3.2)
 
- * [Release] Fix addPendingEvent with pending event order == chronological
-   [\#1034](https://github.com/matrix-org/matrix-js-sdk/pull/1034)
+-   [Release] Fix addPendingEvent with pending event order == chronological
+    [\#1034](https://github.com/matrix-org/matrix-js-sdk/pull/1034)
+
+# Changes in [2.3.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2-rc.1) (2019-09-13)
 
-Changes in [2.3.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2-rc.1) (2019-09-13)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.1...v2.3.2-rc.1)
 
- * Synapse admin functions to release
-   [\#1033](https://github.com/matrix-org/matrix-js-sdk/pull/1033)
- * [To Release] Add matrix base API to report an event
-   [\#1032](https://github.com/matrix-org/matrix-js-sdk/pull/1032)
+-   Synapse admin functions to release
+    [\#1033](https://github.com/matrix-org/matrix-js-sdk/pull/1033)
+-   [To Release] Add matrix base API to report an event
+    [\#1032](https://github.com/matrix-org/matrix-js-sdk/pull/1032)
+
+# Changes in [2.3.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1) (2019-09-12)
 
-Changes in [2.3.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1) (2019-09-12)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.1-rc.1...v2.3.1)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [2.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1-rc.1) (2019-09-11)
 
-Changes in [2.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1-rc.1) (2019-09-11)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.0...v2.3.1-rc.1)
 
- * Update room members on member event redaction
-   [\#1031](https://github.com/matrix-org/matrix-js-sdk/pull/1031)
+-   Update room members on member event redaction
+    [\#1031](https://github.com/matrix-org/matrix-js-sdk/pull/1031)
+
+# Changes in [2.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0) (2019-08-05)
 
-Changes in [2.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0) (2019-08-05)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.0-rc.1...v2.3.0)
 
- * [release] Support rewriting push rules when our internal defaults change
-   [\#1008](https://github.com/matrix-org/matrix-js-sdk/pull/1008)
+-   [release] Support rewriting push rules when our internal defaults change
+    [\#1008](https://github.com/matrix-org/matrix-js-sdk/pull/1008)
+
+# Changes in [2.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0-rc.1) (2019-07-31)
 
-Changes in [2.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0-rc.1) (2019-07-31)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.2.0...v2.3.0-rc.1)
 
- * Add support for IS v2 API with authentication
-   [\#1002](https://github.com/matrix-org/matrix-js-sdk/pull/1002)
- * Tombstone bugfixes
-   [\#1001](https://github.com/matrix-org/matrix-js-sdk/pull/1001)
- * Support for MSC2140 (terms of service for IS/IM)
-   [\#988](https://github.com/matrix-org/matrix-js-sdk/pull/988)
- * Add a request method to /devices
-   [\#994](https://github.com/matrix-org/matrix-js-sdk/pull/994)
-
-Changes in [2.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0) (2019-07-18)
-================================================================================================
+-   Add support for IS v2 API with authentication
+    [\#1002](https://github.com/matrix-org/matrix-js-sdk/pull/1002)
+-   Tombstone bugfixes
+    [\#1001](https://github.com/matrix-org/matrix-js-sdk/pull/1001)
+-   Support for MSC2140 (terms of service for IS/IM)
+    [\#988](https://github.com/matrix-org/matrix-js-sdk/pull/988)
+-   Add a request method to /devices
+    [\#994](https://github.com/matrix-org/matrix-js-sdk/pull/994)
+
+# Changes in [2.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0) (2019-07-18)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.2.0-rc.2...v2.2.0)
 
- * Upgrade lodash dependencies
+-   Upgrade lodash dependencies
+
+# Changes in [2.2.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.2) (2019-07-12)
 
-Changes in [2.2.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.2) (2019-07-12)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.2.0-rc.1...v2.2.0-rc.2)
 
- * Fix regression from 2.2.0-rc.1 in request to /devices
-   [\#995](https://github.com/matrix-org/matrix-js-sdk/pull/995)
+-   Fix regression from 2.2.0-rc.1 in request to /devices
+    [\#995](https://github.com/matrix-org/matrix-js-sdk/pull/995)
+
+# Changes in [2.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.1) (2019-07-12)
 
-Changes in [2.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.1) (2019-07-12)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.1.1...v2.2.0-rc.1)
 
- * End the verification timer when verification is done
-   [\#993](https://github.com/matrix-org/matrix-js-sdk/pull/993)
- * Stabilize usage of stably stable APIs (in a stable way)
-   [\#990](https://github.com/matrix-org/matrix-js-sdk/pull/990)
- * Expose original_event for /relations
-   [\#987](https://github.com/matrix-org/matrix-js-sdk/pull/987)
- * Process ephemeral events outside timeline handling
-   [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
- * Don't accept any locally known edits earlier than the last known server-side
-   aggregated edit
-   [\#986](https://github.com/matrix-org/matrix-js-sdk/pull/986)
- * Get edit date transparently from server aggregations or local echo
-   [\#984](https://github.com/matrix-org/matrix-js-sdk/pull/984)
- * Add a function to flag keys for backup without scheduling a backup
-   [\#982](https://github.com/matrix-org/matrix-js-sdk/pull/982)
- * Block read marker and read receipt from advancing into pending events
-   [\#981](https://github.com/matrix-org/matrix-js-sdk/pull/981)
- * Upgrade dependencies
-   [\#977](https://github.com/matrix-org/matrix-js-sdk/pull/977)
- * Add default push rule to ignore reactions
-   [\#976](https://github.com/matrix-org/matrix-js-sdk/pull/976)
- * Fix exception whilst syncing
-   [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
- * Include the error object when raising Session.logged_out
-   [\#975](https://github.com/matrix-org/matrix-js-sdk/pull/975)
-
-Changes in [2.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.1) (2019-07-11)
-================================================================================================
+-   End the verification timer when verification is done
+    [\#993](https://github.com/matrix-org/matrix-js-sdk/pull/993)
+-   Stabilize usage of stably stable APIs (in a stable way)
+    [\#990](https://github.com/matrix-org/matrix-js-sdk/pull/990)
+-   Expose original_event for /relations
+    [\#987](https://github.com/matrix-org/matrix-js-sdk/pull/987)
+-   Process ephemeral events outside timeline handling
+    [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
+-   Don't accept any locally known edits earlier than the last known server-side
+    aggregated edit
+    [\#986](https://github.com/matrix-org/matrix-js-sdk/pull/986)
+-   Get edit date transparently from server aggregations or local echo
+    [\#984](https://github.com/matrix-org/matrix-js-sdk/pull/984)
+-   Add a function to flag keys for backup without scheduling a backup
+    [\#982](https://github.com/matrix-org/matrix-js-sdk/pull/982)
+-   Block read marker and read receipt from advancing into pending events
+    [\#981](https://github.com/matrix-org/matrix-js-sdk/pull/981)
+-   Upgrade dependencies
+    [\#977](https://github.com/matrix-org/matrix-js-sdk/pull/977)
+-   Add default push rule to ignore reactions
+    [\#976](https://github.com/matrix-org/matrix-js-sdk/pull/976)
+-   Fix exception whilst syncing
+    [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
+-   Include the error object when raising Session.logged_out
+    [\#975](https://github.com/matrix-org/matrix-js-sdk/pull/975)
+
+# Changes in [2.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.1) (2019-07-11)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.1.0...v2.1.1)
 
- * Process emphemeral events outside timeline handling
-   [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
+-   Process emphemeral events outside timeline handling
+    [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
+
+# Changes in [2.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0) (2019-07-08)
 
-Changes in [2.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0) (2019-07-08)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.1.0-rc.1...v2.1.0)
 
- * Fix exception whilst syncing
-   [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
+-   Fix exception whilst syncing
+    [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
+
+# Changes in [2.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0-rc.1) (2019-07-03)
 
-Changes in [2.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0-rc.1) (2019-07-03)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.1...v2.1.0-rc.1)
 
- * Handle self read receipts for fixing e2e notification counts
-   [\#974](https://github.com/matrix-org/matrix-js-sdk/pull/974)
- * Add redacts field to event.toJSON
-   [\#973](https://github.com/matrix-org/matrix-js-sdk/pull/973)
- * Handle associated event send failures
-   [\#972](https://github.com/matrix-org/matrix-js-sdk/pull/972)
- * Remove irrelevant debug line from timeline handling
-   [\#971](https://github.com/matrix-org/matrix-js-sdk/pull/971)
- * Handle relations in encrypted rooms
-   [\#969](https://github.com/matrix-org/matrix-js-sdk/pull/969)
- * Relations endpoint support
-   [\#967](https://github.com/matrix-org/matrix-js-sdk/pull/967)
- * Disable event encryption for reactions
-   [\#968](https://github.com/matrix-org/matrix-js-sdk/pull/968)
- * Change the known safe room version to version 4
-   [\#966](https://github.com/matrix-org/matrix-js-sdk/pull/966)
- * Check for lazy-loading support in the spec versions instead
-   [\#965](https://github.com/matrix-org/matrix-js-sdk/pull/965)
- * Use camelCase instead of underscore
-   [\#963](https://github.com/matrix-org/matrix-js-sdk/pull/963)
- * Time out verification attempts after 10 minutes of inactivity
-   [\#961](https://github.com/matrix-org/matrix-js-sdk/pull/961)
- * Don't handle key verification requests which are immediately cancelled
-   [\#962](https://github.com/matrix-org/matrix-js-sdk/pull/962)
-
-Changes in [2.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1) (2019-06-19)
-================================================================================================
+-   Handle self read receipts for fixing e2e notification counts
+    [\#974](https://github.com/matrix-org/matrix-js-sdk/pull/974)
+-   Add redacts field to event.toJSON
+    [\#973](https://github.com/matrix-org/matrix-js-sdk/pull/973)
+-   Handle associated event send failures
+    [\#972](https://github.com/matrix-org/matrix-js-sdk/pull/972)
+-   Remove irrelevant debug line from timeline handling
+    [\#971](https://github.com/matrix-org/matrix-js-sdk/pull/971)
+-   Handle relations in encrypted rooms
+    [\#969](https://github.com/matrix-org/matrix-js-sdk/pull/969)
+-   Relations endpoint support
+    [\#967](https://github.com/matrix-org/matrix-js-sdk/pull/967)
+-   Disable event encryption for reactions
+    [\#968](https://github.com/matrix-org/matrix-js-sdk/pull/968)
+-   Change the known safe room version to version 4
+    [\#966](https://github.com/matrix-org/matrix-js-sdk/pull/966)
+-   Check for lazy-loading support in the spec versions instead
+    [\#965](https://github.com/matrix-org/matrix-js-sdk/pull/965)
+-   Use camelCase instead of underscore
+    [\#963](https://github.com/matrix-org/matrix-js-sdk/pull/963)
+-   Time out verification attempts after 10 minutes of inactivity
+    [\#961](https://github.com/matrix-org/matrix-js-sdk/pull/961)
+-   Don't handle key verification requests which are immediately cancelled
+    [\#962](https://github.com/matrix-org/matrix-js-sdk/pull/962)
+
+# Changes in [2.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1) (2019-06-19)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.1-rc.2...v2.0.1)
 
- No changes since rc.2
+No changes since rc.2
+
+# Changes in [2.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.2) (2019-06-18)
 
-Changes in [2.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.2) (2019-06-18)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.1-rc.1...v2.0.1-rc.2)
 
- * return 'sending' status for an event that is only locally redacted
-   [\#960](https://github.com/matrix-org/matrix-js-sdk/pull/960)
- * Key verification request fixes
-   [\#954](https://github.com/matrix-org/matrix-js-sdk/pull/954)
- * Add flag to force saving sync store
-   [\#956](https://github.com/matrix-org/matrix-js-sdk/pull/956)
- * Expose the inhibit_login flag to register
-   [\#953](https://github.com/matrix-org/matrix-js-sdk/pull/953)
- *  Support redactions and relations of/with unsent events.
-   [\#947](https://github.com/matrix-org/matrix-js-sdk/pull/947)
-
-Changes in [2.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.1) (2019-06-12)
-==========================================================================================================
+-   return 'sending' status for an event that is only locally redacted
+    [\#960](https://github.com/matrix-org/matrix-js-sdk/pull/960)
+-   Key verification request fixes
+    [\#954](https://github.com/matrix-org/matrix-js-sdk/pull/954)
+-   Add flag to force saving sync store
+    [\#956](https://github.com/matrix-org/matrix-js-sdk/pull/956)
+-   Expose the inhibit_login flag to register
+    [\#953](https://github.com/matrix-org/matrix-js-sdk/pull/953)
+-   Support redactions and relations of/with unsent events.
+    [\#947](https://github.com/matrix-org/matrix-js-sdk/pull/947)
+
+# Changes in [2.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.1) (2019-06-12)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.0...v2.0.1-rc.1)
 
- * Fix content uploads for modern browsers
-   [\#952](https://github.com/matrix-org/matrix-js-sdk/pull/952)
- * Don't overlap auth submissions with polls
-   [\#951](https://github.com/matrix-org/matrix-js-sdk/pull/951)
- * Add funding details for GitHub sponsor button
-   [\#945](https://github.com/matrix-org/matrix-js-sdk/pull/945)
- * Fix backup sig validation with multiple sigs
-   [\#944](https://github.com/matrix-org/matrix-js-sdk/pull/944)
- * Don't send another token request while one's in flight
-   [\#943](https://github.com/matrix-org/matrix-js-sdk/pull/943)
- * Don't poll UI auth again until current poll finishes
-   [\#942](https://github.com/matrix-org/matrix-js-sdk/pull/942)
- * Provide the discovered URLs when a liveliness error occurs
-   [\#938](https://github.com/matrix-org/matrix-js-sdk/pull/938)
- * Encode event IDs when redacting events
-   [\#941](https://github.com/matrix-org/matrix-js-sdk/pull/941)
- * add missing logger
-   [\#940](https://github.com/matrix-org/matrix-js-sdk/pull/940)
- * verification: don't error if we don't know about some keys
-   [\#939](https://github.com/matrix-org/matrix-js-sdk/pull/939)
- * Local echo for redactions
-   [\#937](https://github.com/matrix-org/matrix-js-sdk/pull/937)
- * Refresh safe room versions when the server looks more modern than us
-   [\#934](https://github.com/matrix-org/matrix-js-sdk/pull/934)
- * Add v4 as a safe room version
-   [\#935](https://github.com/matrix-org/matrix-js-sdk/pull/935)
- * Disable guard-for-in rule
-   [\#933](https://github.com/matrix-org/matrix-js-sdk/pull/933)
- * Extend loglevel logging for the whole project
-   [\#924](https://github.com/matrix-org/matrix-js-sdk/pull/924)
- * fix(login): saves access_token and user_id after login for all login types
-   [\#930](https://github.com/matrix-org/matrix-js-sdk/pull/930)
- * Do not try to request thumbnails with non-integer sizes
-   [\#929](https://github.com/matrix-org/matrix-js-sdk/pull/929)
- * Revert "Add a bunch of debugging to .well-known IS validation"
-   [\#928](https://github.com/matrix-org/matrix-js-sdk/pull/928)
- * Add a bunch of debugging to .well-known IS validation
-   [\#927](https://github.com/matrix-org/matrix-js-sdk/pull/927)
-
-Changes in [2.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.0) (2019-05-31)
-================================================================================================
+-   Fix content uploads for modern browsers
+    [\#952](https://github.com/matrix-org/matrix-js-sdk/pull/952)
+-   Don't overlap auth submissions with polls
+    [\#951](https://github.com/matrix-org/matrix-js-sdk/pull/951)
+-   Add funding details for GitHub sponsor button
+    [\#945](https://github.com/matrix-org/matrix-js-sdk/pull/945)
+-   Fix backup sig validation with multiple sigs
+    [\#944](https://github.com/matrix-org/matrix-js-sdk/pull/944)
+-   Don't send another token request while one's in flight
+    [\#943](https://github.com/matrix-org/matrix-js-sdk/pull/943)
+-   Don't poll UI auth again until current poll finishes
+    [\#942](https://github.com/matrix-org/matrix-js-sdk/pull/942)
+-   Provide the discovered URLs when a liveliness error occurs
+    [\#938](https://github.com/matrix-org/matrix-js-sdk/pull/938)
+-   Encode event IDs when redacting events
+    [\#941](https://github.com/matrix-org/matrix-js-sdk/pull/941)
+-   add missing logger
+    [\#940](https://github.com/matrix-org/matrix-js-sdk/pull/940)
+-   verification: don't error if we don't know about some keys
+    [\#939](https://github.com/matrix-org/matrix-js-sdk/pull/939)
+-   Local echo for redactions
+    [\#937](https://github.com/matrix-org/matrix-js-sdk/pull/937)
+-   Refresh safe room versions when the server looks more modern than us
+    [\#934](https://github.com/matrix-org/matrix-js-sdk/pull/934)
+-   Add v4 as a safe room version
+    [\#935](https://github.com/matrix-org/matrix-js-sdk/pull/935)
+-   Disable guard-for-in rule
+    [\#933](https://github.com/matrix-org/matrix-js-sdk/pull/933)
+-   Extend loglevel logging for the whole project
+    [\#924](https://github.com/matrix-org/matrix-js-sdk/pull/924)
+-   fix(login): saves access_token and user_id after login for all login types
+    [\#930](https://github.com/matrix-org/matrix-js-sdk/pull/930)
+-   Do not try to request thumbnails with non-integer sizes
+    [\#929](https://github.com/matrix-org/matrix-js-sdk/pull/929)
+-   Revert "Add a bunch of debugging to .well-known IS validation"
+    [\#928](https://github.com/matrix-org/matrix-js-sdk/pull/928)
+-   Add a bunch of debugging to .well-known IS validation
+    [\#927](https://github.com/matrix-org/matrix-js-sdk/pull/927)
+
+# Changes in [2.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.0) (2019-05-31)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.2.0...v2.0.0)
 
-BREAKING CHANGES
-----------------
+## BREAKING CHANGES
+
+-   This package now publishes in ES6 / ES2015 syntax to NPM
+-   Saves access_token and user_id after login for all login types
+    [\#932](https://github.com/matrix-org/matrix-js-sdk/pull/932)
+-   Fix recovery key encoding for base-x 3.0.5
+    [\#931](https://github.com/matrix-org/matrix-js-sdk/pull/931)
 
- * This package now publishes in ES6 / ES2015 syntax to NPM
- * Saves access_token and user_id after login for all login types
-   [\#932](https://github.com/matrix-org/matrix-js-sdk/pull/932)
- * Fix recovery key encoding for base-x 3.0.5
-   [\#931](https://github.com/matrix-org/matrix-js-sdk/pull/931)
+# Changes in [1.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0) (2019-05-29)
 
-Changes in [1.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0) (2019-05-29)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.2.0-rc.1...v1.2.0)
 
+# Changes in [1.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0-rc.1) (2019-05-23)
 
-Changes in [1.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0-rc.1) (2019-05-23)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.1.0...v1.2.0-rc.1)
 
- * interactive-auth now handles requesting email tokens
-   [\#926](https://github.com/matrix-org/matrix-js-sdk/pull/926)
- * allow access to unreplaced message content
-   [\#923](https://github.com/matrix-org/matrix-js-sdk/pull/923)
- * Add method to retrieve replacing event
-   [\#922](https://github.com/matrix-org/matrix-js-sdk/pull/922)
- * More logging when signature verification fails
-   [\#921](https://github.com/matrix-org/matrix-js-sdk/pull/921)
- * Local echo for m.replace relations
-   [\#920](https://github.com/matrix-org/matrix-js-sdk/pull/920)
- * Track relations as pending and remove when cancelled
-   [\#919](https://github.com/matrix-org/matrix-js-sdk/pull/919)
- * Add stringify helper to summarise events when debugging
-   [\#916](https://github.com/matrix-org/matrix-js-sdk/pull/916)
- * Message editing: filter out replacements for senders that are not the
-   original sender
-   [\#918](https://github.com/matrix-org/matrix-js-sdk/pull/918)
- * Wait until decrypt before aggregating
-   [\#917](https://github.com/matrix-org/matrix-js-sdk/pull/917)
- * Message editing: mark original event as replaced instead of replacing the
-   event object
-   [\#914](https://github.com/matrix-org/matrix-js-sdk/pull/914)
- * Support for replacing message through m.replace relationship.
-   [\#913](https://github.com/matrix-org/matrix-js-sdk/pull/913)
- * Use a short timeout for .well-known requests
-   [\#912](https://github.com/matrix-org/matrix-js-sdk/pull/912)
- * Redaction and change events for relations
-   [\#911](https://github.com/matrix-org/matrix-js-sdk/pull/911)
- * Add basic read path for relations
-   [\#910](https://github.com/matrix-org/matrix-js-sdk/pull/910)
- * Add a concept of default push rules, using it for tombstone notifications
-   [\#860](https://github.com/matrix-org/matrix-js-sdk/pull/860)
- * yarn upgrade
-   [\#907](https://github.com/matrix-org/matrix-js-sdk/pull/907)
-
-Changes in [1.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0) (2019-05-07)
-================================================================================================
+-   interactive-auth now handles requesting email tokens
+    [\#926](https://github.com/matrix-org/matrix-js-sdk/pull/926)
+-   allow access to unreplaced message content
+    [\#923](https://github.com/matrix-org/matrix-js-sdk/pull/923)
+-   Add method to retrieve replacing event
+    [\#922](https://github.com/matrix-org/matrix-js-sdk/pull/922)
+-   More logging when signature verification fails
+    [\#921](https://github.com/matrix-org/matrix-js-sdk/pull/921)
+-   Local echo for m.replace relations
+    [\#920](https://github.com/matrix-org/matrix-js-sdk/pull/920)
+-   Track relations as pending and remove when cancelled
+    [\#919](https://github.com/matrix-org/matrix-js-sdk/pull/919)
+-   Add stringify helper to summarise events when debugging
+    [\#916](https://github.com/matrix-org/matrix-js-sdk/pull/916)
+-   Message editing: filter out replacements for senders that are not the
+    original sender
+    [\#918](https://github.com/matrix-org/matrix-js-sdk/pull/918)
+-   Wait until decrypt before aggregating
+    [\#917](https://github.com/matrix-org/matrix-js-sdk/pull/917)
+-   Message editing: mark original event as replaced instead of replacing the
+    event object
+    [\#914](https://github.com/matrix-org/matrix-js-sdk/pull/914)
+-   Support for replacing message through m.replace relationship.
+    [\#913](https://github.com/matrix-org/matrix-js-sdk/pull/913)
+-   Use a short timeout for .well-known requests
+    [\#912](https://github.com/matrix-org/matrix-js-sdk/pull/912)
+-   Redaction and change events for relations
+    [\#911](https://github.com/matrix-org/matrix-js-sdk/pull/911)
+-   Add basic read path for relations
+    [\#910](https://github.com/matrix-org/matrix-js-sdk/pull/910)
+-   Add a concept of default push rules, using it for tombstone notifications
+    [\#860](https://github.com/matrix-org/matrix-js-sdk/pull/860)
+-   yarn upgrade
+    [\#907](https://github.com/matrix-org/matrix-js-sdk/pull/907)
+
+# Changes in [1.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0) (2019-05-07)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.1.0-rc.1...v1.1.0)
 
- * No Changes since rc.1
+-   No Changes since rc.1
+
+# Changes in [1.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0-rc.1) (2019-04-30)
 
-Changes in [1.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0-rc.1) (2019-04-30)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.4...v1.1.0-rc.1)
 
- * use the release version of olm 3.1.0
-   [\#903](https://github.com/matrix-org/matrix-js-sdk/pull/903)
- * Use new Olm repo link in README
-   [\#901](https://github.com/matrix-org/matrix-js-sdk/pull/901)
- * Support being fed a .well-known config object for validation
-   [\#897](https://github.com/matrix-org/matrix-js-sdk/pull/897)
- * emit self-membership event at end of handling sync update
-   [\#900](https://github.com/matrix-org/matrix-js-sdk/pull/900)
- * Use packages.matrix.org for Olm
-   [\#898](https://github.com/matrix-org/matrix-js-sdk/pull/898)
- * Fix tests on develop
-   [\#899](https://github.com/matrix-org/matrix-js-sdk/pull/899)
- * Stop syncing when the token is invalid
-   [\#895](https://github.com/matrix-org/matrix-js-sdk/pull/895)
- * change event redact,  POST request to PUT request
-   [\#887](https://github.com/matrix-org/matrix-js-sdk/pull/887)
- * Expose better autodiscovery error messages
-   [\#894](https://github.com/matrix-org/matrix-js-sdk/pull/894)
- * Explicitly guard store usage during sync startup
-   [\#892](https://github.com/matrix-org/matrix-js-sdk/pull/892)
- * Flag v3 rooms as safe
-   [\#893](https://github.com/matrix-org/matrix-js-sdk/pull/893)
- * Cache failed capabilities lookups for shorter amounts of time
-   [\#890](https://github.com/matrix-org/matrix-js-sdk/pull/890)
- * Fix highlight notifications for unencrypted rooms
-   [\#891](https://github.com/matrix-org/matrix-js-sdk/pull/891)
- * Document checking crypto state before using `hasUnverifiedDevices`
-   [\#889](https://github.com/matrix-org/matrix-js-sdk/pull/889)
- * Add logging to sync startup path
-   [\#888](https://github.com/matrix-org/matrix-js-sdk/pull/888)
- * Track e2e highlights better, particularly in 'Mentions Only' rooms
-   [\#886](https://github.com/matrix-org/matrix-js-sdk/pull/886)
- * support both the incorrect and correct MAC methods
-   [\#882](https://github.com/matrix-org/matrix-js-sdk/pull/882)
- * Refuse to set forwards pagination token on live timeline
-   [\#885](https://github.com/matrix-org/matrix-js-sdk/pull/885)
- * Degrade `IndexedDBStore` back to memory only on failure
-   [\#884](https://github.com/matrix-org/matrix-js-sdk/pull/884)
- * Refuse to link live timelines into the forwards/backwards position when
-   either is invalid
-   [\#877](https://github.com/matrix-org/matrix-js-sdk/pull/877)
- * Key backup logging improvements
-   [\#883](https://github.com/matrix-org/matrix-js-sdk/pull/883)
- * Don't assume aborts are always from txn.abort()
-   [\#880](https://github.com/matrix-org/matrix-js-sdk/pull/880)
- * Add a bunch of logging
-   [\#878](https://github.com/matrix-org/matrix-js-sdk/pull/878)
- * Refuse splicing the live timeline into a broken position
-   [\#873](https://github.com/matrix-org/matrix-js-sdk/pull/873)
- * Add existence check to local storage based crypto store
-   [\#872](https://github.com/matrix-org/matrix-js-sdk/pull/872)
-
-Changes in [1.0.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.4) (2019-04-08)
-================================================================================================
+-   use the release version of olm 3.1.0
+    [\#903](https://github.com/matrix-org/matrix-js-sdk/pull/903)
+-   Use new Olm repo link in README
+    [\#901](https://github.com/matrix-org/matrix-js-sdk/pull/901)
+-   Support being fed a .well-known config object for validation
+    [\#897](https://github.com/matrix-org/matrix-js-sdk/pull/897)
+-   emit self-membership event at end of handling sync update
+    [\#900](https://github.com/matrix-org/matrix-js-sdk/pull/900)
+-   Use packages.matrix.org for Olm
+    [\#898](https://github.com/matrix-org/matrix-js-sdk/pull/898)
+-   Fix tests on develop
+    [\#899](https://github.com/matrix-org/matrix-js-sdk/pull/899)
+-   Stop syncing when the token is invalid
+    [\#895](https://github.com/matrix-org/matrix-js-sdk/pull/895)
+-   change event redact, POST request to PUT request
+    [\#887](https://github.com/matrix-org/matrix-js-sdk/pull/887)
+-   Expose better autodiscovery error messages
+    [\#894](https://github.com/matrix-org/matrix-js-sdk/pull/894)
+-   Explicitly guard store usage during sync startup
+    [\#892](https://github.com/matrix-org/matrix-js-sdk/pull/892)
+-   Flag v3 rooms as safe
+    [\#893](https://github.com/matrix-org/matrix-js-sdk/pull/893)
+-   Cache failed capabilities lookups for shorter amounts of time
+    [\#890](https://github.com/matrix-org/matrix-js-sdk/pull/890)
+-   Fix highlight notifications for unencrypted rooms
+    [\#891](https://github.com/matrix-org/matrix-js-sdk/pull/891)
+-   Document checking crypto state before using `hasUnverifiedDevices`
+    [\#889](https://github.com/matrix-org/matrix-js-sdk/pull/889)
+-   Add logging to sync startup path
+    [\#888](https://github.com/matrix-org/matrix-js-sdk/pull/888)
+-   Track e2e highlights better, particularly in 'Mentions Only' rooms
+    [\#886](https://github.com/matrix-org/matrix-js-sdk/pull/886)
+-   support both the incorrect and correct MAC methods
+    [\#882](https://github.com/matrix-org/matrix-js-sdk/pull/882)
+-   Refuse to set forwards pagination token on live timeline
+    [\#885](https://github.com/matrix-org/matrix-js-sdk/pull/885)
+-   Degrade `IndexedDBStore` back to memory only on failure
+    [\#884](https://github.com/matrix-org/matrix-js-sdk/pull/884)
+-   Refuse to link live timelines into the forwards/backwards position when
+    either is invalid
+    [\#877](https://github.com/matrix-org/matrix-js-sdk/pull/877)
+-   Key backup logging improvements
+    [\#883](https://github.com/matrix-org/matrix-js-sdk/pull/883)
+-   Don't assume aborts are always from txn.abort()
+    [\#880](https://github.com/matrix-org/matrix-js-sdk/pull/880)
+-   Add a bunch of logging
+    [\#878](https://github.com/matrix-org/matrix-js-sdk/pull/878)
+-   Refuse splicing the live timeline into a broken position
+    [\#873](https://github.com/matrix-org/matrix-js-sdk/pull/873)
+-   Add existence check to local storage based crypto store
+    [\#872](https://github.com/matrix-org/matrix-js-sdk/pull/872)
+
+# Changes in [1.0.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.4) (2019-04-08)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.3...v1.0.4)
 
- * Hotfix: more logging and potential fixes for timeline corruption issue, see ticket https://github.com/vector-im/riot-web/issues/8593.
+-   Hotfix: more logging and potential fixes for timeline corruption issue, see ticket https://github.com/vector-im/riot-web/issues/8593.
+
+# Changes in [1.0.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3) (2019-04-01)
 
-Changes in [1.0.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3) (2019-04-01)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.3-rc.1...v1.0.3)
 
- * Add existence check to local storage based crypto store
-   [\#874](https://github.com/matrix-org/matrix-js-sdk/pull/874)
+-   Add existence check to local storage based crypto store
+    [\#874](https://github.com/matrix-org/matrix-js-sdk/pull/874)
+
+# Changes in [1.0.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3-rc.1) (2019-03-27)
 
-Changes in [1.0.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3-rc.1) (2019-03-27)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.2...v1.0.3-rc.1)
 
- * Add IndexedDB existence checks
-   [\#871](https://github.com/matrix-org/matrix-js-sdk/pull/871)
- * Emit sync errors for capturing by clients
-   [\#869](https://github.com/matrix-org/matrix-js-sdk/pull/869)
- * Add functions for getting room upgrade history and leaving those rooms
-   [\#868](https://github.com/matrix-org/matrix-js-sdk/pull/868)
- * Clarify the meaning of 'real name' for contribution
-   [\#867](https://github.com/matrix-org/matrix-js-sdk/pull/867)
- * Remove `sessionStore` to `cryptoStore` migration path
-   [\#865](https://github.com/matrix-org/matrix-js-sdk/pull/865)
- * Add debugging for spurious room version warnings
-   [\#866](https://github.com/matrix-org/matrix-js-sdk/pull/866)
- * Add investigation notes for browser storage
-   [\#864](https://github.com/matrix-org/matrix-js-sdk/pull/864)
- * make sure resolve object is defined before calling it
-   [\#862](https://github.com/matrix-org/matrix-js-sdk/pull/862)
- * Rename `MatrixInMemoryStore` to `MemoryStore`
-   [\#861](https://github.com/matrix-org/matrix-js-sdk/pull/861)
- * Use Buildkite for CI
-   [\#859](https://github.com/matrix-org/matrix-js-sdk/pull/859)
- * only create one session at a time per device
-   [\#857](https://github.com/matrix-org/matrix-js-sdk/pull/857)
-
-Changes in [1.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2) (2019-03-18)
-================================================================================================
+-   Add IndexedDB existence checks
+    [\#871](https://github.com/matrix-org/matrix-js-sdk/pull/871)
+-   Emit sync errors for capturing by clients
+    [\#869](https://github.com/matrix-org/matrix-js-sdk/pull/869)
+-   Add functions for getting room upgrade history and leaving those rooms
+    [\#868](https://github.com/matrix-org/matrix-js-sdk/pull/868)
+-   Clarify the meaning of 'real name' for contribution
+    [\#867](https://github.com/matrix-org/matrix-js-sdk/pull/867)
+-   Remove `sessionStore` to `cryptoStore` migration path
+    [\#865](https://github.com/matrix-org/matrix-js-sdk/pull/865)
+-   Add debugging for spurious room version warnings
+    [\#866](https://github.com/matrix-org/matrix-js-sdk/pull/866)
+-   Add investigation notes for browser storage
+    [\#864](https://github.com/matrix-org/matrix-js-sdk/pull/864)
+-   make sure resolve object is defined before calling it
+    [\#862](https://github.com/matrix-org/matrix-js-sdk/pull/862)
+-   Rename `MatrixInMemoryStore` to `MemoryStore`
+    [\#861](https://github.com/matrix-org/matrix-js-sdk/pull/861)
+-   Use Buildkite for CI
+    [\#859](https://github.com/matrix-org/matrix-js-sdk/pull/859)
+-   only create one session at a time per device
+    [\#857](https://github.com/matrix-org/matrix-js-sdk/pull/857)
+
+# Changes in [1.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2) (2019-03-18)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.2-rc.1...v1.0.2)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [1.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2-rc.1) (2019-03-13)
 
-Changes in [1.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2-rc.1) (2019-03-13)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.1...v1.0.2-rc.1)
 
- * Use modern Yarn version on Travis CI
-   [\#858](https://github.com/matrix-org/matrix-js-sdk/pull/858)
- * Switch to `yarn` for dependency management
-   [\#856](https://github.com/matrix-org/matrix-js-sdk/pull/856)
- * More key request fixes
-   [\#855](https://github.com/matrix-org/matrix-js-sdk/pull/855)
- * Calculate encrypted notification counts
-   [\#851](https://github.com/matrix-org/matrix-js-sdk/pull/851)
- * Update dependencies
-   [\#854](https://github.com/matrix-org/matrix-js-sdk/pull/854)
- * make sure key requests get sent
-   [\#850](https://github.com/matrix-org/matrix-js-sdk/pull/850)
- * Use 'ideal' rather than 'exact' for deviceid
-   [\#852](https://github.com/matrix-org/matrix-js-sdk/pull/852)
- * handle partially-shared sessions better
-   [\#848](https://github.com/matrix-org/matrix-js-sdk/pull/848)
-
-Changes in [1.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1) (2019-03-06)
-================================================================================================
+-   Use modern Yarn version on Travis CI
+    [\#858](https://github.com/matrix-org/matrix-js-sdk/pull/858)
+-   Switch to `yarn` for dependency management
+    [\#856](https://github.com/matrix-org/matrix-js-sdk/pull/856)
+-   More key request fixes
+    [\#855](https://github.com/matrix-org/matrix-js-sdk/pull/855)
+-   Calculate encrypted notification counts
+    [\#851](https://github.com/matrix-org/matrix-js-sdk/pull/851)
+-   Update dependencies
+    [\#854](https://github.com/matrix-org/matrix-js-sdk/pull/854)
+-   make sure key requests get sent
+    [\#850](https://github.com/matrix-org/matrix-js-sdk/pull/850)
+-   Use 'ideal' rather than 'exact' for deviceid
+    [\#852](https://github.com/matrix-org/matrix-js-sdk/pull/852)
+-   handle partially-shared sessions better
+    [\#848](https://github.com/matrix-org/matrix-js-sdk/pull/848)
+
+# Changes in [1.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1) (2019-03-06)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.1-rc.2...v1.0.1)
 
- * No changes since rc.2
+-   No changes since rc.2
+
+# Changes in [1.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.2) (2019-03-05)
 
-Changes in [1.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.2) (2019-03-05)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.1-rc.1...v1.0.1-rc.2)
 
- * dont swallow txn errors in crypto store
-   [\#853](https://github.com/matrix-org/matrix-js-sdk/pull/853)
- * Don't swallow txn errors in crypto store
-   [\#849](https://github.com/matrix-org/matrix-js-sdk/pull/849)
+-   dont swallow txn errors in crypto store
+    [\#853](https://github.com/matrix-org/matrix-js-sdk/pull/853)
+-   Don't swallow txn errors in crypto store
+    [\#849](https://github.com/matrix-org/matrix-js-sdk/pull/849)
+
+# Changes in [1.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.1) (2019-02-28)
 
-Changes in [1.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.1) (2019-02-28)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.0...v1.0.1-rc.1)
 
- * Fix "e is undefined" masking the original error in MegolmDecryption
-   [\#847](https://github.com/matrix-org/matrix-js-sdk/pull/847)
+-   Fix "e is undefined" masking the original error in MegolmDecryption
+    [\#847](https://github.com/matrix-org/matrix-js-sdk/pull/847)
+
+# Changes in [1.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0) (2019-02-14)
 
-Changes in [1.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0) (2019-02-14)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.0-rc.2...v1.0.0)
 
- * Try again to commit package-lock.json
-   [\#841](https://github.com/matrix-org/matrix-js-sdk/pull/841)
+-   Try again to commit package-lock.json
+    [\#841](https://github.com/matrix-org/matrix-js-sdk/pull/841)
+
+# Changes in [1.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.2) (2019-02-14)
 
-Changes in [1.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.2) (2019-02-14)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.0-rc.1...v1.0.0-rc.2)
 
- * Release script: commit package-lock.json
-   [\#839](https://github.com/matrix-org/matrix-js-sdk/pull/839)
- * Add method to force re-check of key backup
-   [\#840](https://github.com/matrix-org/matrix-js-sdk/pull/840)
- * Fix: dont check for unverified devices in left members
-   [\#838](https://github.com/matrix-org/matrix-js-sdk/pull/838)
+-   Release script: commit package-lock.json
+    [\#839](https://github.com/matrix-org/matrix-js-sdk/pull/839)
+-   Add method to force re-check of key backup
+    [\#840](https://github.com/matrix-org/matrix-js-sdk/pull/840)
+-   Fix: dont check for unverified devices in left members
+    [\#838](https://github.com/matrix-org/matrix-js-sdk/pull/838)
+
+# Changes in [1.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.1) (2019-02-08)
 
-Changes in [1.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.1) (2019-02-08)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.3...v1.0.0-rc.1)
 
- * change hex SAS verification to decimal and emoji
-   [\#837](https://github.com/matrix-org/matrix-js-sdk/pull/837)
- * Trust on decrypt
-   [\#836](https://github.com/matrix-org/matrix-js-sdk/pull/836)
- * Always track our own devices
-   [\#835](https://github.com/matrix-org/matrix-js-sdk/pull/835)
- * Make linting rules more consistent
-   [\#834](https://github.com/matrix-org/matrix-js-sdk/pull/834)
- * add method to room to check for unverified devices
-   [\#833](https://github.com/matrix-org/matrix-js-sdk/pull/833)
- * Merge redesign into develop
-   [\#831](https://github.com/matrix-org/matrix-js-sdk/pull/831)
- * Supporting infrastructure for educated decisions on when to upgrade rooms
-   [\#830](https://github.com/matrix-org/matrix-js-sdk/pull/830)
- * Include signature info for unknown devices
-   [\#826](https://github.com/matrix-org/matrix-js-sdk/pull/826)
- * Flag v2 rooms as "safe"
-   [\#828](https://github.com/matrix-org/matrix-js-sdk/pull/828)
- * Update ESLint
-   [\#821](https://github.com/matrix-org/matrix-js-sdk/pull/821)
-
-Changes in [0.14.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3) (2019-01-22)
-==================================================================================================
+-   change hex SAS verification to decimal and emoji
+    [\#837](https://github.com/matrix-org/matrix-js-sdk/pull/837)
+-   Trust on decrypt
+    [\#836](https://github.com/matrix-org/matrix-js-sdk/pull/836)
+-   Always track our own devices
+    [\#835](https://github.com/matrix-org/matrix-js-sdk/pull/835)
+-   Make linting rules more consistent
+    [\#834](https://github.com/matrix-org/matrix-js-sdk/pull/834)
+-   add method to room to check for unverified devices
+    [\#833](https://github.com/matrix-org/matrix-js-sdk/pull/833)
+-   Merge redesign into develop
+    [\#831](https://github.com/matrix-org/matrix-js-sdk/pull/831)
+-   Supporting infrastructure for educated decisions on when to upgrade rooms
+    [\#830](https://github.com/matrix-org/matrix-js-sdk/pull/830)
+-   Include signature info for unknown devices
+    [\#826](https://github.com/matrix-org/matrix-js-sdk/pull/826)
+-   Flag v2 rooms as "safe"
+    [\#828](https://github.com/matrix-org/matrix-js-sdk/pull/828)
+-   Update ESLint
+    [\#821](https://github.com/matrix-org/matrix-js-sdk/pull/821)
+
+# Changes in [0.14.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3) (2019-01-22)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.3-rc.1...v0.14.3)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.14.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3-rc.1) (2019-01-17)
 
-Changes in [0.14.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3-rc.1) (2019-01-17)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.2...v0.14.3-rc.1)
 
- * Merge develop into experimental
-   [\#815](https://github.com/matrix-org/matrix-js-sdk/pull/815)
- * Add a getAllEndToEndSessions to crypto store
-   [\#812](https://github.com/matrix-org/matrix-js-sdk/pull/812)
- * T3chguy/fix displayname logic
-   [\#668](https://github.com/matrix-org/matrix-js-sdk/pull/668)
- * Contributing: Note that rebase lets you mass signoff commits
-   [\#814](https://github.com/matrix-org/matrix-js-sdk/pull/814)
- * take into account homoglyphs when calculating similar display names
-   [\#672](https://github.com/matrix-org/matrix-js-sdk/pull/672)
- * Emit for key backup failures
-   [\#809](https://github.com/matrix-org/matrix-js-sdk/pull/809)
- * emit oldEventId on "updatePendingEvent"
-   [\#646](https://github.com/matrix-org/matrix-js-sdk/pull/646)
- * Add getThirdpartyUser to base api
-   [\#589](https://github.com/matrix-org/matrix-js-sdk/pull/589)
- * Support custom status messages
-   [\#805](https://github.com/matrix-org/matrix-js-sdk/pull/805)
- * Extra checks to avoid release script blowing up mid-process.
-   [\#749](https://github.com/matrix-org/matrix-js-sdk/pull/749)
- * Move glob regex utilities out of the pushprocessor and into a more generic
-   place
-   [\#800](https://github.com/matrix-org/matrix-js-sdk/pull/800)
-
-Changes in [0.14.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2) (2018-12-10)
-==================================================================================================
+-   Merge develop into experimental
+    [\#815](https://github.com/matrix-org/matrix-js-sdk/pull/815)
+-   Add a getAllEndToEndSessions to crypto store
+    [\#812](https://github.com/matrix-org/matrix-js-sdk/pull/812)
+-   T3chguy/fix displayname logic
+    [\#668](https://github.com/matrix-org/matrix-js-sdk/pull/668)
+-   Contributing: Note that rebase lets you mass signoff commits
+    [\#814](https://github.com/matrix-org/matrix-js-sdk/pull/814)
+-   take into account homoglyphs when calculating similar display names
+    [\#672](https://github.com/matrix-org/matrix-js-sdk/pull/672)
+-   Emit for key backup failures
+    [\#809](https://github.com/matrix-org/matrix-js-sdk/pull/809)
+-   emit oldEventId on "updatePendingEvent"
+    [\#646](https://github.com/matrix-org/matrix-js-sdk/pull/646)
+-   Add getThirdpartyUser to base api
+    [\#589](https://github.com/matrix-org/matrix-js-sdk/pull/589)
+-   Support custom status messages
+    [\#805](https://github.com/matrix-org/matrix-js-sdk/pull/805)
+-   Extra checks to avoid release script blowing up mid-process.
+    [\#749](https://github.com/matrix-org/matrix-js-sdk/pull/749)
+-   Move glob regex utilities out of the pushprocessor and into a more generic
+    place
+    [\#800](https://github.com/matrix-org/matrix-js-sdk/pull/800)
+
+# Changes in [0.14.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2) (2018-12-10)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.2-rc.1...v0.14.2)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.14.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2-rc.1) (2018-12-06)
 
-Changes in [0.14.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2-rc.1) (2018-12-06)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.1...v0.14.2-rc.1)
 
- * fix some assertions in e2e backup unit test
-   [\#794](https://github.com/matrix-org/matrix-js-sdk/pull/794)
- * Config should be called with auth
-   [\#798](https://github.com/matrix-org/matrix-js-sdk/pull/798)
- * Don't re-establish sessions with unknown devices
-   [\#792](https://github.com/matrix-org/matrix-js-sdk/pull/792)
- * e2e key backups
-   [\#684](https://github.com/matrix-org/matrix-js-sdk/pull/684)
- * WIP: online incremental megolm backups
-   [\#595](https://github.com/matrix-org/matrix-js-sdk/pull/595)
- * Support for e2e key backups
-   [\#736](https://github.com/matrix-org/matrix-js-sdk/pull/736)
- * Passphrase Support for e2e backups
-   [\#786](https://github.com/matrix-org/matrix-js-sdk/pull/786)
- * Add 'getSsoLoginUrl' function
-   [\#783](https://github.com/matrix-org/matrix-js-sdk/pull/783)
- * Fix: don't set the room name to null when heroes are missing.
-   [\#784](https://github.com/matrix-org/matrix-js-sdk/pull/784)
- * Handle crypto db version upgrades
-   [\#785](https://github.com/matrix-org/matrix-js-sdk/pull/785)
- * Restart broken Olm sessions
-   [\#780](https://github.com/matrix-org/matrix-js-sdk/pull/780)
- * Use the last olm session that got a message
-   [\#776](https://github.com/matrix-org/matrix-js-sdk/pull/776)
-
-Changes in [0.14.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.1) (2018-11-22)
-==================================================================================================
+-   fix some assertions in e2e backup unit test
+    [\#794](https://github.com/matrix-org/matrix-js-sdk/pull/794)
+-   Config should be called with auth
+    [\#798](https://github.com/matrix-org/matrix-js-sdk/pull/798)
+-   Don't re-establish sessions with unknown devices
+    [\#792](https://github.com/matrix-org/matrix-js-sdk/pull/792)
+-   e2e key backups
+    [\#684](https://github.com/matrix-org/matrix-js-sdk/pull/684)
+-   WIP: online incremental megolm backups
+    [\#595](https://github.com/matrix-org/matrix-js-sdk/pull/595)
+-   Support for e2e key backups
+    [\#736](https://github.com/matrix-org/matrix-js-sdk/pull/736)
+-   Passphrase Support for e2e backups
+    [\#786](https://github.com/matrix-org/matrix-js-sdk/pull/786)
+-   Add 'getSsoLoginUrl' function
+    [\#783](https://github.com/matrix-org/matrix-js-sdk/pull/783)
+-   Fix: don't set the room name to null when heroes are missing.
+    [\#784](https://github.com/matrix-org/matrix-js-sdk/pull/784)
+-   Handle crypto db version upgrades
+    [\#785](https://github.com/matrix-org/matrix-js-sdk/pull/785)
+-   Restart broken Olm sessions
+    [\#780](https://github.com/matrix-org/matrix-js-sdk/pull/780)
+-   Use the last olm session that got a message
+    [\#776](https://github.com/matrix-org/matrix-js-sdk/pull/776)
+
+# Changes in [0.14.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.1) (2018-11-22)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.0...v0.14.1)
 
- * Warning when crypto DB is too new to use.
+-   Warning when crypto DB is too new to use.
+
+# Changes in [0.14.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0) (2018-11-19)
 
-Changes in [0.14.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0) (2018-11-19)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.0-rc.1...v0.14.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.14.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0-rc.1) (2018-11-15)
 
-Changes in [0.14.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0-rc.1) (2018-11-15)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.13.1...v0.14.0-rc.1)
 
-BREAKING CHANGE
-----------------
-
- * js-sdk now uses Olm 3.0. Apps using Olm must update to 3.0 to
-   continue using Olm with the js-sdk. The js-sdk will call Olm's
-   init() method when the client is started.
-
-All Changes
------------
-
- * Prevent messages from being sent if other messages have failed to send
-   [\#781](https://github.com/matrix-org/matrix-js-sdk/pull/781)
- * A unit test for olm
-   [\#777](https://github.com/matrix-org/matrix-js-sdk/pull/777)
- * Set access_token and user_id after login in with username and password.
-   [\#778](https://github.com/matrix-org/matrix-js-sdk/pull/778)
- * Add function to get currently joined rooms.
-   [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
- * Remove the request-only stuff we don't need anymore
-   [\#775](https://github.com/matrix-org/matrix-js-sdk/pull/775)
- * Manually construct query strings for browser-request instances
-   [\#770](https://github.com/matrix-org/matrix-js-sdk/pull/770)
- * Fix: correctly check for crypto being present
-   [\#769](https://github.com/matrix-org/matrix-js-sdk/pull/769)
- * Update babel-eslint to 8.1.1
-   [\#768](https://github.com/matrix-org/matrix-js-sdk/pull/768)
- * Support `request` in the browser and support supplying servers to try in
-   joinRoom()
-   [\#764](https://github.com/matrix-org/matrix-js-sdk/pull/764)
- * loglevel should be a normal dependency
-   [\#767](https://github.com/matrix-org/matrix-js-sdk/pull/767)
- * Stop devicelist when client is stopped
-   [\#766](https://github.com/matrix-org/matrix-js-sdk/pull/766)
- * Update to WebAssembly-powered Olm
-   [\#743](https://github.com/matrix-org/matrix-js-sdk/pull/743)
- * Logging lib. Fixes #332
-   [\#763](https://github.com/matrix-org/matrix-js-sdk/pull/763)
- * Use new stop() method on matrix-mock-request
-   [\#765](https://github.com/matrix-org/matrix-js-sdk/pull/765)
-
-Changes in [0.13.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.1) (2018-11-14)
-==================================================================================================
+## BREAKING CHANGE
+
+-   js-sdk now uses Olm 3.0. Apps using Olm must update to 3.0 to
+    continue using Olm with the js-sdk. The js-sdk will call Olm's
+    init() method when the client is started.
+
+## All Changes
+
+-   Prevent messages from being sent if other messages have failed to send
+    [\#781](https://github.com/matrix-org/matrix-js-sdk/pull/781)
+-   A unit test for olm
+    [\#777](https://github.com/matrix-org/matrix-js-sdk/pull/777)
+-   Set access_token and user_id after login in with username and password.
+    [\#778](https://github.com/matrix-org/matrix-js-sdk/pull/778)
+-   Add function to get currently joined rooms.
+    [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
+-   Remove the request-only stuff we don't need anymore
+    [\#775](https://github.com/matrix-org/matrix-js-sdk/pull/775)
+-   Manually construct query strings for browser-request instances
+    [\#770](https://github.com/matrix-org/matrix-js-sdk/pull/770)
+-   Fix: correctly check for crypto being present
+    [\#769](https://github.com/matrix-org/matrix-js-sdk/pull/769)
+-   Update babel-eslint to 8.1.1
+    [\#768](https://github.com/matrix-org/matrix-js-sdk/pull/768)
+-   Support `request` in the browser and support supplying servers to try in
+    joinRoom()
+    [\#764](https://github.com/matrix-org/matrix-js-sdk/pull/764)
+-   loglevel should be a normal dependency
+    [\#767](https://github.com/matrix-org/matrix-js-sdk/pull/767)
+-   Stop devicelist when client is stopped
+    [\#766](https://github.com/matrix-org/matrix-js-sdk/pull/766)
+-   Update to WebAssembly-powered Olm
+    [\#743](https://github.com/matrix-org/matrix-js-sdk/pull/743)
+-   Logging lib. Fixes #332
+    [\#763](https://github.com/matrix-org/matrix-js-sdk/pull/763)
+-   Use new stop() method on matrix-mock-request
+    [\#765](https://github.com/matrix-org/matrix-js-sdk/pull/765)
+
+# Changes in [0.13.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.1) (2018-11-14)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.13.0...v0.13.1)
 
- * Add function to get currently joined rooms.
-   [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
+-   Add function to get currently joined rooms.
+    [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
+
+# Changes in [0.13.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.0) (2018-11-15)
 
-Changes in [0.13.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.0) (2018-11-15)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.1...v0.13.0)
 
-BREAKING CHANGE
-----------------
- * `MatrixClient::login` now sets client `access_token` and `user_id` following successful login with username and password.
+## BREAKING CHANGE
+
+-   `MatrixClient::login` now sets client `access_token` and `user_id` following successful login with username and password.
+
+# Changes in [0.12.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1) (2018-10-29)
 
-Changes in [0.12.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1) (2018-10-29)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.1-rc.1...v0.12.1)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.12.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1-rc.1) (2018-10-24)
 
-Changes in [0.12.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1-rc.1) (2018-10-24)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.0...v0.12.1-rc.1)
 
- * Add repository type to package.json to make it valid
-   [\#762](https://github.com/matrix-org/matrix-js-sdk/pull/762)
- * Add getMediaConfig()
-   [\#761](https://github.com/matrix-org/matrix-js-sdk/pull/761)
- * add new examples, to be expanded into a post
-   [\#739](https://github.com/matrix-org/matrix-js-sdk/pull/739)
+-   Add repository type to package.json to make it valid
+    [\#762](https://github.com/matrix-org/matrix-js-sdk/pull/762)
+-   Add getMediaConfig()
+    [\#761](https://github.com/matrix-org/matrix-js-sdk/pull/761)
+-   add new examples, to be expanded into a post
+    [\#739](https://github.com/matrix-org/matrix-js-sdk/pull/739)
+
+# Changes in [0.12.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0) (2018-10-16)
 
-Changes in [0.12.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0) (2018-10-16)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.0-rc.1...v0.12.0)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.12.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0-rc.1) (2018-10-11)
 
-Changes in [0.12.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0-rc.1) (2018-10-11)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.1...v0.12.0-rc.1)
 
-BREAKING CHANGES
-----------------
- * If js-sdk finds data in the store that is incompatible with the options currently being used,
-   it will emit sync state ERROR with an error of type InvalidStoreError. It will also stop trying
-   to sync in this situation: the app must stop the client and then either clear the store or
-   change the options (in this case, enable or disable lazy loading of members) and then start
-   the client again.
-
-All Changes
------------
-
- * never replace /sync'ed memberships with OOB ones
-   [\#760](https://github.com/matrix-org/matrix-js-sdk/pull/760)
- * Don't fail to start up if lazy load check fails
-   [\#759](https://github.com/matrix-org/matrix-js-sdk/pull/759)
- * Make e2e work on Edge
-   [\#754](https://github.com/matrix-org/matrix-js-sdk/pull/754)
- * throw error with same name and message over idb worker boundary
-   [\#758](https://github.com/matrix-org/matrix-js-sdk/pull/758)
- * Default to a room version of 1 when there is no room create event
-   [\#755](https://github.com/matrix-org/matrix-js-sdk/pull/755)
- * Silence bluebird warnings
-   [\#757](https://github.com/matrix-org/matrix-js-sdk/pull/757)
- * allow non-ff merge from release branch into master
-   [\#750](https://github.com/matrix-org/matrix-js-sdk/pull/750)
- * Reject with the actual error on indexeddb error
-   [\#751](https://github.com/matrix-org/matrix-js-sdk/pull/751)
- * Update mocha to v5
-   [\#744](https://github.com/matrix-org/matrix-js-sdk/pull/744)
- * disable lazy loading for guests as they cant create filters
-   [\#748](https://github.com/matrix-org/matrix-js-sdk/pull/748)
- * Revert "Add getMediaLimits to client"
-   [\#745](https://github.com/matrix-org/matrix-js-sdk/pull/745)
-
-Changes in [0.11.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1) (2018-10-01)
-==================================================================================================
+## BREAKING CHANGES
+
+-   If js-sdk finds data in the store that is incompatible with the options currently being used,
+    it will emit sync state ERROR with an error of type InvalidStoreError. It will also stop trying
+    to sync in this situation: the app must stop the client and then either clear the store or
+    change the options (in this case, enable or disable lazy loading of members) and then start
+    the client again.
+
+## All Changes
+
+-   never replace /sync'ed memberships with OOB ones
+    [\#760](https://github.com/matrix-org/matrix-js-sdk/pull/760)
+-   Don't fail to start up if lazy load check fails
+    [\#759](https://github.com/matrix-org/matrix-js-sdk/pull/759)
+-   Make e2e work on Edge
+    [\#754](https://github.com/matrix-org/matrix-js-sdk/pull/754)
+-   throw error with same name and message over idb worker boundary
+    [\#758](https://github.com/matrix-org/matrix-js-sdk/pull/758)
+-   Default to a room version of 1 when there is no room create event
+    [\#755](https://github.com/matrix-org/matrix-js-sdk/pull/755)
+-   Silence bluebird warnings
+    [\#757](https://github.com/matrix-org/matrix-js-sdk/pull/757)
+-   allow non-ff merge from release branch into master
+    [\#750](https://github.com/matrix-org/matrix-js-sdk/pull/750)
+-   Reject with the actual error on indexeddb error
+    [\#751](https://github.com/matrix-org/matrix-js-sdk/pull/751)
+-   Update mocha to v5
+    [\#744](https://github.com/matrix-org/matrix-js-sdk/pull/744)
+-   disable lazy loading for guests as they cant create filters
+    [\#748](https://github.com/matrix-org/matrix-js-sdk/pull/748)
+-   Revert "Add getMediaLimits to client"
+    [\#745](https://github.com/matrix-org/matrix-js-sdk/pull/745)
+
+# Changes in [0.11.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1) (2018-10-01)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.1-rc.1...v0.11.1)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.11.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1-rc.1) (2018-09-27)
 
-Changes in [0.11.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1-rc.1) (2018-09-27)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.0...v0.11.1-rc.1)
 
- * make usage of hub compatible with latest version (2.5)
-   [\#747](https://github.com/matrix-org/matrix-js-sdk/pull/747)
- * Detect when lazy loading has been toggled in client.startClient
-   [\#746](https://github.com/matrix-org/matrix-js-sdk/pull/746)
- * Add getMediaLimits to client
-   [\#644](https://github.com/matrix-org/matrix-js-sdk/pull/644)
- * Split npm start into an init and watch script
-   [\#742](https://github.com/matrix-org/matrix-js-sdk/pull/742)
- * Revert "room name should only take canonical alias into account"
-   [\#738](https://github.com/matrix-org/matrix-js-sdk/pull/738)
- * fix display name disambiguation with LL
-   [\#737](https://github.com/matrix-org/matrix-js-sdk/pull/737)
- * Introduce Room.myMembership event
-   [\#735](https://github.com/matrix-org/matrix-js-sdk/pull/735)
- * room name should only take canonical alias into account
-   [\#733](https://github.com/matrix-org/matrix-js-sdk/pull/733)
- * state events from context response were not wrapped in a MatrixEvent
-   [\#732](https://github.com/matrix-org/matrix-js-sdk/pull/732)
- * Reduce amount of promises created when inserting members
-   [\#724](https://github.com/matrix-org/matrix-js-sdk/pull/724)
- * dont wait for LL members to be stored to resolve the members
-   [\#726](https://github.com/matrix-org/matrix-js-sdk/pull/726)
- * RoomState.members emitted with wrong argument order for OOB members
-   [\#728](https://github.com/matrix-org/matrix-js-sdk/pull/728)
-
-Changes in [0.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0) (2018-09-10)
-==================================================================================================
+-   make usage of hub compatible with latest version (2.5)
+    [\#747](https://github.com/matrix-org/matrix-js-sdk/pull/747)
+-   Detect when lazy loading has been toggled in client.startClient
+    [\#746](https://github.com/matrix-org/matrix-js-sdk/pull/746)
+-   Add getMediaLimits to client
+    [\#644](https://github.com/matrix-org/matrix-js-sdk/pull/644)
+-   Split npm start into an init and watch script
+    [\#742](https://github.com/matrix-org/matrix-js-sdk/pull/742)
+-   Revert "room name should only take canonical alias into account"
+    [\#738](https://github.com/matrix-org/matrix-js-sdk/pull/738)
+-   fix display name disambiguation with LL
+    [\#737](https://github.com/matrix-org/matrix-js-sdk/pull/737)
+-   Introduce Room.myMembership event
+    [\#735](https://github.com/matrix-org/matrix-js-sdk/pull/735)
+-   room name should only take canonical alias into account
+    [\#733](https://github.com/matrix-org/matrix-js-sdk/pull/733)
+-   state events from context response were not wrapped in a MatrixEvent
+    [\#732](https://github.com/matrix-org/matrix-js-sdk/pull/732)
+-   Reduce amount of promises created when inserting members
+    [\#724](https://github.com/matrix-org/matrix-js-sdk/pull/724)
+-   dont wait for LL members to be stored to resolve the members
+    [\#726](https://github.com/matrix-org/matrix-js-sdk/pull/726)
+-   RoomState.members emitted with wrong argument order for OOB members
+    [\#728](https://github.com/matrix-org/matrix-js-sdk/pull/728)
+
+# Changes in [0.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0) (2018-09-10)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.0-rc.1...v0.11.0)
 
-BREAKING CHANGES
-----------------
- * v0.11.0-rc.1 introduced some breaking changes - see the respective release notes.
+## BREAKING CHANGES
+
+-   v0.11.0-rc.1 introduced some breaking changes - see the respective release notes.
 
 No changes since rc.1
 
-Changes in [0.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0-rc.1) (2018-09-07)
-============================================================================================================
+# Changes in [0.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0-rc.1) (2018-09-07)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.9...v0.11.0-rc.1)
 
- * Support for lazy loading members. This should improve performance for
-   users who joined big rooms a lot. Pass to `lazyLoadMembers = true` option when calling `startClient`.
-
-BREAKING CHANGES
-----------------
-
- * `MatrixClient::startClient` now returns a Promise. No method should be called on the client before that promise resolves. Before this method didn't return anything.
- * A new `CATCHUP` sync state, emitted by `MatrixClient#"sync"` and returned by `MatrixClient::getSyncState()`, when doing initial sync after the `ERROR` state. See `MatrixClient` documentation for details.
- * `RoomState::maySendEvent('m.room.message', userId)` & `RoomState::maySendMessage(userId)` do not check the membership of the user anymore, only the power level. To check if the syncing user is allowed to write in a room, use `Room::maySendMessage()` as `RoomState` is not always aware of the syncing user's membership anymore, in case lazy loading of members is enabled.
-
-All Changes
------------
-
- * Only emit CATCHUP if recovering from conn error
-   [\#727](https://github.com/matrix-org/matrix-js-sdk/pull/727)
- * Fix docstring for sync data.error
-   [\#725](https://github.com/matrix-org/matrix-js-sdk/pull/725)
- * Re-apply "Don't rely on members to query if syncing user can post to room"
-   [\#723](https://github.com/matrix-org/matrix-js-sdk/pull/723)
- * Revert "Don't rely on members to query if syncing user can post to room"
-   [\#721](https://github.com/matrix-org/matrix-js-sdk/pull/721)
- * Don't rely on members to query if syncing user can post to room
-   [\#717](https://github.com/matrix-org/matrix-js-sdk/pull/717)
- * Fixes for room.guessDMUserId
-   [\#719](https://github.com/matrix-org/matrix-js-sdk/pull/719)
- * Fix filepanel also filtering main timeline with LL turned on.
-   [\#716](https://github.com/matrix-org/matrix-js-sdk/pull/716)
- * Remove lazy loaded members when leaving room
-   [\#711](https://github.com/matrix-org/matrix-js-sdk/pull/711)
- * Fix: show spinner again while recovering from connection error
-   [\#702](https://github.com/matrix-org/matrix-js-sdk/pull/702)
- * Add method to query LL state in client
-   [\#714](https://github.com/matrix-org/matrix-js-sdk/pull/714)
- * Fix: also load invited members when lazy loading members
-   [\#707](https://github.com/matrix-org/matrix-js-sdk/pull/707)
- * Pass through function to discard megolm session
-   [\#704](https://github.com/matrix-org/matrix-js-sdk/pull/704)
-
-Changes in [0.10.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9) (2018-09-03)
-==================================================================================================
+-   Support for lazy loading members. This should improve performance for
+    users who joined big rooms a lot. Pass to `lazyLoadMembers = true` option when calling `startClient`.
+
+## BREAKING CHANGES
+
+-   `MatrixClient::startClient` now returns a Promise. No method should be called on the client before that promise resolves. Before this method didn't return anything.
+-   A new `CATCHUP` sync state, emitted by `MatrixClient#"sync"` and returned by `MatrixClient::getSyncState()`, when doing initial sync after the `ERROR` state. See `MatrixClient` documentation for details.
+-   `RoomState::maySendEvent('m.room.message', userId)` & `RoomState::maySendMessage(userId)` do not check the membership of the user anymore, only the power level. To check if the syncing user is allowed to write in a room, use `Room::maySendMessage()` as `RoomState` is not always aware of the syncing user's membership anymore, in case lazy loading of members is enabled.
+
+## All Changes
+
+-   Only emit CATCHUP if recovering from conn error
+    [\#727](https://github.com/matrix-org/matrix-js-sdk/pull/727)
+-   Fix docstring for sync data.error
+    [\#725](https://github.com/matrix-org/matrix-js-sdk/pull/725)
+-   Re-apply "Don't rely on members to query if syncing user can post to room"
+    [\#723](https://github.com/matrix-org/matrix-js-sdk/pull/723)
+-   Revert "Don't rely on members to query if syncing user can post to room"
+    [\#721](https://github.com/matrix-org/matrix-js-sdk/pull/721)
+-   Don't rely on members to query if syncing user can post to room
+    [\#717](https://github.com/matrix-org/matrix-js-sdk/pull/717)
+-   Fixes for room.guessDMUserId
+    [\#719](https://github.com/matrix-org/matrix-js-sdk/pull/719)
+-   Fix filepanel also filtering main timeline with LL turned on.
+    [\#716](https://github.com/matrix-org/matrix-js-sdk/pull/716)
+-   Remove lazy loaded members when leaving room
+    [\#711](https://github.com/matrix-org/matrix-js-sdk/pull/711)
+-   Fix: show spinner again while recovering from connection error
+    [\#702](https://github.com/matrix-org/matrix-js-sdk/pull/702)
+-   Add method to query LL state in client
+    [\#714](https://github.com/matrix-org/matrix-js-sdk/pull/714)
+-   Fix: also load invited members when lazy loading members
+    [\#707](https://github.com/matrix-org/matrix-js-sdk/pull/707)
+-   Pass through function to discard megolm session
+    [\#704](https://github.com/matrix-org/matrix-js-sdk/pull/704)
+
+# Changes in [0.10.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9) (2018-09-03)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.9-rc.2...v0.10.9)
 
- * No changes since rc.2
+-   No changes since rc.2
+
+# Changes in [0.10.9-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.2) (2018-08-31)
 
-Changes in [0.10.9-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.2) (2018-08-31)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.9-rc.1...v0.10.9-rc.2)
 
- * Fix for "otherMember.getAvatarUrl is not a function"
-   [\#708](https://github.com/matrix-org/matrix-js-sdk/pull/708)
+-   Fix for "otherMember.getAvatarUrl is not a function"
+    [\#708](https://github.com/matrix-org/matrix-js-sdk/pull/708)
+
+# Changes in [0.10.9-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.1) (2018-08-30)
 
-Changes in [0.10.9-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.1) (2018-08-30)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.8...v0.10.9-rc.1)
 
- * Fix DM avatar
-   [\#706](https://github.com/matrix-org/matrix-js-sdk/pull/706)
- * Lazy loading: avoid loading members at initial sync for e2e rooms
-   [\#699](https://github.com/matrix-org/matrix-js-sdk/pull/699)
- * Improve setRoomEncryption guard against multiple m.room.encryption st…
-   [\#700](https://github.com/matrix-org/matrix-js-sdk/pull/700)
- * Revert "Lazy loading: don't block on setting up room crypto"
-   [\#698](https://github.com/matrix-org/matrix-js-sdk/pull/698)
- * Lazy loading: don't block on setting up room crypto
-   [\#696](https://github.com/matrix-org/matrix-js-sdk/pull/696)
- * Add getVisibleRooms()
-   [\#695](https://github.com/matrix-org/matrix-js-sdk/pull/695)
- * Add wrapper around getJoinedMemberCount()
-   [\#697](https://github.com/matrix-org/matrix-js-sdk/pull/697)
- * Api to fetch events via /room/.../event/..
-   [\#694](https://github.com/matrix-org/matrix-js-sdk/pull/694)
- * Support for room upgrades
-   [\#693](https://github.com/matrix-org/matrix-js-sdk/pull/693)
- * Lazy loading of room members
-   [\#691](https://github.com/matrix-org/matrix-js-sdk/pull/691)
-
-Changes in [0.10.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8) (2018-08-20)
-==================================================================================================
+-   Fix DM avatar
+    [\#706](https://github.com/matrix-org/matrix-js-sdk/pull/706)
+-   Lazy loading: avoid loading members at initial sync for e2e rooms
+    [\#699](https://github.com/matrix-org/matrix-js-sdk/pull/699)
+-   Improve setRoomEncryption guard against multiple m.room.encryption st…
+    [\#700](https://github.com/matrix-org/matrix-js-sdk/pull/700)
+-   Revert "Lazy loading: don't block on setting up room crypto"
+    [\#698](https://github.com/matrix-org/matrix-js-sdk/pull/698)
+-   Lazy loading: don't block on setting up room crypto
+    [\#696](https://github.com/matrix-org/matrix-js-sdk/pull/696)
+-   Add getVisibleRooms()
+    [\#695](https://github.com/matrix-org/matrix-js-sdk/pull/695)
+-   Add wrapper around getJoinedMemberCount()
+    [\#697](https://github.com/matrix-org/matrix-js-sdk/pull/697)
+-   Api to fetch events via /room/.../event/..
+    [\#694](https://github.com/matrix-org/matrix-js-sdk/pull/694)
+-   Support for room upgrades
+    [\#693](https://github.com/matrix-org/matrix-js-sdk/pull/693)
+-   Lazy loading of room members
+    [\#691](https://github.com/matrix-org/matrix-js-sdk/pull/691)
+
+# Changes in [0.10.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8) (2018-08-20)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.8-rc.1...v0.10.8)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.10.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8-rc.1) (2018-08-16)
 
-Changes in [0.10.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8-rc.1) (2018-08-16)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.7...v0.10.8-rc.1)
 
- * Add getVersion to Room
-   [\#689](https://github.com/matrix-org/matrix-js-sdk/pull/689)
- * Add getSyncStateData()
-   [\#680](https://github.com/matrix-org/matrix-js-sdk/pull/680)
- * Send sync error to listener
-   [\#679](https://github.com/matrix-org/matrix-js-sdk/pull/679)
- * make sure room.tags is always a valid object to avoid crashes
-   [\#675](https://github.com/matrix-org/matrix-js-sdk/pull/675)
- * Fix infinite spinner upon joining a room
-   [\#673](https://github.com/matrix-org/matrix-js-sdk/pull/673)
-
-Changes in [0.10.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7) (2018-07-30)
-==================================================================================================
+-   Add getVersion to Room
+    [\#689](https://github.com/matrix-org/matrix-js-sdk/pull/689)
+-   Add getSyncStateData()
+    [\#680](https://github.com/matrix-org/matrix-js-sdk/pull/680)
+-   Send sync error to listener
+    [\#679](https://github.com/matrix-org/matrix-js-sdk/pull/679)
+-   make sure room.tags is always a valid object to avoid crashes
+    [\#675](https://github.com/matrix-org/matrix-js-sdk/pull/675)
+-   Fix infinite spinner upon joining a room
+    [\#673](https://github.com/matrix-org/matrix-js-sdk/pull/673)
+
+# Changes in [0.10.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7) (2018-07-30)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.7-rc.1...v0.10.7)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.10.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7-rc.1) (2018-07-24)
 
-Changes in [0.10.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7-rc.1) (2018-07-24)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.6...v0.10.7-rc.1)
 
- * encrypt for invited users if history visibility allows.
-   [\#666](https://github.com/matrix-org/matrix-js-sdk/pull/666)
+-   encrypt for invited users if history visibility allows.
+    [\#666](https://github.com/matrix-org/matrix-js-sdk/pull/666)
+
+# Changes in [0.10.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6) (2018-07-09)
 
-Changes in [0.10.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6) (2018-07-09)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.6-rc.1...v0.10.6)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.10.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6-rc.1) (2018-07-06)
 
-Changes in [0.10.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6-rc.1) (2018-07-06)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.5...v0.10.6-rc.1)
 
- * Expose event decryption error via Event.decrypted event
-   [\#665](https://github.com/matrix-org/matrix-js-sdk/pull/665)
- * Add decryption error codes to base.DecryptionError
-   [\#663](https://github.com/matrix-org/matrix-js-sdk/pull/663)
+-   Expose event decryption error via Event.decrypted event
+    [\#665](https://github.com/matrix-org/matrix-js-sdk/pull/665)
+-   Add decryption error codes to base.DecryptionError
+    [\#663](https://github.com/matrix-org/matrix-js-sdk/pull/663)
+
+# Changes in [0.10.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5) (2018-06-29)
 
-Changes in [0.10.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5) (2018-06-29)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.5-rc.1...v0.10.5)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.10.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5-rc.1) (2018-06-21)
 
-Changes in [0.10.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5-rc.1) (2018-06-21)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.4...v0.10.5-rc.1)
 
- * fix auth header and filename=undefined
-   [\#659](https://github.com/matrix-org/matrix-js-sdk/pull/659)
- * allow setting the output device for webrtc calls
-   [\#650](https://github.com/matrix-org/matrix-js-sdk/pull/650)
- * arguments true and false are actually invalid
-   [\#596](https://github.com/matrix-org/matrix-js-sdk/pull/596)
- * fix typo where `headers` was not being used and thus sent wrong content-type
-   [\#643](https://github.com/matrix-org/matrix-js-sdk/pull/643)
- * fix some documentation typos
-   [\#642](https://github.com/matrix-org/matrix-js-sdk/pull/642)
-
-Changes in [0.10.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4) (2018-06-12)
-==================================================================================================
+-   fix auth header and filename=undefined
+    [\#659](https://github.com/matrix-org/matrix-js-sdk/pull/659)
+-   allow setting the output device for webrtc calls
+    [\#650](https://github.com/matrix-org/matrix-js-sdk/pull/650)
+-   arguments true and false are actually invalid
+    [\#596](https://github.com/matrix-org/matrix-js-sdk/pull/596)
+-   fix typo where `headers` was not being used and thus sent wrong content-type
+    [\#643](https://github.com/matrix-org/matrix-js-sdk/pull/643)
+-   fix some documentation typos
+    [\#642](https://github.com/matrix-org/matrix-js-sdk/pull/642)
+
+# Changes in [0.10.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4) (2018-06-12)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.4-rc.1...v0.10.4)
 
- * No changes since rc.1
+-   No changes since rc.1
+
+# Changes in [0.10.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4-rc.1) (2018-06-06)
 
-Changes in [0.10.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4-rc.1) (2018-06-06)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.3...v0.10.4-rc.1)
 
- * check whether notif level is undefined, because `0` is falsey
-   [\#651](https://github.com/matrix-org/matrix-js-sdk/pull/651)
+-   check whether notif level is undefined, because `0` is falsey
+    [\#651](https://github.com/matrix-org/matrix-js-sdk/pull/651)
+
+# Changes in [0.10.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3) (2018-05-25)
 
-Changes in [0.10.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3) (2018-05-25)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.3-rc.1...v0.10.3)
 
- * No changes since v0.10.3-rc.1
+-   No changes since v0.10.3-rc.1
+
+# Changes in [0.10.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3-rc.1) (2018-05-24)
 
-Changes in [0.10.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3-rc.1) (2018-05-24)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.2...v0.10.3-rc.1)
 
-BREAKING CHANGE
----------------
+## BREAKING CHANGE
 
 The deprecated 'callback' parameter has been removed from MatrixBaseApis.deactivateAccount
 
- * Add `erase` option to deactivateAccount
-   [\#649](https://github.com/matrix-org/matrix-js-sdk/pull/649)
- * Emit Session.no_consent when M_CONSENT_NOT_GIVEN received
-   [\#647](https://github.com/matrix-org/matrix-js-sdk/pull/647)
+-   Add `erase` option to deactivateAccount
+    [\#649](https://github.com/matrix-org/matrix-js-sdk/pull/649)
+-   Emit Session.no_consent when M_CONSENT_NOT_GIVEN received
+    [\#647](https://github.com/matrix-org/matrix-js-sdk/pull/647)
+
+# Changes in [0.10.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2) (2018-04-30)
 
-Changes in [0.10.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2) (2018-04-30)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.2-rc.1...v0.10.2)
 
- * No changes from rc.1
+-   No changes from rc.1
+
+# Changes in [0.10.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2-rc.1) (2018-04-25)
 
-Changes in [0.10.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2-rc.1) (2018-04-25)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.1...v0.10.2-rc.1)
 
- * Ignore inserts of dup inbound group sessions, pt 2
-   [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
- * Ignore inserts of duplicate inbound group sessions
-   [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
- * Log IDB errors
-   [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
- * Remove not very useful but veryv spammy log line
-   [\#632](https://github.com/matrix-org/matrix-js-sdk/pull/632)
- * Switch event type to m.sticker.
-   [\#628](https://github.com/matrix-org/matrix-js-sdk/pull/628)
-
-Changes in [0.10.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.1) (2018-04-12)
-==================================================================================================
+-   Ignore inserts of dup inbound group sessions, pt 2
+    [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
+-   Ignore inserts of duplicate inbound group sessions
+    [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
+-   Log IDB errors
+    [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
+-   Remove not very useful but veryv spammy log line
+    [\#632](https://github.com/matrix-org/matrix-js-sdk/pull/632)
+-   Switch event type to m.sticker.
+    [\#628](https://github.com/matrix-org/matrix-js-sdk/pull/628)
+
+# Changes in [0.10.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.1) (2018-04-12)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.0...v0.10.1)
 
- * Log IDB errors
-   [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
- * Ignore inserts of duplicate inbound group sessions
-   [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
- * Ignore inserts of dup inbound group sessions, pt 2
-   [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
+-   Log IDB errors
+    [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
+-   Ignore inserts of duplicate inbound group sessions
+    [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
+-   Ignore inserts of dup inbound group sessions, pt 2
+    [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
+
+# Changes in [0.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0) (2018-04-11)
 
-Changes in [0.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0) (2018-04-11)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.0-rc.2...v0.10.0)
 
- * No changes
+-   No changes
+
+# Changes in [0.10.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.2) (2018-04-09)
 
-Changes in [0.10.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.2) (2018-04-09)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.0-rc.1...v0.10.0-rc.2)
 
- * Add wrapper for group join API
- * Add wrapped API to set group join\_policy
+-   Add wrapper for group join API
+-   Add wrapped API to set group join_policy
+
+# Changes in [0.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.1) (2018-03-19)
 
-Changes in [0.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.1) (2018-03-19)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.2...v0.10.0-rc.1)
 
- * Fix duplicated state events in timeline from peek
-   [\#630](https://github.com/matrix-org/matrix-js-sdk/pull/630)
- * Create indexeddb worker when starting the store
-   [\#627](https://github.com/matrix-org/matrix-js-sdk/pull/627)
- * Fix indexeddb logging
-   [\#626](https://github.com/matrix-org/matrix-js-sdk/pull/626)
- * Don't do /keys/changes on incremental sync
-   [\#625](https://github.com/matrix-org/matrix-js-sdk/pull/625)
- * Don't mark devicelist dirty unnecessarily
-   [\#623](https://github.com/matrix-org/matrix-js-sdk/pull/623)
- * Cache the joined member count for a room state
-   [\#619](https://github.com/matrix-org/matrix-js-sdk/pull/619)
- * Fix JS doc
-   [\#618](https://github.com/matrix-org/matrix-js-sdk/pull/618)
- * Precompute push actions for state events
-   [\#617](https://github.com/matrix-org/matrix-js-sdk/pull/617)
- * Fix bug where global "Never send to unverified..." is ignored
-   [\#616](https://github.com/matrix-org/matrix-js-sdk/pull/616)
- * Intern legacy top-level 'membership' field
-   [\#615](https://github.com/matrix-org/matrix-js-sdk/pull/615)
- * Don't synthesize RR for m.room.redaction as causes the RR to go missing.
-   [\#598](https://github.com/matrix-org/matrix-js-sdk/pull/598)
- * Make Events create Dates on demand
-   [\#613](https://github.com/matrix-org/matrix-js-sdk/pull/613)
- * Stop cloning events when adding to state
-   [\#612](https://github.com/matrix-org/matrix-js-sdk/pull/612)
- * De-dup code: use the initialiseState function
-   [\#611](https://github.com/matrix-org/matrix-js-sdk/pull/611)
- * Create sentinel members on-demand
-   [\#610](https://github.com/matrix-org/matrix-js-sdk/pull/610)
- * Some more doc on how sentinels work
-   [\#609](https://github.com/matrix-org/matrix-js-sdk/pull/609)
- * Migrate room encryption store to crypto store
-   [\#597](https://github.com/matrix-org/matrix-js-sdk/pull/597)
- * add parameter to getIdentityServerUrl to strip the protocol for invites
-   [\#600](https://github.com/matrix-org/matrix-js-sdk/pull/600)
- * Move Device Tracking Data to Crypto Store
-   [\#594](https://github.com/matrix-org/matrix-js-sdk/pull/594)
- * Optimise pushprocessor
-   [\#591](https://github.com/matrix-org/matrix-js-sdk/pull/591)
- * Set event error before emitting
-   [\#592](https://github.com/matrix-org/matrix-js-sdk/pull/592)
- * Add event type for stickers [WIP]
-   [\#590](https://github.com/matrix-org/matrix-js-sdk/pull/590)
- * Migrate inbound sessions to cryptostore
-   [\#587](https://github.com/matrix-org/matrix-js-sdk/pull/587)
- * Disambiguate names if they contain an mxid
-   [\#588](https://github.com/matrix-org/matrix-js-sdk/pull/588)
- * Check for sessions in indexeddb before migrating
-   [\#585](https://github.com/matrix-org/matrix-js-sdk/pull/585)
- * Emit an event for crypto store migration
-   [\#586](https://github.com/matrix-org/matrix-js-sdk/pull/586)
- * Supporting fixes For making UnknownDeviceDialog not pop up automatically
-   [\#575](https://github.com/matrix-org/matrix-js-sdk/pull/575)
- * Move sessions to the crypto store
-   [\#584](https://github.com/matrix-org/matrix-js-sdk/pull/584)
- * Change crypto store transaction API
-   [\#582](https://github.com/matrix-org/matrix-js-sdk/pull/582)
- * Add some missed copyright notices
-   [\#581](https://github.com/matrix-org/matrix-js-sdk/pull/581)
- * Move Olm account to IndexedDB
-   [\#579](https://github.com/matrix-org/matrix-js-sdk/pull/579)
- * Fix logging of DecryptionErrors to be more useful
-   [\#580](https://github.com/matrix-org/matrix-js-sdk/pull/580)
- * [BREAKING] Change the behaviour of the unverfied devices blacklist flag
-   [\#568](https://github.com/matrix-org/matrix-js-sdk/pull/568)
- * Support set_presence=offline for syncing
-   [\#557](https://github.com/matrix-org/matrix-js-sdk/pull/557)
- * Consider cases where the sender may not redact their own event
-   [\#556](https://github.com/matrix-org/matrix-js-sdk/pull/556)
-
-Changes in [0.9.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.2) (2017-12-04)
-================================================================================================
+-   Fix duplicated state events in timeline from peek
+    [\#630](https://github.com/matrix-org/matrix-js-sdk/pull/630)
+-   Create indexeddb worker when starting the store
+    [\#627](https://github.com/matrix-org/matrix-js-sdk/pull/627)
+-   Fix indexeddb logging
+    [\#626](https://github.com/matrix-org/matrix-js-sdk/pull/626)
+-   Don't do /keys/changes on incremental sync
+    [\#625](https://github.com/matrix-org/matrix-js-sdk/pull/625)
+-   Don't mark devicelist dirty unnecessarily
+    [\#623](https://github.com/matrix-org/matrix-js-sdk/pull/623)
+-   Cache the joined member count for a room state
+    [\#619](https://github.com/matrix-org/matrix-js-sdk/pull/619)
+-   Fix JS doc
+    [\#618](https://github.com/matrix-org/matrix-js-sdk/pull/618)
+-   Precompute push actions for state events
+    [\#617](https://github.com/matrix-org/matrix-js-sdk/pull/617)
+-   Fix bug where global "Never send to unverified..." is ignored
+    [\#616](https://github.com/matrix-org/matrix-js-sdk/pull/616)
+-   Intern legacy top-level 'membership' field
+    [\#615](https://github.com/matrix-org/matrix-js-sdk/pull/615)
+-   Don't synthesize RR for m.room.redaction as causes the RR to go missing.
+    [\#598](https://github.com/matrix-org/matrix-js-sdk/pull/598)
+-   Make Events create Dates on demand
+    [\#613](https://github.com/matrix-org/matrix-js-sdk/pull/613)
+-   Stop cloning events when adding to state
+    [\#612](https://github.com/matrix-org/matrix-js-sdk/pull/612)
+-   De-dup code: use the initialiseState function
+    [\#611](https://github.com/matrix-org/matrix-js-sdk/pull/611)
+-   Create sentinel members on-demand
+    [\#610](https://github.com/matrix-org/matrix-js-sdk/pull/610)
+-   Some more doc on how sentinels work
+    [\#609](https://github.com/matrix-org/matrix-js-sdk/pull/609)
+-   Migrate room encryption store to crypto store
+    [\#597](https://github.com/matrix-org/matrix-js-sdk/pull/597)
+-   add parameter to getIdentityServerUrl to strip the protocol for invites
+    [\#600](https://github.com/matrix-org/matrix-js-sdk/pull/600)
+-   Move Device Tracking Data to Crypto Store
+    [\#594](https://github.com/matrix-org/matrix-js-sdk/pull/594)
+-   Optimise pushprocessor
+    [\#591](https://github.com/matrix-org/matrix-js-sdk/pull/591)
+-   Set event error before emitting
+    [\#592](https://github.com/matrix-org/matrix-js-sdk/pull/592)
+-   Add event type for stickers [WIP]
+    [\#590](https://github.com/matrix-org/matrix-js-sdk/pull/590)
+-   Migrate inbound sessions to cryptostore
+    [\#587](https://github.com/matrix-org/matrix-js-sdk/pull/587)
+-   Disambiguate names if they contain an mxid
+    [\#588](https://github.com/matrix-org/matrix-js-sdk/pull/588)
+-   Check for sessions in indexeddb before migrating
+    [\#585](https://github.com/matrix-org/matrix-js-sdk/pull/585)
+-   Emit an event for crypto store migration
+    [\#586](https://github.com/matrix-org/matrix-js-sdk/pull/586)
+-   Supporting fixes For making UnknownDeviceDialog not pop up automatically
+    [\#575](https://github.com/matrix-org/matrix-js-sdk/pull/575)
+-   Move sessions to the crypto store
+    [\#584](https://github.com/matrix-org/matrix-js-sdk/pull/584)
+-   Change crypto store transaction API
+    [\#582](https://github.com/matrix-org/matrix-js-sdk/pull/582)
+-   Add some missed copyright notices
+    [\#581](https://github.com/matrix-org/matrix-js-sdk/pull/581)
+-   Move Olm account to IndexedDB
+    [\#579](https://github.com/matrix-org/matrix-js-sdk/pull/579)
+-   Fix logging of DecryptionErrors to be more useful
+    [\#580](https://github.com/matrix-org/matrix-js-sdk/pull/580)
+-   [BREAKING] Change the behaviour of the unverfied devices blacklist flag
+    [\#568](https://github.com/matrix-org/matrix-js-sdk/pull/568)
+-   Support set_presence=offline for syncing
+    [\#557](https://github.com/matrix-org/matrix-js-sdk/pull/557)
+-   Consider cases where the sender may not redact their own event
+    [\#556](https://github.com/matrix-org/matrix-js-sdk/pull/556)
+
+# Changes in [0.9.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.2) (2017-12-04)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.1...v0.9.2)
 
+# Changes in [0.9.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.1) (2017-11-17)
 
-Changes in [0.9.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.1) (2017-11-17)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.0...v0.9.1)
 
- * Fix the force TURN option
-   [\#577](https://github.com/matrix-org/matrix-js-sdk/pull/577)
+-   Fix the force TURN option
+    [\#577](https://github.com/matrix-org/matrix-js-sdk/pull/577)
+
+# Changes in [0.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0) (2017-11-15)
 
-Changes in [0.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0) (2017-11-15)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.0-rc.1...v0.9.0)
 
+# Changes in [0.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0-rc.1) (2017-11-10)
 
-Changes in [0.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0-rc.1) (2017-11-10)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.5...v0.9.0-rc.1)
 
- * Modify addRoomToGroup to allow setting isPublic, create alias
-   updateGroupRoomAssociation
-   [\#567](https://github.com/matrix-org/matrix-js-sdk/pull/567)
- * Expose more functionality of pushprocessor
-   [\#565](https://github.com/matrix-org/matrix-js-sdk/pull/565)
- * Function for working out notif trigger permission
-   [\#566](https://github.com/matrix-org/matrix-js-sdk/pull/566)
- * keep track of event ID and timestamp of decrypted messages
-   [\#555](https://github.com/matrix-org/matrix-js-sdk/pull/555)
- * Fix notifEvent computation
-   [\#564](https://github.com/matrix-org/matrix-js-sdk/pull/564)
- * Fix power level of sentinel members
-   [\#563](https://github.com/matrix-org/matrix-js-sdk/pull/563)
- * don't try to decrypt a redacted message (fixes vector-im/riot-web#3744)
-   [\#554](https://github.com/matrix-org/matrix-js-sdk/pull/554)
- * Support room notifs
-   [\#562](https://github.com/matrix-org/matrix-js-sdk/pull/562)
- * Fix the glob-to-regex code
-   [\#558](https://github.com/matrix-org/matrix-js-sdk/pull/558)
-
-Changes in [0.8.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5) (2017-10-16)
-================================================================================================
+-   Modify addRoomToGroup to allow setting isPublic, create alias
+    updateGroupRoomAssociation
+    [\#567](https://github.com/matrix-org/matrix-js-sdk/pull/567)
+-   Expose more functionality of pushprocessor
+    [\#565](https://github.com/matrix-org/matrix-js-sdk/pull/565)
+-   Function for working out notif trigger permission
+    [\#566](https://github.com/matrix-org/matrix-js-sdk/pull/566)
+-   keep track of event ID and timestamp of decrypted messages
+    [\#555](https://github.com/matrix-org/matrix-js-sdk/pull/555)
+-   Fix notifEvent computation
+    [\#564](https://github.com/matrix-org/matrix-js-sdk/pull/564)
+-   Fix power level of sentinel members
+    [\#563](https://github.com/matrix-org/matrix-js-sdk/pull/563)
+-   don't try to decrypt a redacted message (fixes vector-im/riot-web#3744)
+    [\#554](https://github.com/matrix-org/matrix-js-sdk/pull/554)
+-   Support room notifs
+    [\#562](https://github.com/matrix-org/matrix-js-sdk/pull/562)
+-   Fix the glob-to-regex code
+    [\#558](https://github.com/matrix-org/matrix-js-sdk/pull/558)
+
+# Changes in [0.8.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5) (2017-10-16)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.5-rc.1...v0.8.5)
 
- * Make unknown pushrule conditions not match
-   [\#559](https://github.com/matrix-org/matrix-js-sdk/pull/559)
+-   Make unknown pushrule conditions not match
+    [\#559](https://github.com/matrix-org/matrix-js-sdk/pull/559)
+
+# Changes in [0.8.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5-rc.1) (2017-10-13)
 
-Changes in [0.8.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5-rc.1) (2017-10-13)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.4...v0.8.5-rc.1)
 
- * Implement wrapper API for removing a room from a group
-   [\#553](https://github.com/matrix-org/matrix-js-sdk/pull/553)
- * Fix typo which resulted in stuck key download requests
-   [\#552](https://github.com/matrix-org/matrix-js-sdk/pull/552)
- * Store group when it's created
-   [\#549](https://github.com/matrix-org/matrix-js-sdk/pull/549)
- * Luke/groups remove rooms users from summary
-   [\#548](https://github.com/matrix-org/matrix-js-sdk/pull/548)
- * Clean on prepublish
-   [\#546](https://github.com/matrix-org/matrix-js-sdk/pull/546)
- * Implement wrapper APIs for adding rooms to group summary
-   [\#545](https://github.com/matrix-org/matrix-js-sdk/pull/545)
-
-Changes in [0.8.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.4) (2017-09-21)
-================================================================================================
+-   Implement wrapper API for removing a room from a group
+    [\#553](https://github.com/matrix-org/matrix-js-sdk/pull/553)
+-   Fix typo which resulted in stuck key download requests
+    [\#552](https://github.com/matrix-org/matrix-js-sdk/pull/552)
+-   Store group when it's created
+    [\#549](https://github.com/matrix-org/matrix-js-sdk/pull/549)
+-   Luke/groups remove rooms users from summary
+    [\#548](https://github.com/matrix-org/matrix-js-sdk/pull/548)
+-   Clean on prepublish
+    [\#546](https://github.com/matrix-org/matrix-js-sdk/pull/546)
+-   Implement wrapper APIs for adding rooms to group summary
+    [\#545](https://github.com/matrix-org/matrix-js-sdk/pull/545)
+
+# Changes in [0.8.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.4) (2017-09-21)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.3...v0.8.4)
 
- * Fix build issue
+-   Fix build issue
+
+# Changes in [0.8.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3) (2017-09-20)
 
-Changes in [0.8.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3) (2017-09-20)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.3-rc.1...v0.8.3)
 
- * No changes
+-   No changes
+
+# Changes in [0.8.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3-rc.1) (2017-09-19)
 
-Changes in [0.8.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3-rc.1) (2017-09-19)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.2...v0.8.3-rc.1)
 
- * consume trailing slash when creating Matrix Client in HS and IS urls
-   [\#526](https://github.com/matrix-org/matrix-js-sdk/pull/526)
- * Add ignore users API
-   [\#539](https://github.com/matrix-org/matrix-js-sdk/pull/539)
- * Upgrade to jsdoc 3.5.5
-   [\#540](https://github.com/matrix-org/matrix-js-sdk/pull/540)
- * Make re-emitting events much more memory efficient
-   [\#538](https://github.com/matrix-org/matrix-js-sdk/pull/538)
- * Only re-emit events from Event objects if needed
-   [\#536](https://github.com/matrix-org/matrix-js-sdk/pull/536)
- * Handle 'left' users in the deviceList mananagement
-   [\#535](https://github.com/matrix-org/matrix-js-sdk/pull/535)
- * Factor out devicelist integration tests to a separate file
-   [\#534](https://github.com/matrix-org/matrix-js-sdk/pull/534)
- * Refactor sync._sync as an async function
-   [\#533](https://github.com/matrix-org/matrix-js-sdk/pull/533)
- * Add es6 to eslint environments
-   [\#532](https://github.com/matrix-org/matrix-js-sdk/pull/532)
-
-Changes in [0.8.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.2) (2017-08-24)
-================================================================================================
+-   consume trailing slash when creating Matrix Client in HS and IS urls
+    [\#526](https://github.com/matrix-org/matrix-js-sdk/pull/526)
+-   Add ignore users API
+    [\#539](https://github.com/matrix-org/matrix-js-sdk/pull/539)
+-   Upgrade to jsdoc 3.5.5
+    [\#540](https://github.com/matrix-org/matrix-js-sdk/pull/540)
+-   Make re-emitting events much more memory efficient
+    [\#538](https://github.com/matrix-org/matrix-js-sdk/pull/538)
+-   Only re-emit events from Event objects if needed
+    [\#536](https://github.com/matrix-org/matrix-js-sdk/pull/536)
+-   Handle 'left' users in the deviceList mananagement
+    [\#535](https://github.com/matrix-org/matrix-js-sdk/pull/535)
+-   Factor out devicelist integration tests to a separate file
+    [\#534](https://github.com/matrix-org/matrix-js-sdk/pull/534)
+-   Refactor sync.\_sync as an async function
+    [\#533](https://github.com/matrix-org/matrix-js-sdk/pull/533)
+-   Add es6 to eslint environments
+    [\#532](https://github.com/matrix-org/matrix-js-sdk/pull/532)
+
+# Changes in [0.8.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.2) (2017-08-24)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.1...v0.8.2)
 
- * Handle m.call.* events which are decrypted asynchronously
-   [\#530](https://github.com/matrix-org/matrix-js-sdk/pull/530)
- * Re-emit events from, er, Event objects
-   [\#529](https://github.com/matrix-org/matrix-js-sdk/pull/529)
+-   Handle m.call.\* events which are decrypted asynchronously
+    [\#530](https://github.com/matrix-org/matrix-js-sdk/pull/530)
+-   Re-emit events from, er, Event objects
+    [\#529](https://github.com/matrix-org/matrix-js-sdk/pull/529)
+
+# Changes in [0.8.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1) (2017-08-23)
 
-Changes in [0.8.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1) (2017-08-23)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.1-rc.1...v0.8.1)
 
- * [No changes]
+-   [No changes]
+
+# Changes in [0.8.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1-rc.1) (2017-08-22)
 
-Changes in [0.8.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1-rc.1) (2017-08-22)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.0...v0.8.1-rc.1)
 
- * Fix error handling in interactive-auth
-   [\#527](https://github.com/matrix-org/matrix-js-sdk/pull/527)
- * Make lots of OlmDevice asynchronous
-   [\#524](https://github.com/matrix-org/matrix-js-sdk/pull/524)
- * Make crypto.decryptMessage return decryption results
-   [\#523](https://github.com/matrix-org/matrix-js-sdk/pull/523)
+-   Fix error handling in interactive-auth
+    [\#527](https://github.com/matrix-org/matrix-js-sdk/pull/527)
+-   Make lots of OlmDevice asynchronous
+    [\#524](https://github.com/matrix-org/matrix-js-sdk/pull/524)
+-   Make crypto.decryptMessage return decryption results
+    [\#523](https://github.com/matrix-org/matrix-js-sdk/pull/523)
+
+# Changes in [0.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.0) (2017-08-15)
 
-Changes in [0.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.0) (2017-08-15)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.13...v0.8.0)
 
-BREAKING CHANGE
----------------
+## BREAKING CHANGE
 
 In order to support a move to a more scalable storage backend, we need to make
 a number of the APIs related end-to-end encryption asynchronous.
@@ -3787,1190 +3820,1198 @@ applications which support end-to-end encryption:
 
 2. The following APIs have been changed to return promises:
 
-   * `MatrixClient.getStoredDevicesForUser`
-   * `MatrixClient.getStoredDevice`
-   * `MatrixClient.setDeviceVerified`
-   * `MatrixClient.setDeviceBlocked`
-   * `MatrixClient.setDeviceKnown`
-   * `MatrixClient.getEventSenderDeviceInfo`
-   * `MatrixClient.isEventSenderVerified`
-   * `MatrixClient.importRoomKeys`
-
-   Applications using the results of any of the above methods will need to be
-   updated to wait for the result of the promise.
+    - `MatrixClient.getStoredDevicesForUser`
+    - `MatrixClient.getStoredDevice`
+    - `MatrixClient.setDeviceVerified`
+    - `MatrixClient.setDeviceBlocked`
+    - `MatrixClient.setDeviceKnown`
+    - `MatrixClient.getEventSenderDeviceInfo`
+    - `MatrixClient.isEventSenderVerified`
+    - `MatrixClient.importRoomKeys`
 
+    Applications using the results of any of the above methods will need to be
+    updated to wait for the result of the promise.
 
 3. `MatrixClient.listDeviceKeys` has been removed altogether. It's been
    deprecated for some time. Applications using it should instead be changed to
    use `MatrixClient.getStoredDevices`, which is similar but returns its results
    in a slightly different format.
 
+-   Make bits of `olmlib` asynchronous
+    [\#521](https://github.com/matrix-org/matrix-js-sdk/pull/521)
+-   Make some of DeviceList asynchronous
+    [\#520](https://github.com/matrix-org/matrix-js-sdk/pull/520)
+-   Make methods in crypto/algorithms async
+    [\#519](https://github.com/matrix-org/matrix-js-sdk/pull/519)
+-   Avoid sending unencrypted messages in e2e room
+    [\#518](https://github.com/matrix-org/matrix-js-sdk/pull/518)
+-   Make tests wait for syncs to happen
+    [\#517](https://github.com/matrix-org/matrix-js-sdk/pull/517)
+-   Make a load of methods in the 'Crypto' module asynchronous
+    [\#510](https://github.com/matrix-org/matrix-js-sdk/pull/510)
+-   Set `rawDisplayName` to `userId` if membership has `displayname=null`
+    [\#515](https://github.com/matrix-org/matrix-js-sdk/pull/515)
+-   Refactor handling of crypto events for async
+    [\#508](https://github.com/matrix-org/matrix-js-sdk/pull/508)
+-   Let event decryption be asynchronous
+    [\#509](https://github.com/matrix-org/matrix-js-sdk/pull/509)
+-   Transform `async` functions to bluebird promises
+    [\#511](https://github.com/matrix-org/matrix-js-sdk/pull/511)
+-   Add more group APIs
+    [\#512](https://github.com/matrix-org/matrix-js-sdk/pull/512)
+-   Retrying test: wait for localEchoUpdated event
+    [\#507](https://github.com/matrix-org/matrix-js-sdk/pull/507)
+-   Fix member events breaking on timeline reset, 2
+    [\#504](https://github.com/matrix-org/matrix-js-sdk/pull/504)
+-   Make bits of the js-sdk api asynchronous
+    [\#503](https://github.com/matrix-org/matrix-js-sdk/pull/503)
+-   Yet more js-sdk test deflakification
+    [\#499](https://github.com/matrix-org/matrix-js-sdk/pull/499)
+-   Fix racy 'matrixclient retrying' test
+    [\#497](https://github.com/matrix-org/matrix-js-sdk/pull/497)
+-   Fix spamming of key-share-requests
+    [\#495](https://github.com/matrix-org/matrix-js-sdk/pull/495)
+-   Add progress handler to `uploadContent`
+    [\#500](https://github.com/matrix-org/matrix-js-sdk/pull/500)
+-   Switch matrix-js-sdk to bluebird
+    [\#490](https://github.com/matrix-org/matrix-js-sdk/pull/490)
+-   Fix some more flakey tests
+    [\#492](https://github.com/matrix-org/matrix-js-sdk/pull/492)
+-   make the npm test script windows-friendly
+    [\#489](https://github.com/matrix-org/matrix-js-sdk/pull/489)
+-   Fix a bunch of races in the tests
+    [\#488](https://github.com/matrix-org/matrix-js-sdk/pull/488)
+-   Fix early return in MatrixClient.setGuestAccess
+    [\#487](https://github.com/matrix-org/matrix-js-sdk/pull/487)
+-   Remove testUtils.failTest
+    [\#486](https://github.com/matrix-org/matrix-js-sdk/pull/486)
+-   Add test:watch script
+    [\#485](https://github.com/matrix-org/matrix-js-sdk/pull/485)
+-   Make it possible to use async/await
+    [\#484](https://github.com/matrix-org/matrix-js-sdk/pull/484)
+-   Remove m.new_device support
+    [\#483](https://github.com/matrix-org/matrix-js-sdk/pull/483)
+-   Use access-token in header
+    [\#478](https://github.com/matrix-org/matrix-js-sdk/pull/478)
+-   Sanity-check response from /thirdparty/protocols
+    [\#482](https://github.com/matrix-org/matrix-js-sdk/pull/482)
+-   Avoid parsing plain-text errors as JSON
+    [\#479](https://github.com/matrix-org/matrix-js-sdk/pull/479)
+-   Use external mock-request
+    [\#481](https://github.com/matrix-org/matrix-js-sdk/pull/481)
+-   Fix some races in the tests
+    [\#480](https://github.com/matrix-org/matrix-js-sdk/pull/480)
+-   Fall back to MemoryCryptoStore if indexeddb fails
+    [\#475](https://github.com/matrix-org/matrix-js-sdk/pull/475)
+-   Fix load failure in firefox when indexedDB is disabled
+    [\#474](https://github.com/matrix-org/matrix-js-sdk/pull/474)
+-   Fix a race in a test
+    [\#471](https://github.com/matrix-org/matrix-js-sdk/pull/471)
+-   Avoid throwing an unhandled error when the indexeddb is deleted
+    [\#470](https://github.com/matrix-org/matrix-js-sdk/pull/470)
+-   fix jsdoc
+    [\#469](https://github.com/matrix-org/matrix-js-sdk/pull/469)
+-   Handle m.forwarded_room_key events
+    [\#468](https://github.com/matrix-org/matrix-js-sdk/pull/468)
+-   Improve error reporting from indexeddbstore.clearDatabase
+    [\#466](https://github.com/matrix-org/matrix-js-sdk/pull/466)
+-   Implement sharing of megolm keys
+    [\#454](https://github.com/matrix-org/matrix-js-sdk/pull/454)
+-   Process received room key requests
+    [\#449](https://github.com/matrix-org/matrix-js-sdk/pull/449)
+-   Send m.room_key_request events when we fail to decrypt an event
+    [\#448](https://github.com/matrix-org/matrix-js-sdk/pull/448)
+
+# Changes in [0.7.13](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.13) (2017-06-22)
 
- * Make bits of `olmlib` asynchronous
-   [\#521](https://github.com/matrix-org/matrix-js-sdk/pull/521)
- * Make some of DeviceList asynchronous
-   [\#520](https://github.com/matrix-org/matrix-js-sdk/pull/520)
- * Make methods in crypto/algorithms async
-   [\#519](https://github.com/matrix-org/matrix-js-sdk/pull/519)
- * Avoid sending unencrypted messages in e2e room
-   [\#518](https://github.com/matrix-org/matrix-js-sdk/pull/518)
- * Make tests wait for syncs to happen
-   [\#517](https://github.com/matrix-org/matrix-js-sdk/pull/517)
- * Make a load of methods in the 'Crypto' module asynchronous
-   [\#510](https://github.com/matrix-org/matrix-js-sdk/pull/510)
- * Set `rawDisplayName` to `userId` if membership has `displayname=null`
-   [\#515](https://github.com/matrix-org/matrix-js-sdk/pull/515)
- * Refactor handling of crypto events for async
-   [\#508](https://github.com/matrix-org/matrix-js-sdk/pull/508)
- * Let event decryption be asynchronous
-   [\#509](https://github.com/matrix-org/matrix-js-sdk/pull/509)
- * Transform `async` functions to bluebird promises
-   [\#511](https://github.com/matrix-org/matrix-js-sdk/pull/511)
- * Add more group APIs
-   [\#512](https://github.com/matrix-org/matrix-js-sdk/pull/512)
- * Retrying test: wait for localEchoUpdated event
-   [\#507](https://github.com/matrix-org/matrix-js-sdk/pull/507)
- * Fix member events breaking on timeline reset, 2
-   [\#504](https://github.com/matrix-org/matrix-js-sdk/pull/504)
- * Make bits of the js-sdk api asynchronous
-   [\#503](https://github.com/matrix-org/matrix-js-sdk/pull/503)
- * Yet more js-sdk test deflakification
-   [\#499](https://github.com/matrix-org/matrix-js-sdk/pull/499)
- * Fix racy 'matrixclient retrying' test
-   [\#497](https://github.com/matrix-org/matrix-js-sdk/pull/497)
- * Fix spamming of key-share-requests
-   [\#495](https://github.com/matrix-org/matrix-js-sdk/pull/495)
- * Add progress handler to `uploadContent`
-   [\#500](https://github.com/matrix-org/matrix-js-sdk/pull/500)
- * Switch matrix-js-sdk to bluebird
-   [\#490](https://github.com/matrix-org/matrix-js-sdk/pull/490)
- * Fix some more flakey tests
-   [\#492](https://github.com/matrix-org/matrix-js-sdk/pull/492)
- * make the npm test script windows-friendly
-   [\#489](https://github.com/matrix-org/matrix-js-sdk/pull/489)
- * Fix a bunch of races in the tests
-   [\#488](https://github.com/matrix-org/matrix-js-sdk/pull/488)
- * Fix early return in MatrixClient.setGuestAccess
-   [\#487](https://github.com/matrix-org/matrix-js-sdk/pull/487)
- * Remove testUtils.failTest
-   [\#486](https://github.com/matrix-org/matrix-js-sdk/pull/486)
- * Add test:watch script
-   [\#485](https://github.com/matrix-org/matrix-js-sdk/pull/485)
- * Make it possible to use async/await
-   [\#484](https://github.com/matrix-org/matrix-js-sdk/pull/484)
- * Remove m.new_device support
-   [\#483](https://github.com/matrix-org/matrix-js-sdk/pull/483)
- * Use access-token in header
-   [\#478](https://github.com/matrix-org/matrix-js-sdk/pull/478)
- * Sanity-check response from /thirdparty/protocols
-   [\#482](https://github.com/matrix-org/matrix-js-sdk/pull/482)
- * Avoid parsing plain-text errors as JSON
-   [\#479](https://github.com/matrix-org/matrix-js-sdk/pull/479)
- * Use external mock-request
-   [\#481](https://github.com/matrix-org/matrix-js-sdk/pull/481)
- * Fix some races in the tests
-   [\#480](https://github.com/matrix-org/matrix-js-sdk/pull/480)
- * Fall back to MemoryCryptoStore if indexeddb fails
-   [\#475](https://github.com/matrix-org/matrix-js-sdk/pull/475)
- * Fix load failure in firefox when indexedDB is disabled
-   [\#474](https://github.com/matrix-org/matrix-js-sdk/pull/474)
- * Fix a race in a test
-   [\#471](https://github.com/matrix-org/matrix-js-sdk/pull/471)
- * Avoid throwing an unhandled error when the indexeddb is deleted
-   [\#470](https://github.com/matrix-org/matrix-js-sdk/pull/470)
- * fix jsdoc
-   [\#469](https://github.com/matrix-org/matrix-js-sdk/pull/469)
- * Handle m.forwarded_room_key events
-   [\#468](https://github.com/matrix-org/matrix-js-sdk/pull/468)
- * Improve error reporting from indexeddbstore.clearDatabase
-   [\#466](https://github.com/matrix-org/matrix-js-sdk/pull/466)
- * Implement sharing of megolm keys
-   [\#454](https://github.com/matrix-org/matrix-js-sdk/pull/454)
- * Process received room key requests
-   [\#449](https://github.com/matrix-org/matrix-js-sdk/pull/449)
- * Send m.room_key_request events when we fail to decrypt an event
-   [\#448](https://github.com/matrix-org/matrix-js-sdk/pull/448)
-
-Changes in [0.7.13](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.13) (2017-06-22)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.12...v0.7.13)
 
- * Fix failure on Tor browser
-   [\#473](https://github.com/matrix-org/matrix-js-sdk/pull/473)
- * Fix issues with firefox private browsing
-   [\#472](https://github.com/matrix-org/matrix-js-sdk/pull/472)
+-   Fix failure on Tor browser
+    [\#473](https://github.com/matrix-org/matrix-js-sdk/pull/473)
+-   Fix issues with firefox private browsing
+    [\#472](https://github.com/matrix-org/matrix-js-sdk/pull/472)
+
+# Changes in [0.7.12](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12) (2017-06-19)
 
-Changes in [0.7.12](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12) (2017-06-19)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.12-rc.1...v0.7.12)
 
- * No changes
+-   No changes
 
+# Changes in [0.7.12-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12-rc.1) (2017-06-15)
 
-Changes in [0.7.12-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12-rc.1) (2017-06-15)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.11...v0.7.12-rc.1)
 
- * allow setting iceTransportPolicy to relay through forceTURN option
-   [\#462](https://github.com/matrix-org/matrix-js-sdk/pull/462)
+-   allow setting iceTransportPolicy to relay through forceTURN option
+    [\#462](https://github.com/matrix-org/matrix-js-sdk/pull/462)
+
+# Changes in [0.7.11](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11) (2017-06-12)
 
-Changes in [0.7.11](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11) (2017-06-12)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.11-rc.1...v0.7.11)
 
- * Add a bunch of logging around sending messages
-   [\#460](https://github.com/matrix-org/matrix-js-sdk/pull/460)
+-   Add a bunch of logging around sending messages
+    [\#460](https://github.com/matrix-org/matrix-js-sdk/pull/460)
+
+# Changes in [0.7.11-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11-rc.1) (2017-06-09)
 
-Changes in [0.7.11-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11-rc.1) (2017-06-09)
-============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.10...v0.7.11-rc.1)
 
- * Make TimelineWindow.load resolve quicker if we have the events
-   [\#458](https://github.com/matrix-org/matrix-js-sdk/pull/458)
- * Stop peeking when a matrix client is stopped
-   [\#451](https://github.com/matrix-org/matrix-js-sdk/pull/451)
- * Update README: Clarify how to install libolm
-   [\#450](https://github.com/matrix-org/matrix-js-sdk/pull/450)
+-   Make TimelineWindow.load resolve quicker if we have the events
+    [\#458](https://github.com/matrix-org/matrix-js-sdk/pull/458)
+-   Stop peeking when a matrix client is stopped
+    [\#451](https://github.com/matrix-org/matrix-js-sdk/pull/451)
+-   Update README: Clarify how to install libolm
+    [\#450](https://github.com/matrix-org/matrix-js-sdk/pull/450)
+
+# Changes in [0.7.10](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.10) (2017-06-02)
 
-Changes in [0.7.10](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.10) (2017-06-02)
-==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.9...v0.7.10)
 
- * BREAKING CHANGE: The SDK no longer ``require``s ``olm`` - instead it expects
-   libolm to be provided as an ``Olm`` global. This will only affect
-   applications which use end-to-end encryption. See the
-   [README](README.md#end-to-end-encryption-support) for details.
+-   BREAKING CHANGE: The SDK no longer `require`s `olm` - instead it expects
+    libolm to be provided as an `Olm` global. This will only affect
+    applications which use end-to-end encryption. See the
+    [README](README.md#end-to-end-encryption-support) for details.
+
+-   indexeddb-crypto-store: fix db deletion
+    [\#447](https://github.com/matrix-org/matrix-js-sdk/pull/447)
+-   Load Olm from the global rather than requiring it.
+    [\#446](https://github.com/matrix-org/matrix-js-sdk/pull/446)
 
- * indexeddb-crypto-store: fix db deletion
-   [\#447](https://github.com/matrix-org/matrix-js-sdk/pull/447)
- * Load Olm from the global rather than requiring it.
-   [\#446](https://github.com/matrix-org/matrix-js-sdk/pull/446)
+# Changes in [0.7.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.9) (2017-06-01)
 
-Changes in [0.7.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.9) (2017-06-01)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.8...v0.7.9)
 
- * Initial framework for indexeddb-backed crypto store
-   [\#445](https://github.com/matrix-org/matrix-js-sdk/pull/445)
- * Factor out reEmit to a common module
-   [\#444](https://github.com/matrix-org/matrix-js-sdk/pull/444)
- * crypto/algorithms/base.js: Convert to es6
-   [\#443](https://github.com/matrix-org/matrix-js-sdk/pull/443)
- * maySendRedactionForEvent for userId
-   [\#435](https://github.com/matrix-org/matrix-js-sdk/pull/435)
- * MatrixClient: add getUserId()
-   [\#441](https://github.com/matrix-org/matrix-js-sdk/pull/441)
- * Run jsdoc on a custom babeling of the source
-   [\#442](https://github.com/matrix-org/matrix-js-sdk/pull/442)
- * Add in a public api getStoredDevice allowing clients to get a specific
-   device
-   [\#439](https://github.com/matrix-org/matrix-js-sdk/pull/439)
-
-Changes in [0.7.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8) (2017-05-22)
-================================================================================================
+-   Initial framework for indexeddb-backed crypto store
+    [\#445](https://github.com/matrix-org/matrix-js-sdk/pull/445)
+-   Factor out reEmit to a common module
+    [\#444](https://github.com/matrix-org/matrix-js-sdk/pull/444)
+-   crypto/algorithms/base.js: Convert to es6
+    [\#443](https://github.com/matrix-org/matrix-js-sdk/pull/443)
+-   maySendRedactionForEvent for userId
+    [\#435](https://github.com/matrix-org/matrix-js-sdk/pull/435)
+-   MatrixClient: add getUserId()
+    [\#441](https://github.com/matrix-org/matrix-js-sdk/pull/441)
+-   Run jsdoc on a custom babeling of the source
+    [\#442](https://github.com/matrix-org/matrix-js-sdk/pull/442)
+-   Add in a public api getStoredDevice allowing clients to get a specific
+    device
+    [\#439](https://github.com/matrix-org/matrix-js-sdk/pull/439)
+
+# Changes in [0.7.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8) (2017-05-22)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.8-rc.1...v0.7.8)
 
- * No changes
+-   No changes
 
+# Changes in [0.7.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8-rc.1) (2017-05-19)
 
-Changes in [0.7.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8-rc.1) (2017-05-19)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.7...v0.7.8-rc.1)
 
- * Attempt to rework the release-tarball-signing stuff
-   [\#438](https://github.com/matrix-org/matrix-js-sdk/pull/438)
- * ability to specify webrtc audio/video inputs for the lib to request
-   [\#427](https://github.com/matrix-org/matrix-js-sdk/pull/427)
- * make screen sharing call FF friendly :D
-   [\#434](https://github.com/matrix-org/matrix-js-sdk/pull/434)
- * Fix race in device list updates
-   [\#431](https://github.com/matrix-org/matrix-js-sdk/pull/431)
- * WebRTC: Support recvonly for video for those without a webcam
-   [\#424](https://github.com/matrix-org/matrix-js-sdk/pull/424)
- * Update istanbul to remove minimatch DoS Warning
-   [\#422](https://github.com/matrix-org/matrix-js-sdk/pull/422)
- * webrtc/call: Make it much less likely that callIds collide locally
-   [\#423](https://github.com/matrix-org/matrix-js-sdk/pull/423)
- * Automatically complete dummy auth
-   [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
- * Don't leave the gh-pages branch checked out
-   [\#418](https://github.com/matrix-org/matrix-js-sdk/pull/418)
-
-Changes in [0.7.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7) (2017-04-25)
-================================================================================================
+-   Attempt to rework the release-tarball-signing stuff
+    [\#438](https://github.com/matrix-org/matrix-js-sdk/pull/438)
+-   ability to specify webrtc audio/video inputs for the lib to request
+    [\#427](https://github.com/matrix-org/matrix-js-sdk/pull/427)
+-   make screen sharing call FF friendly :D
+    [\#434](https://github.com/matrix-org/matrix-js-sdk/pull/434)
+-   Fix race in device list updates
+    [\#431](https://github.com/matrix-org/matrix-js-sdk/pull/431)
+-   WebRTC: Support recvonly for video for those without a webcam
+    [\#424](https://github.com/matrix-org/matrix-js-sdk/pull/424)
+-   Update istanbul to remove minimatch DoS Warning
+    [\#422](https://github.com/matrix-org/matrix-js-sdk/pull/422)
+-   webrtc/call: Make it much less likely that callIds collide locally
+    [\#423](https://github.com/matrix-org/matrix-js-sdk/pull/423)
+-   Automatically complete dummy auth
+    [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
+-   Don't leave the gh-pages branch checked out
+    [\#418](https://github.com/matrix-org/matrix-js-sdk/pull/418)
+
+# Changes in [0.7.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7) (2017-04-25)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.7-rc.1...v0.7.7)
 
- * No changes
+-   No changes
 
+# Changes in [0.7.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7-rc.1) (2017-04-21)
 
-Changes in [0.7.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7-rc.1) (2017-04-21)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.6...v0.7.7-rc.1)
 
- * Automatically complete dummy auth
-   [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
+-   Automatically complete dummy auth
+    [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
 
+# Changes in [0.7.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6) (2017-04-12)
 
-Changes in [0.7.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6) (2017-04-12)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.6-rc.2...v0.7.6)
 
- * No changes
+-   No changes
+
+# Changes in [0.7.6-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.2) (2017-04-10)
 
-Changes in [0.7.6-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.2) (2017-04-10)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.6-rc.1...v0.7.6-rc.2)
 
- * Add feature detection for webworkers
-   [\#416](https://github.com/matrix-org/matrix-js-sdk/pull/416)
- * Fix release script
-   [\#415](https://github.com/matrix-org/matrix-js-sdk/pull/415)
+-   Add feature detection for webworkers
+    [\#416](https://github.com/matrix-org/matrix-js-sdk/pull/416)
+-   Fix release script
+    [\#415](https://github.com/matrix-org/matrix-js-sdk/pull/415)
+
+# Changes in [0.7.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.1) (2017-04-07)
 
-Changes in [0.7.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.1) (2017-04-07)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5...v0.7.6-rc.1)
 
- * Make indexeddb save after the first sync
-   [\#414](https://github.com/matrix-org/matrix-js-sdk/pull/414)
- * Make indexeddb startup faster
-   [\#413](https://github.com/matrix-org/matrix-js-sdk/pull/413)
- * Add ability to do indexeddb sync work in webworker
-   [\#412](https://github.com/matrix-org/matrix-js-sdk/pull/412)
- * Move more functionality to the indexeddb backend
-   [\#409](https://github.com/matrix-org/matrix-js-sdk/pull/409)
- * Indicate syncState ERROR after many failed /syncs
-   [\#410](https://github.com/matrix-org/matrix-js-sdk/pull/410)
- * Further reorganising of indexeddb sync code
-   [\#407](https://github.com/matrix-org/matrix-js-sdk/pull/407)
- * Change interface of IndexedDBStore: hide internals
-   [\#406](https://github.com/matrix-org/matrix-js-sdk/pull/406)
- * Don't be SYNCING until updating from the server
-   [\#405](https://github.com/matrix-org/matrix-js-sdk/pull/405)
- * Don't log the entire /sync response
-   [\#403](https://github.com/matrix-org/matrix-js-sdk/pull/403)
- * webrtc/call: Assign MediaStream to video element srcObject
-   [\#402](https://github.com/matrix-org/matrix-js-sdk/pull/402)
- * Fix undefined reference in http-api
-   [\#400](https://github.com/matrix-org/matrix-js-sdk/pull/400)
- * Add copyright header to event-timeline.js
-   [\#382](https://github.com/matrix-org/matrix-js-sdk/pull/382)
- * client: fix docs for user-scoped account_data events
-   [\#397](https://github.com/matrix-org/matrix-js-sdk/pull/397)
- * Add a CONTRIBUTING for js-sdk
-   [\#399](https://github.com/matrix-org/matrix-js-sdk/pull/399)
- * Fix leaking room state objects on limited sync responses
-   [\#395](https://github.com/matrix-org/matrix-js-sdk/pull/395)
- * Extend 'ignoreFailure' to be 'background'
-   [\#396](https://github.com/matrix-org/matrix-js-sdk/pull/396)
- * Add x_show_msisdn parameter to register calls
-   [\#388](https://github.com/matrix-org/matrix-js-sdk/pull/388)
- * Update event redaction to keep sender and origin_server_ts
-   [\#394](https://github.com/matrix-org/matrix-js-sdk/pull/394)
- * Handle 'limited' timeline responses in the SyncAccumulator
-   [\#393](https://github.com/matrix-org/matrix-js-sdk/pull/393)
- * Give a better error message if the HS doesn't support msisdn registeration
-   [\#391](https://github.com/matrix-org/matrix-js-sdk/pull/391)
- * Add getEmailSid
-   [\#383](https://github.com/matrix-org/matrix-js-sdk/pull/383)
- * Add m.login.email.identity support to UI auth
-   [\#380](https://github.com/matrix-org/matrix-js-sdk/pull/380)
- * src/client.js: Fix incorrect roomId reference in VoIP glare code
-   [\#381](https://github.com/matrix-org/matrix-js-sdk/pull/381)
- * add .editorconfig
-   [\#379](https://github.com/matrix-org/matrix-js-sdk/pull/379)
- * Store account data in the same way as room data
-   [\#377](https://github.com/matrix-org/matrix-js-sdk/pull/377)
- * Upload one-time keys on /sync rather than a timer
-   [\#376](https://github.com/matrix-org/matrix-js-sdk/pull/376)
- * Increase the WRITE_DELAY on database syncing
-   [\#374](https://github.com/matrix-org/matrix-js-sdk/pull/374)
- * Make deleteAllData() return a Promise
-   [\#373](https://github.com/matrix-org/matrix-js-sdk/pull/373)
- * Don't include banned users in the room name
-   [\#372](https://github.com/matrix-org/matrix-js-sdk/pull/372)
- * Support IndexedDB as a backing store
-   [\#363](https://github.com/matrix-org/matrix-js-sdk/pull/363)
- * Poll /sync with a short timeout while catching up
-   [\#370](https://github.com/matrix-org/matrix-js-sdk/pull/370)
- * Make test coverage work again
-   [\#368](https://github.com/matrix-org/matrix-js-sdk/pull/368)
- * Add docs to event
-   [\#367](https://github.com/matrix-org/matrix-js-sdk/pull/367)
- * Keep the device-sync token more up-to-date
-   [\#366](https://github.com/matrix-org/matrix-js-sdk/pull/366)
- * Fix race conditions in device list download
-   [\#365](https://github.com/matrix-org/matrix-js-sdk/pull/365)
- * Fix the unban method
-   [\#364](https://github.com/matrix-org/matrix-js-sdk/pull/364)
- * Spread out device verification work
-   [\#362](https://github.com/matrix-org/matrix-js-sdk/pull/362)
- * Clean up/improve e2e logging
-   [\#361](https://github.com/matrix-org/matrix-js-sdk/pull/361)
- * Fix decryption of events whose key arrives later
-   [\#360](https://github.com/matrix-org/matrix-js-sdk/pull/360)
- * Invalidate device lists when encryption is enabled in a room
-   [\#359](https://github.com/matrix-org/matrix-js-sdk/pull/359)
- * Switch from jasmine to mocha + expect + lolex
-   [\#358](https://github.com/matrix-org/matrix-js-sdk/pull/358)
- * Install source-map-support in each test
-   [\#356](https://github.com/matrix-org/matrix-js-sdk/pull/356)
- * searchMessageText: avoid setting keys=undefined
-   [\#357](https://github.com/matrix-org/matrix-js-sdk/pull/357)
- * realtime-callbacks: pass `global` as `this`
-   [\#355](https://github.com/matrix-org/matrix-js-sdk/pull/355)
- * Make the tests work without olm
-   [\#354](https://github.com/matrix-org/matrix-js-sdk/pull/354)
- * Tests: Factor out TestClient and use it in crypto tests
-   [\#353](https://github.com/matrix-org/matrix-js-sdk/pull/353)
- * Fix some lint
-   [\#352](https://github.com/matrix-org/matrix-js-sdk/pull/352)
- * Make a sig for source tarballs when releasing
-   [\#351](https://github.com/matrix-org/matrix-js-sdk/pull/351)
- * When doing a pre-release, don't bother merging to master and develop.
-   [\#350](https://github.com/matrix-org/matrix-js-sdk/pull/350)
-
-Changes in [0.7.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5) (2017-02-04)
-================================================================================================
+-   Make indexeddb save after the first sync
+    [\#414](https://github.com/matrix-org/matrix-js-sdk/pull/414)
+-   Make indexeddb startup faster
+    [\#413](https://github.com/matrix-org/matrix-js-sdk/pull/413)
+-   Add ability to do indexeddb sync work in webworker
+    [\#412](https://github.com/matrix-org/matrix-js-sdk/pull/412)
+-   Move more functionality to the indexeddb backend
+    [\#409](https://github.com/matrix-org/matrix-js-sdk/pull/409)
+-   Indicate syncState ERROR after many failed /syncs
+    [\#410](https://github.com/matrix-org/matrix-js-sdk/pull/410)
+-   Further reorganising of indexeddb sync code
+    [\#407](https://github.com/matrix-org/matrix-js-sdk/pull/407)
+-   Change interface of IndexedDBStore: hide internals
+    [\#406](https://github.com/matrix-org/matrix-js-sdk/pull/406)
+-   Don't be SYNCING until updating from the server
+    [\#405](https://github.com/matrix-org/matrix-js-sdk/pull/405)
+-   Don't log the entire /sync response
+    [\#403](https://github.com/matrix-org/matrix-js-sdk/pull/403)
+-   webrtc/call: Assign MediaStream to video element srcObject
+    [\#402](https://github.com/matrix-org/matrix-js-sdk/pull/402)
+-   Fix undefined reference in http-api
+    [\#400](https://github.com/matrix-org/matrix-js-sdk/pull/400)
+-   Add copyright header to event-timeline.js
+    [\#382](https://github.com/matrix-org/matrix-js-sdk/pull/382)
+-   client: fix docs for user-scoped account_data events
+    [\#397](https://github.com/matrix-org/matrix-js-sdk/pull/397)
+-   Add a CONTRIBUTING for js-sdk
+    [\#399](https://github.com/matrix-org/matrix-js-sdk/pull/399)
+-   Fix leaking room state objects on limited sync responses
+    [\#395](https://github.com/matrix-org/matrix-js-sdk/pull/395)
+-   Extend 'ignoreFailure' to be 'background'
+    [\#396](https://github.com/matrix-org/matrix-js-sdk/pull/396)
+-   Add x_show_msisdn parameter to register calls
+    [\#388](https://github.com/matrix-org/matrix-js-sdk/pull/388)
+-   Update event redaction to keep sender and origin_server_ts
+    [\#394](https://github.com/matrix-org/matrix-js-sdk/pull/394)
+-   Handle 'limited' timeline responses in the SyncAccumulator
+    [\#393](https://github.com/matrix-org/matrix-js-sdk/pull/393)
+-   Give a better error message if the HS doesn't support msisdn registeration
+    [\#391](https://github.com/matrix-org/matrix-js-sdk/pull/391)
+-   Add getEmailSid
+    [\#383](https://github.com/matrix-org/matrix-js-sdk/pull/383)
+-   Add m.login.email.identity support to UI auth
+    [\#380](https://github.com/matrix-org/matrix-js-sdk/pull/380)
+-   src/client.js: Fix incorrect roomId reference in VoIP glare code
+    [\#381](https://github.com/matrix-org/matrix-js-sdk/pull/381)
+-   add .editorconfig
+    [\#379](https://github.com/matrix-org/matrix-js-sdk/pull/379)
+-   Store account data in the same way as room data
+    [\#377](https://github.com/matrix-org/matrix-js-sdk/pull/377)
+-   Upload one-time keys on /sync rather than a timer
+    [\#376](https://github.com/matrix-org/matrix-js-sdk/pull/376)
+-   Increase the WRITE_DELAY on database syncing
+    [\#374](https://github.com/matrix-org/matrix-js-sdk/pull/374)
+-   Make deleteAllData() return a Promise
+    [\#373](https://github.com/matrix-org/matrix-js-sdk/pull/373)
+-   Don't include banned users in the room name
+    [\#372](https://github.com/matrix-org/matrix-js-sdk/pull/372)
+-   Support IndexedDB as a backing store
+    [\#363](https://github.com/matrix-org/matrix-js-sdk/pull/363)
+-   Poll /sync with a short timeout while catching up
+    [\#370](https://github.com/matrix-org/matrix-js-sdk/pull/370)
+-   Make test coverage work again
+    [\#368](https://github.com/matrix-org/matrix-js-sdk/pull/368)
+-   Add docs to event
+    [\#367](https://github.com/matrix-org/matrix-js-sdk/pull/367)
+-   Keep the device-sync token more up-to-date
+    [\#366](https://github.com/matrix-org/matrix-js-sdk/pull/366)
+-   Fix race conditions in device list download
+    [\#365](https://github.com/matrix-org/matrix-js-sdk/pull/365)
+-   Fix the unban method
+    [\#364](https://github.com/matrix-org/matrix-js-sdk/pull/364)
+-   Spread out device verification work
+    [\#362](https://github.com/matrix-org/matrix-js-sdk/pull/362)
+-   Clean up/improve e2e logging
+    [\#361](https://github.com/matrix-org/matrix-js-sdk/pull/361)
+-   Fix decryption of events whose key arrives later
+    [\#360](https://github.com/matrix-org/matrix-js-sdk/pull/360)
+-   Invalidate device lists when encryption is enabled in a room
+    [\#359](https://github.com/matrix-org/matrix-js-sdk/pull/359)
+-   Switch from jasmine to mocha + expect + lolex
+    [\#358](https://github.com/matrix-org/matrix-js-sdk/pull/358)
+-   Install source-map-support in each test
+    [\#356](https://github.com/matrix-org/matrix-js-sdk/pull/356)
+-   searchMessageText: avoid setting keys=undefined
+    [\#357](https://github.com/matrix-org/matrix-js-sdk/pull/357)
+-   realtime-callbacks: pass `global` as `this`
+    [\#355](https://github.com/matrix-org/matrix-js-sdk/pull/355)
+-   Make the tests work without olm
+    [\#354](https://github.com/matrix-org/matrix-js-sdk/pull/354)
+-   Tests: Factor out TestClient and use it in crypto tests
+    [\#353](https://github.com/matrix-org/matrix-js-sdk/pull/353)
+-   Fix some lint
+    [\#352](https://github.com/matrix-org/matrix-js-sdk/pull/352)
+-   Make a sig for source tarballs when releasing
+    [\#351](https://github.com/matrix-org/matrix-js-sdk/pull/351)
+-   When doing a pre-release, don't bother merging to master and develop.
+    [\#350](https://github.com/matrix-org/matrix-js-sdk/pull/350)
+
+# Changes in [0.7.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5) (2017-02-04)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5-rc.3...v0.7.5)
 
 No changes from 0.7.5-rc.3
 
-Changes in [0.7.5-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.3) (2017-02-03)
-==========================================================================================================
+# Changes in [0.7.5-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.3) (2017-02-03)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5-rc.2...v0.7.5-rc.3)
 
- * Include DeviceInfo in deviceVerificationChanged events
-   [a3cc8eb](https://github.com/matrix-org/matrix-js-sdk/commit/a3cc8eb1f6d165576a342596f638316721cb26b6)
- * Fix device list update
-   [5fd7410](https://github.com/matrix-org/matrix-js-sdk/commit/5fd74109ffc56b73deb40c2604d84c38b8032c40)
+-   Include DeviceInfo in deviceVerificationChanged events
+    [a3cc8eb](https://github.com/matrix-org/matrix-js-sdk/commit/a3cc8eb1f6d165576a342596f638316721cb26b6)
+-   Fix device list update
+    [5fd7410](https://github.com/matrix-org/matrix-js-sdk/commit/5fd74109ffc56b73deb40c2604d84c38b8032c40)
 
+# Changes in [0.7.5-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.2) (2017-02-03)
 
-Changes in [0.7.5-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.2) (2017-02-03)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5-rc.1...v0.7.5-rc.2)
 
- * Use the device change notifications interface
-   [\#348](https://github.com/matrix-org/matrix-js-sdk/pull/348)
- * Rewrite the device key query logic
-   [\#347](https://github.com/matrix-org/matrix-js-sdk/pull/347)
+-   Use the device change notifications interface
+    [\#348](https://github.com/matrix-org/matrix-js-sdk/pull/348)
+-   Rewrite the device key query logic
+    [\#347](https://github.com/matrix-org/matrix-js-sdk/pull/347)
+
+# Changes in [0.7.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.1) (2017-02-03)
 
-Changes in [0.7.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.1) (2017-02-03)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.4...v0.7.5-rc.1)
 
- * Support for blacklisting unverified devices, both per-room and globally
-   [\#336](https://github.com/matrix-org/matrix-js-sdk/pull/336)
- * track errors when events can't be sent
-   [\#349](https://github.com/matrix-org/matrix-js-sdk/pull/349)
- * Factor out device list management
-   [\#346](https://github.com/matrix-org/matrix-js-sdk/pull/346)
- * Support for warning users when unknown devices show up
-   [\#335](https://github.com/matrix-org/matrix-js-sdk/pull/335)
- * Enable sourcemaps in browserified distro
-   [\#345](https://github.com/matrix-org/matrix-js-sdk/pull/345)
- * Record all e2e room settings in localstorage
-   [\#344](https://github.com/matrix-org/matrix-js-sdk/pull/344)
- * Make Olm work with browserified js-sdk
-   [\#340](https://github.com/matrix-org/matrix-js-sdk/pull/340)
- * Make browserify a dev dependency
-   [\#339](https://github.com/matrix-org/matrix-js-sdk/pull/339)
- * Allow single line brace-style
-   [\#338](https://github.com/matrix-org/matrix-js-sdk/pull/338)
- * Turn on comma-dangle for function calls
-   [\#333](https://github.com/matrix-org/matrix-js-sdk/pull/333)
- * Add prefer-const
-   [\#331](https://github.com/matrix-org/matrix-js-sdk/pull/331)
- * Support for importing and exporting megolm sessions
-   [\#326](https://github.com/matrix-org/matrix-js-sdk/pull/326)
- * Fix linting on all tests
-   [\#329](https://github.com/matrix-org/matrix-js-sdk/pull/329)
- * Fix ESLint warnings and errors
-   [\#325](https://github.com/matrix-org/matrix-js-sdk/pull/325)
- * BREAKING CHANGE: Remove WebStorageStore
-   [\#324](https://github.com/matrix-org/matrix-js-sdk/pull/324)
-
-Changes in [0.7.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4) (2017-01-16)
-================================================================================================
+-   Support for blacklisting unverified devices, both per-room and globally
+    [\#336](https://github.com/matrix-org/matrix-js-sdk/pull/336)
+-   track errors when events can't be sent
+    [\#349](https://github.com/matrix-org/matrix-js-sdk/pull/349)
+-   Factor out device list management
+    [\#346](https://github.com/matrix-org/matrix-js-sdk/pull/346)
+-   Support for warning users when unknown devices show up
+    [\#335](https://github.com/matrix-org/matrix-js-sdk/pull/335)
+-   Enable sourcemaps in browserified distro
+    [\#345](https://github.com/matrix-org/matrix-js-sdk/pull/345)
+-   Record all e2e room settings in localstorage
+    [\#344](https://github.com/matrix-org/matrix-js-sdk/pull/344)
+-   Make Olm work with browserified js-sdk
+    [\#340](https://github.com/matrix-org/matrix-js-sdk/pull/340)
+-   Make browserify a dev dependency
+    [\#339](https://github.com/matrix-org/matrix-js-sdk/pull/339)
+-   Allow single line brace-style
+    [\#338](https://github.com/matrix-org/matrix-js-sdk/pull/338)
+-   Turn on comma-dangle for function calls
+    [\#333](https://github.com/matrix-org/matrix-js-sdk/pull/333)
+-   Add prefer-const
+    [\#331](https://github.com/matrix-org/matrix-js-sdk/pull/331)
+-   Support for importing and exporting megolm sessions
+    [\#326](https://github.com/matrix-org/matrix-js-sdk/pull/326)
+-   Fix linting on all tests
+    [\#329](https://github.com/matrix-org/matrix-js-sdk/pull/329)
+-   Fix ESLint warnings and errors
+    [\#325](https://github.com/matrix-org/matrix-js-sdk/pull/325)
+-   BREAKING CHANGE: Remove WebStorageStore
+    [\#324](https://github.com/matrix-org/matrix-js-sdk/pull/324)
+
+# Changes in [0.7.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4) (2017-01-16)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.4-rc.1...v0.7.4)
 
- * Fix non-conference calling
+-   Fix non-conference calling
+
+# Changes in [0.7.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4-rc.1) (2017-01-13)
 
-Changes in [0.7.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4-rc.1) (2017-01-13)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.3...v0.7.4-rc.1)
 
- * Remove babel-polyfill
-   [\#321](https://github.com/matrix-org/matrix-js-sdk/pull/321)
- * Update build process for ES6
-   [\#320](https://github.com/matrix-org/matrix-js-sdk/pull/320)
- * 'babel' is not a babel package anymore
-   [\#319](https://github.com/matrix-org/matrix-js-sdk/pull/319)
- * Add Babel for ES6 support
-   [\#318](https://github.com/matrix-org/matrix-js-sdk/pull/318)
- * Move screen sharing check/error
-   [\#317](https://github.com/matrix-org/matrix-js-sdk/pull/317)
- * release.sh: Bail early if there are uncommitted changes
-   [\#316](https://github.com/matrix-org/matrix-js-sdk/pull/316)
-
-Changes in [0.7.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.3) (2017-01-04)
-================================================================================================
+-   Remove babel-polyfill
+    [\#321](https://github.com/matrix-org/matrix-js-sdk/pull/321)
+-   Update build process for ES6
+    [\#320](https://github.com/matrix-org/matrix-js-sdk/pull/320)
+-   'babel' is not a babel package anymore
+    [\#319](https://github.com/matrix-org/matrix-js-sdk/pull/319)
+-   Add Babel for ES6 support
+    [\#318](https://github.com/matrix-org/matrix-js-sdk/pull/318)
+-   Move screen sharing check/error
+    [\#317](https://github.com/matrix-org/matrix-js-sdk/pull/317)
+-   release.sh: Bail early if there are uncommitted changes
+    [\#316](https://github.com/matrix-org/matrix-js-sdk/pull/316)
+
+# Changes in [0.7.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.3) (2017-01-04)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.2...v0.7.3)
 
- * User presence list feature
-   [\#310](https://github.com/matrix-org/matrix-js-sdk/pull/310)
- * Allow clients the ability to set a default local timeout
-   [\#313](https://github.com/matrix-org/matrix-js-sdk/pull/313)
- * Add API to delete threepid
-   [\#312](https://github.com/matrix-org/matrix-js-sdk/pull/312)
+-   User presence list feature
+    [\#310](https://github.com/matrix-org/matrix-js-sdk/pull/310)
+-   Allow clients the ability to set a default local timeout
+    [\#313](https://github.com/matrix-org/matrix-js-sdk/pull/313)
+-   Add API to delete threepid
+    [\#312](https://github.com/matrix-org/matrix-js-sdk/pull/312)
+
+# Changes in [0.7.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.2) (2016-12-15)
 
-Changes in [0.7.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.2) (2016-12-15)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.1...v0.7.2)
 
- * Bump to Olm 2.0
-   [\#309](https://github.com/matrix-org/matrix-js-sdk/pull/309)
- * Sanity check payload length before encrypting
-   [\#307](https://github.com/matrix-org/matrix-js-sdk/pull/307)
- * Remove dead _sendPingToDevice function
-   [\#308](https://github.com/matrix-org/matrix-js-sdk/pull/308)
- * Add setRoomDirectoryVisibilityAppService
-   [\#306](https://github.com/matrix-org/matrix-js-sdk/pull/306)
- * Update release script to do signed releases
-   [\#305](https://github.com/matrix-org/matrix-js-sdk/pull/305)
- * e2e: Wait for pending device lists
-   [\#304](https://github.com/matrix-org/matrix-js-sdk/pull/304)
- * Start a new megolm session when devices are blacklisted
-   [\#303](https://github.com/matrix-org/matrix-js-sdk/pull/303)
- * E2E: Download our own devicelist on startup
-   [\#302](https://github.com/matrix-org/matrix-js-sdk/pull/302)
-
-Changes in [0.7.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1) (2016-12-09)
-================================================================================================
+-   Bump to Olm 2.0
+    [\#309](https://github.com/matrix-org/matrix-js-sdk/pull/309)
+-   Sanity check payload length before encrypting
+    [\#307](https://github.com/matrix-org/matrix-js-sdk/pull/307)
+-   Remove dead \_sendPingToDevice function
+    [\#308](https://github.com/matrix-org/matrix-js-sdk/pull/308)
+-   Add setRoomDirectoryVisibilityAppService
+    [\#306](https://github.com/matrix-org/matrix-js-sdk/pull/306)
+-   Update release script to do signed releases
+    [\#305](https://github.com/matrix-org/matrix-js-sdk/pull/305)
+-   e2e: Wait for pending device lists
+    [\#304](https://github.com/matrix-org/matrix-js-sdk/pull/304)
+-   Start a new megolm session when devices are blacklisted
+    [\#303](https://github.com/matrix-org/matrix-js-sdk/pull/303)
+-   E2E: Download our own devicelist on startup
+    [\#302](https://github.com/matrix-org/matrix-js-sdk/pull/302)
+
+# Changes in [0.7.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1) (2016-12-09)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.1-rc.1...v0.7.1)
 
 No changes
 
+# Changes in [0.7.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1-rc.1) (2016-12-05)
 
-Changes in [0.7.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1-rc.1) (2016-12-05)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.0...v0.7.1-rc.1)
 
- * Avoid NPE when no sessionStore is given
-   [\#300](https://github.com/matrix-org/matrix-js-sdk/pull/300)
- * Improve decryption error messages
-   [\#299](https://github.com/matrix-org/matrix-js-sdk/pull/299)
- * Revert "Use native Array.isArray when available."
-   [\#283](https://github.com/matrix-org/matrix-js-sdk/pull/283)
- * Use native Array.isArray when available.
-   [\#282](https://github.com/matrix-org/matrix-js-sdk/pull/282)
-
-Changes in [0.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.0) (2016-11-18)
-================================================================================================
+-   Avoid NPE when no sessionStore is given
+    [\#300](https://github.com/matrix-org/matrix-js-sdk/pull/300)
+-   Improve decryption error messages
+    [\#299](https://github.com/matrix-org/matrix-js-sdk/pull/299)
+-   Revert "Use native Array.isArray when available."
+    [\#283](https://github.com/matrix-org/matrix-js-sdk/pull/283)
+-   Use native Array.isArray when available.
+    [\#282](https://github.com/matrix-org/matrix-js-sdk/pull/282)
+
+# Changes in [0.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.0) (2016-11-18)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.4...v0.7.0)
 
- * Avoid a packetstorm of device queries on startup
-   [\#297](https://github.com/matrix-org/matrix-js-sdk/pull/297)
- * E2E: Check devices to share keys with on each send
-   [\#295](https://github.com/matrix-org/matrix-js-sdk/pull/295)
- * Apply unknown-keyshare mitigations
-   [\#296](https://github.com/matrix-org/matrix-js-sdk/pull/296)
- * distinguish unknown users from deviceless users
-   [\#294](https://github.com/matrix-org/matrix-js-sdk/pull/294)
- * Allow starting client with initialSyncLimit = 0
-   [\#293](https://github.com/matrix-org/matrix-js-sdk/pull/293)
- * Make timeline-window _unpaginate public and rename to unpaginate
-   [\#289](https://github.com/matrix-org/matrix-js-sdk/pull/289)
- * Send a STOPPED sync updated after call to stopClient
-   [\#286](https://github.com/matrix-org/matrix-js-sdk/pull/286)
- * Fix bug in verifying megolm event senders
-   [\#292](https://github.com/matrix-org/matrix-js-sdk/pull/292)
- * Handle decryption of events after they arrive
-   [\#288](https://github.com/matrix-org/matrix-js-sdk/pull/288)
- * Fix examples.
-   [\#287](https://github.com/matrix-org/matrix-js-sdk/pull/287)
- * Add a travis.yml
-   [\#278](https://github.com/matrix-org/matrix-js-sdk/pull/278)
- * Encrypt all events, including 'm.call.*'
-   [\#277](https://github.com/matrix-org/matrix-js-sdk/pull/277)
- * Ignore reshares of known megolm sessions
-   [\#276](https://github.com/matrix-org/matrix-js-sdk/pull/276)
- * Log to the console on unknown session
-   [\#274](https://github.com/matrix-org/matrix-js-sdk/pull/274)
- * Make it easier for SDK users to wrap prevailing the 'request' function
-   [\#273](https://github.com/matrix-org/matrix-js-sdk/pull/273)
-
-Changes in [0.6.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4) (2016-11-04)
-================================================================================================
+-   Avoid a packetstorm of device queries on startup
+    [\#297](https://github.com/matrix-org/matrix-js-sdk/pull/297)
+-   E2E: Check devices to share keys with on each send
+    [\#295](https://github.com/matrix-org/matrix-js-sdk/pull/295)
+-   Apply unknown-keyshare mitigations
+    [\#296](https://github.com/matrix-org/matrix-js-sdk/pull/296)
+-   distinguish unknown users from deviceless users
+    [\#294](https://github.com/matrix-org/matrix-js-sdk/pull/294)
+-   Allow starting client with initialSyncLimit = 0
+    [\#293](https://github.com/matrix-org/matrix-js-sdk/pull/293)
+-   Make timeline-window \_unpaginate public and rename to unpaginate
+    [\#289](https://github.com/matrix-org/matrix-js-sdk/pull/289)
+-   Send a STOPPED sync updated after call to stopClient
+    [\#286](https://github.com/matrix-org/matrix-js-sdk/pull/286)
+-   Fix bug in verifying megolm event senders
+    [\#292](https://github.com/matrix-org/matrix-js-sdk/pull/292)
+-   Handle decryption of events after they arrive
+    [\#288](https://github.com/matrix-org/matrix-js-sdk/pull/288)
+-   Fix examples.
+    [\#287](https://github.com/matrix-org/matrix-js-sdk/pull/287)
+-   Add a travis.yml
+    [\#278](https://github.com/matrix-org/matrix-js-sdk/pull/278)
+-   Encrypt all events, including 'm.call.\*'
+    [\#277](https://github.com/matrix-org/matrix-js-sdk/pull/277)
+-   Ignore reshares of known megolm sessions
+    [\#276](https://github.com/matrix-org/matrix-js-sdk/pull/276)
+-   Log to the console on unknown session
+    [\#274](https://github.com/matrix-org/matrix-js-sdk/pull/274)
+-   Make it easier for SDK users to wrap prevailing the 'request' function
+    [\#273](https://github.com/matrix-org/matrix-js-sdk/pull/273)
+
+# Changes in [0.6.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4) (2016-11-04)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.4-rc.2...v0.6.4)
 
- * Change release script to pass version by environment variable
+-   Change release script to pass version by environment variable
 
+# Changes in [0.6.4-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.2) (2016-11-02)
 
-Changes in [0.6.4-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.2) (2016-11-02)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.4-rc.1...v0.6.4-rc.2)
 
- * Add getRoomTags method to client
-   [\#236](https://github.com/matrix-org/matrix-js-sdk/pull/236)
+-   Add getRoomTags method to client
+    [\#236](https://github.com/matrix-org/matrix-js-sdk/pull/236)
+
+# Changes in [0.6.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.1) (2016-11-02)
 
-Changes in [0.6.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.1) (2016-11-02)
-==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.3...v0.6.4-rc.1)
 
-Breaking Changes
-----------------
- * Bundled version of the JS SDK are no longer versioned along with
-   source files in the dist/ directory. As of this release, they
-   will be included in the release tarball, but not the source
-   repository.
-
-Other Changes
--------------
- * More fixes to the release script
-   [\#272](https://github.com/matrix-org/matrix-js-sdk/pull/272)
- * Update the release process to use github releases
-   [\#271](https://github.com/matrix-org/matrix-js-sdk/pull/271)
- * Don't package the world when we release
-   [\#270](https://github.com/matrix-org/matrix-js-sdk/pull/270)
- * Add ability to set a filter prior to the first /sync
-   [\#269](https://github.com/matrix-org/matrix-js-sdk/pull/269)
- * Sign one-time keys, and verify their signatures
-   [\#243](https://github.com/matrix-org/matrix-js-sdk/pull/243)
- * Check for duplicate message indexes for group messages
-   [\#241](https://github.com/matrix-org/matrix-js-sdk/pull/241)
- * Rotate megolm sessions
-   [\#240](https://github.com/matrix-org/matrix-js-sdk/pull/240)
- * Check recipient and sender in Olm messages
-   [\#239](https://github.com/matrix-org/matrix-js-sdk/pull/239)
- * Consistency checks for E2E device downloads
-   [\#237](https://github.com/matrix-org/matrix-js-sdk/pull/237)
- * Support User-Interactive auth for delete device
-   [\#235](https://github.com/matrix-org/matrix-js-sdk/pull/235)
- * Utility to help with interactive auth
-   [\#234](https://github.com/matrix-org/matrix-js-sdk/pull/234)
- * Fix sync breaking when an invalid filterId is in localStorage
-   [\#228](https://github.com/matrix-org/matrix-js-sdk/pull/228)
-
-Changes in [0.6.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.3) (2016-10-12)
-================================================================================================
+## Breaking Changes
+
+-   Bundled version of the JS SDK are no longer versioned along with
+    source files in the dist/ directory. As of this release, they
+    will be included in the release tarball, but not the source
+    repository.
+
+## Other Changes
+
+-   More fixes to the release script
+    [\#272](https://github.com/matrix-org/matrix-js-sdk/pull/272)
+-   Update the release process to use github releases
+    [\#271](https://github.com/matrix-org/matrix-js-sdk/pull/271)
+-   Don't package the world when we release
+    [\#270](https://github.com/matrix-org/matrix-js-sdk/pull/270)
+-   Add ability to set a filter prior to the first /sync
+    [\#269](https://github.com/matrix-org/matrix-js-sdk/pull/269)
+-   Sign one-time keys, and verify their signatures
+    [\#243](https://github.com/matrix-org/matrix-js-sdk/pull/243)
+-   Check for duplicate message indexes for group messages
+    [\#241](https://github.com/matrix-org/matrix-js-sdk/pull/241)
+-   Rotate megolm sessions
+    [\#240](https://github.com/matrix-org/matrix-js-sdk/pull/240)
+-   Check recipient and sender in Olm messages
+    [\#239](https://github.com/matrix-org/matrix-js-sdk/pull/239)
+-   Consistency checks for E2E device downloads
+    [\#237](https://github.com/matrix-org/matrix-js-sdk/pull/237)
+-   Support User-Interactive auth for delete device
+    [\#235](https://github.com/matrix-org/matrix-js-sdk/pull/235)
+-   Utility to help with interactive auth
+    [\#234](https://github.com/matrix-org/matrix-js-sdk/pull/234)
+-   Fix sync breaking when an invalid filterId is in localStorage
+    [\#228](https://github.com/matrix-org/matrix-js-sdk/pull/228)
+
+# Changes in [0.6.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.3) (2016-10-12)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.2...v0.6.3)
 
-Breaking Changes
-----------------
- * Add a 'RECONNECTING' state to the sync states. This is an additional state
-   between 'SYNCING' and 'ERROR', so most clients should not notice.
-
-Other Changes
-----------------
- * Fix params getting replaced on register calls
-   [\#233](https://github.com/matrix-org/matrix-js-sdk/pull/233)
- * Fix potential 30s delay on reconnect
-   [\#232](https://github.com/matrix-org/matrix-js-sdk/pull/232)
- * uploadContent: Attempt some consistency between browser and node
-   [\#230](https://github.com/matrix-org/matrix-js-sdk/pull/230)
- * Fix error handling on uploadContent
-   [\#229](https://github.com/matrix-org/matrix-js-sdk/pull/229)
- * Fix uploadContent for node.js
-   [\#226](https://github.com/matrix-org/matrix-js-sdk/pull/226)
- * Don't emit ERROR until a keepalive poke fails
-   [\#223](https://github.com/matrix-org/matrix-js-sdk/pull/223)
- * Function to get the fallback url for interactive auth
-   [\#224](https://github.com/matrix-org/matrix-js-sdk/pull/224)
- * Revert "Handle the first /sync failure differently."
-   [\#222](https://github.com/matrix-org/matrix-js-sdk/pull/222)
-
-Changes in [0.6.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.2) (2016-10-05)
-================================================================================================
+## Breaking Changes
+
+-   Add a 'RECONNECTING' state to the sync states. This is an additional state
+    between 'SYNCING' and 'ERROR', so most clients should not notice.
+
+## Other Changes
+
+-   Fix params getting replaced on register calls
+    [\#233](https://github.com/matrix-org/matrix-js-sdk/pull/233)
+-   Fix potential 30s delay on reconnect
+    [\#232](https://github.com/matrix-org/matrix-js-sdk/pull/232)
+-   uploadContent: Attempt some consistency between browser and node
+    [\#230](https://github.com/matrix-org/matrix-js-sdk/pull/230)
+-   Fix error handling on uploadContent
+    [\#229](https://github.com/matrix-org/matrix-js-sdk/pull/229)
+-   Fix uploadContent for node.js
+    [\#226](https://github.com/matrix-org/matrix-js-sdk/pull/226)
+-   Don't emit ERROR until a keepalive poke fails
+    [\#223](https://github.com/matrix-org/matrix-js-sdk/pull/223)
+-   Function to get the fallback url for interactive auth
+    [\#224](https://github.com/matrix-org/matrix-js-sdk/pull/224)
+-   Revert "Handle the first /sync failure differently."
+    [\#222](https://github.com/matrix-org/matrix-js-sdk/pull/222)
+
+# Changes in [0.6.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.2) (2016-10-05)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.1...v0.6.2)
 
- * Check dependencies aren't on develop in release.sh
-   [\#221](https://github.com/matrix-org/matrix-js-sdk/pull/221)
- * Fix checkTurnServers leak on logout
-   [\#220](https://github.com/matrix-org/matrix-js-sdk/pull/220)
- * Fix leak of file upload objects
-   [\#219](https://github.com/matrix-org/matrix-js-sdk/pull/219)
- * crypto: remove duplicate code
-   [\#218](https://github.com/matrix-org/matrix-js-sdk/pull/218)
- * Add API for 3rd party location lookup
-   [\#217](https://github.com/matrix-org/matrix-js-sdk/pull/217)
- * Handle the first /sync failure differently.
-   [\#216](https://github.com/matrix-org/matrix-js-sdk/pull/216)
-
-Changes in [0.6.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.1) (2016-09-21)
-================================================================================================
+-   Check dependencies aren't on develop in release.sh
+    [\#221](https://github.com/matrix-org/matrix-js-sdk/pull/221)
+-   Fix checkTurnServers leak on logout
+    [\#220](https://github.com/matrix-org/matrix-js-sdk/pull/220)
+-   Fix leak of file upload objects
+    [\#219](https://github.com/matrix-org/matrix-js-sdk/pull/219)
+-   crypto: remove duplicate code
+    [\#218](https://github.com/matrix-org/matrix-js-sdk/pull/218)
+-   Add API for 3rd party location lookup
+    [\#217](https://github.com/matrix-org/matrix-js-sdk/pull/217)
+-   Handle the first /sync failure differently.
+    [\#216](https://github.com/matrix-org/matrix-js-sdk/pull/216)
+
+# Changes in [0.6.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.1) (2016-09-21)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.0...v0.6.1)
 
- * Fix the ed25519 key checking
-   [\#215](https://github.com/matrix-org/matrix-js-sdk/pull/215)
- * Add MatrixClient.getEventSenderDeviceInfo()
-   [\#214](https://github.com/matrix-org/matrix-js-sdk/pull/214)
+-   Fix the ed25519 key checking
+    [\#215](https://github.com/matrix-org/matrix-js-sdk/pull/215)
+-   Add MatrixClient.getEventSenderDeviceInfo()
+    [\#214](https://github.com/matrix-org/matrix-js-sdk/pull/214)
+
+# Changes in [0.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.0) (2016-09-21)
 
-Changes in [0.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.0) (2016-09-21)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.6...v0.6.0)
 
- * Pull user device list on join
-   [\#212](https://github.com/matrix-org/matrix-js-sdk/pull/212)
- * Fix sending of oh_hais on bad sessions
-   [\#213](https://github.com/matrix-org/matrix-js-sdk/pull/213)
- * Support /publicRooms pagination
-   [\#211](https://github.com/matrix-org/matrix-js-sdk/pull/211)
- * Update the olm library version to 1.3.0
-   [\#205](https://github.com/matrix-org/matrix-js-sdk/pull/205)
- * Comment what the logic in uploadKeys does
-   [\#209](https://github.com/matrix-org/matrix-js-sdk/pull/209)
- * Include keysProved and keysClaimed in the local echo for events we send.
-   [\#210](https://github.com/matrix-org/matrix-js-sdk/pull/210)
- * Check if we need to upload new one-time keys every 10 minutes
-   [\#208](https://github.com/matrix-org/matrix-js-sdk/pull/208)
- * Reset oneTimeKey to null on each loop iteration.
-   [\#207](https://github.com/matrix-org/matrix-js-sdk/pull/207)
- * Add getKeysProved and getKeysClaimed methods to MatrixEvent.
-   [\#206](https://github.com/matrix-org/matrix-js-sdk/pull/206)
- * Send a 'm.new_device' when we get a message for an unknown group session
-   [\#204](https://github.com/matrix-org/matrix-js-sdk/pull/204)
- * Introduce EventTimelineSet, filtered timelines and global notif timeline.
-   [\#196](https://github.com/matrix-org/matrix-js-sdk/pull/196)
- * Wrap the crypto event handlers in try/catch blocks
-   [\#203](https://github.com/matrix-org/matrix-js-sdk/pull/203)
- * Show warnings on to-device decryption fail
-   [\#202](https://github.com/matrix-org/matrix-js-sdk/pull/202)
- * s/Displayname/DisplayName/
-   [\#201](https://github.com/matrix-org/matrix-js-sdk/pull/201)
- * OH HAI
-   [\#200](https://github.com/matrix-org/matrix-js-sdk/pull/200)
- * Share the current ratchet with new members
-   [\#199](https://github.com/matrix-org/matrix-js-sdk/pull/199)
- * Move crypto bits into a subdirectory
-   [\#198](https://github.com/matrix-org/matrix-js-sdk/pull/198)
- * Refactor event handling in Crypto
-   [\#197](https://github.com/matrix-org/matrix-js-sdk/pull/197)
- * Don't create Olm sessions proactively
-   [\#195](https://github.com/matrix-org/matrix-js-sdk/pull/195)
- * Use to-device events for key sharing
-   [\#194](https://github.com/matrix-org/matrix-js-sdk/pull/194)
- * README: callbacks deprecated
-   [\#193](https://github.com/matrix-org/matrix-js-sdk/pull/193)
- * Fix sender verification for megolm messages
-   [\#192](https://github.com/matrix-org/matrix-js-sdk/pull/192)
- * Use `ciphertext` instead of `body` in megolm events
-   [\#191](https://github.com/matrix-org/matrix-js-sdk/pull/191)
- * Add debug methods to get the state of OlmSessions
-   [\#189](https://github.com/matrix-org/matrix-js-sdk/pull/189)
- * MatrixClient.getStoredDevicesForUser
-   [\#190](https://github.com/matrix-org/matrix-js-sdk/pull/190)
- * Olm-related cleanups
-   [\#188](https://github.com/matrix-org/matrix-js-sdk/pull/188)
- * Update to fixed olmlib
-   [\#187](https://github.com/matrix-org/matrix-js-sdk/pull/187)
- * always play audio out of the remoteAudioElement if it exists.
-   [\#186](https://github.com/matrix-org/matrix-js-sdk/pull/186)
- * Fix exceptions where HTMLMediaElement loads and plays race
-   [\#185](https://github.com/matrix-org/matrix-js-sdk/pull/185)
- * Reset megolm session when people join/leave the room
-   [\#183](https://github.com/matrix-org/matrix-js-sdk/pull/183)
- * Fix exceptions when dealing with redactions
-   [\#184](https://github.com/matrix-org/matrix-js-sdk/pull/184)
-
-Changes in [0.5.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.6) (2016-08-28)
-================================================================================================
+-   Pull user device list on join
+    [\#212](https://github.com/matrix-org/matrix-js-sdk/pull/212)
+-   Fix sending of oh_hais on bad sessions
+    [\#213](https://github.com/matrix-org/matrix-js-sdk/pull/213)
+-   Support /publicRooms pagination
+    [\#211](https://github.com/matrix-org/matrix-js-sdk/pull/211)
+-   Update the olm library version to 1.3.0
+    [\#205](https://github.com/matrix-org/matrix-js-sdk/pull/205)
+-   Comment what the logic in uploadKeys does
+    [\#209](https://github.com/matrix-org/matrix-js-sdk/pull/209)
+-   Include keysProved and keysClaimed in the local echo for events we send.
+    [\#210](https://github.com/matrix-org/matrix-js-sdk/pull/210)
+-   Check if we need to upload new one-time keys every 10 minutes
+    [\#208](https://github.com/matrix-org/matrix-js-sdk/pull/208)
+-   Reset oneTimeKey to null on each loop iteration.
+    [\#207](https://github.com/matrix-org/matrix-js-sdk/pull/207)
+-   Add getKeysProved and getKeysClaimed methods to MatrixEvent.
+    [\#206](https://github.com/matrix-org/matrix-js-sdk/pull/206)
+-   Send a 'm.new_device' when we get a message for an unknown group session
+    [\#204](https://github.com/matrix-org/matrix-js-sdk/pull/204)
+-   Introduce EventTimelineSet, filtered timelines and global notif timeline.
+    [\#196](https://github.com/matrix-org/matrix-js-sdk/pull/196)
+-   Wrap the crypto event handlers in try/catch blocks
+    [\#203](https://github.com/matrix-org/matrix-js-sdk/pull/203)
+-   Show warnings on to-device decryption fail
+    [\#202](https://github.com/matrix-org/matrix-js-sdk/pull/202)
+-   s/Displayname/DisplayName/
+    [\#201](https://github.com/matrix-org/matrix-js-sdk/pull/201)
+-   OH HAI
+    [\#200](https://github.com/matrix-org/matrix-js-sdk/pull/200)
+-   Share the current ratchet with new members
+    [\#199](https://github.com/matrix-org/matrix-js-sdk/pull/199)
+-   Move crypto bits into a subdirectory
+    [\#198](https://github.com/matrix-org/matrix-js-sdk/pull/198)
+-   Refactor event handling in Crypto
+    [\#197](https://github.com/matrix-org/matrix-js-sdk/pull/197)
+-   Don't create Olm sessions proactively
+    [\#195](https://github.com/matrix-org/matrix-js-sdk/pull/195)
+-   Use to-device events for key sharing
+    [\#194](https://github.com/matrix-org/matrix-js-sdk/pull/194)
+-   README: callbacks deprecated
+    [\#193](https://github.com/matrix-org/matrix-js-sdk/pull/193)
+-   Fix sender verification for megolm messages
+    [\#192](https://github.com/matrix-org/matrix-js-sdk/pull/192)
+-   Use `ciphertext` instead of `body` in megolm events
+    [\#191](https://github.com/matrix-org/matrix-js-sdk/pull/191)
+-   Add debug methods to get the state of OlmSessions
+    [\#189](https://github.com/matrix-org/matrix-js-sdk/pull/189)
+-   MatrixClient.getStoredDevicesForUser
+    [\#190](https://github.com/matrix-org/matrix-js-sdk/pull/190)
+-   Olm-related cleanups
+    [\#188](https://github.com/matrix-org/matrix-js-sdk/pull/188)
+-   Update to fixed olmlib
+    [\#187](https://github.com/matrix-org/matrix-js-sdk/pull/187)
+-   always play audio out of the remoteAudioElement if it exists.
+    [\#186](https://github.com/matrix-org/matrix-js-sdk/pull/186)
+-   Fix exceptions where HTMLMediaElement loads and plays race
+    [\#185](https://github.com/matrix-org/matrix-js-sdk/pull/185)
+-   Reset megolm session when people join/leave the room
+    [\#183](https://github.com/matrix-org/matrix-js-sdk/pull/183)
+-   Fix exceptions when dealing with redactions
+    [\#184](https://github.com/matrix-org/matrix-js-sdk/pull/184)
+
+# Changes in [0.5.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.6) (2016-08-28)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.5...v0.5.6)
 
- * Put all of the megolm keys in one room message
-   [\#182](https://github.com/matrix-org/matrix-js-sdk/pull/182)
- * Reinstate device blocking for simple Olm
-   [\#181](https://github.com/matrix-org/matrix-js-sdk/pull/181)
- * support for unpacking megolm keys
-   [\#180](https://github.com/matrix-org/matrix-js-sdk/pull/180)
- * Send out megolm keys when we start a megolm session
-   [\#179](https://github.com/matrix-org/matrix-js-sdk/pull/179)
- * Change the result structure for ensureOlmSessionsForUsers
-   [\#178](https://github.com/matrix-org/matrix-js-sdk/pull/178)
- * Factor out a function for doing olm encryption
-   [\#177](https://github.com/matrix-org/matrix-js-sdk/pull/177)
- * Move DeviceInfo and DeviceVerification to separate module
-   [\#175](https://github.com/matrix-org/matrix-js-sdk/pull/175)
- * Make encryption asynchronous
-   [\#176](https://github.com/matrix-org/matrix-js-sdk/pull/176)
- * Added ability to set and get status_msg for presence.
-   [\#167](https://github.com/matrix-org/matrix-js-sdk/pull/167)
- * Megolm: don't dereference nullable object
-   [\#174](https://github.com/matrix-org/matrix-js-sdk/pull/174)
- * Implement megolm encryption/decryption
-   [\#173](https://github.com/matrix-org/matrix-js-sdk/pull/173)
- * Update our push rules when they come down stream
-   [\#170](https://github.com/matrix-org/matrix-js-sdk/pull/170)
- * Factor Olm encryption/decryption out to new classes
-   [\#172](https://github.com/matrix-org/matrix-js-sdk/pull/172)
- * Make DeviceInfo more useful, and refactor crypto methods to use it
-   [\#171](https://github.com/matrix-org/matrix-js-sdk/pull/171)
- * Move login and register methods into base-apis
-   [\#169](https://github.com/matrix-org/matrix-js-sdk/pull/169)
- * Remove defaultDeviceDisplayName from MatrixClient options
-   [\#168](https://github.com/matrix-org/matrix-js-sdk/pull/168)
-
-Changes in [0.5.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.5) (2016-08-11)
-================================================================================================
+-   Put all of the megolm keys in one room message
+    [\#182](https://github.com/matrix-org/matrix-js-sdk/pull/182)
+-   Reinstate device blocking for simple Olm
+    [\#181](https://github.com/matrix-org/matrix-js-sdk/pull/181)
+-   support for unpacking megolm keys
+    [\#180](https://github.com/matrix-org/matrix-js-sdk/pull/180)
+-   Send out megolm keys when we start a megolm session
+    [\#179](https://github.com/matrix-org/matrix-js-sdk/pull/179)
+-   Change the result structure for ensureOlmSessionsForUsers
+    [\#178](https://github.com/matrix-org/matrix-js-sdk/pull/178)
+-   Factor out a function for doing olm encryption
+    [\#177](https://github.com/matrix-org/matrix-js-sdk/pull/177)
+-   Move DeviceInfo and DeviceVerification to separate module
+    [\#175](https://github.com/matrix-org/matrix-js-sdk/pull/175)
+-   Make encryption asynchronous
+    [\#176](https://github.com/matrix-org/matrix-js-sdk/pull/176)
+-   Added ability to set and get status_msg for presence.
+    [\#167](https://github.com/matrix-org/matrix-js-sdk/pull/167)
+-   Megolm: don't dereference nullable object
+    [\#174](https://github.com/matrix-org/matrix-js-sdk/pull/174)
+-   Implement megolm encryption/decryption
+    [\#173](https://github.com/matrix-org/matrix-js-sdk/pull/173)
+-   Update our push rules when they come down stream
+    [\#170](https://github.com/matrix-org/matrix-js-sdk/pull/170)
+-   Factor Olm encryption/decryption out to new classes
+    [\#172](https://github.com/matrix-org/matrix-js-sdk/pull/172)
+-   Make DeviceInfo more useful, and refactor crypto methods to use it
+    [\#171](https://github.com/matrix-org/matrix-js-sdk/pull/171)
+-   Move login and register methods into base-apis
+    [\#169](https://github.com/matrix-org/matrix-js-sdk/pull/169)
+-   Remove defaultDeviceDisplayName from MatrixClient options
+    [\#168](https://github.com/matrix-org/matrix-js-sdk/pull/168)
+
+# Changes in [0.5.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.5) (2016-08-11)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.4...v0.5.5)
 
- * Add room.getAliases() and room.getCanonicalAlias
- * Add API calls `/register/email/requestToken`, `/account/password/email/requestToken` and `/account/3pid/email/requestToken`
- * Add `User.currentlyActive` and `User.lastPresenceTs` events for changes in fields on the User object
- * Add `logout` and `deactivateAccount`
-
- * Make sure we actually stop the sync loop on logout
-   [\#166](https://github.com/matrix-org/matrix-js-sdk/pull/166)
- * Zero is a valid power level
-   [\#164](https://github.com/matrix-org/matrix-js-sdk/pull/164)
- * Verify e2e keys on download
-   [\#163](https://github.com/matrix-org/matrix-js-sdk/pull/163)
- * Factor crypto stuff out of MatrixClient
-   [\#162](https://github.com/matrix-org/matrix-js-sdk/pull/162)
- * Refactor device key upload
-   [\#161](https://github.com/matrix-org/matrix-js-sdk/pull/161)
- * Wrappers for devices API
-   [\#158](https://github.com/matrix-org/matrix-js-sdk/pull/158)
- * Add deactivate account function
-   [\#160](https://github.com/matrix-org/matrix-js-sdk/pull/160)
- * client.listDeviceKeys: Expose device display name
-   [\#159](https://github.com/matrix-org/matrix-js-sdk/pull/159)
- * Add `logout`
-   [\#157](https://github.com/matrix-org/matrix-js-sdk/pull/157)
- * Fix email registration
-   [\#156](https://github.com/matrix-org/matrix-js-sdk/pull/156)
- * Factor out MatrixClient methods to MatrixBaseApis
-   [\#155](https://github.com/matrix-org/matrix-js-sdk/pull/155)
- * Fix some broken tests
-   [\#154](https://github.com/matrix-org/matrix-js-sdk/pull/154)
- * make jenkins fail the build if the tests fail
-   [\#153](https://github.com/matrix-org/matrix-js-sdk/pull/153)
- * deviceId-related fixes
-   [\#152](https://github.com/matrix-org/matrix-js-sdk/pull/152)
- * /login, /register: Add device_id and initial_device_display_name
-   [\#151](https://github.com/matrix-org/matrix-js-sdk/pull/151)
- * Support global account_data
-   [\#150](https://github.com/matrix-org/matrix-js-sdk/pull/150)
- * Add more events to User
-   [\#149](https://github.com/matrix-org/matrix-js-sdk/pull/149)
- * Add API calls for other requestToken endpoints
-   [\#148](https://github.com/matrix-org/matrix-js-sdk/pull/148)
- * Add register-specific request token endpoint
-   [\#147](https://github.com/matrix-org/matrix-js-sdk/pull/147)
- * Set a valid SPDX license identifier in package.json
-   [\#139](https://github.com/matrix-org/matrix-js-sdk/pull/139)
- * Configure encryption on m.room.encryption events
-   [\#145](https://github.com/matrix-org/matrix-js-sdk/pull/145)
- * Implement device blocking
-   [\#146](https://github.com/matrix-org/matrix-js-sdk/pull/146)
- * Clearer doc for setRoomDirectoryVisibility
-   [\#144](https://github.com/matrix-org/matrix-js-sdk/pull/144)
- * crypto: use memberlist to derive recipient list
-   [\#143](https://github.com/matrix-org/matrix-js-sdk/pull/143)
- * Support for marking devices as unverified
-   [\#142](https://github.com/matrix-org/matrix-js-sdk/pull/142)
- * Add Olm as an optionalDependency
-   [\#141](https://github.com/matrix-org/matrix-js-sdk/pull/141)
- * Add room.getAliases() and room.getCanonicalAlias()
-   [\#140](https://github.com/matrix-org/matrix-js-sdk/pull/140)
- * Change how MatrixEvent manages encrypted events
-   [\#138](https://github.com/matrix-org/matrix-js-sdk/pull/138)
- * Catch exceptions when encrypting events
-   [\#137](https://github.com/matrix-org/matrix-js-sdk/pull/137)
- * Support for marking devices as verified
-   [\#136](https://github.com/matrix-org/matrix-js-sdk/pull/136)
- * Various matrix-client refactorings and fixes
-   [\#134](https://github.com/matrix-org/matrix-js-sdk/pull/134)
-
-Changes in [0.5.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.4) (2016-06-02)
-================================================================================================
+-   Add room.getAliases() and room.getCanonicalAlias
+-   Add API calls `/register/email/requestToken`, `/account/password/email/requestToken` and `/account/3pid/email/requestToken`
+-   Add `User.currentlyActive` and `User.lastPresenceTs` events for changes in fields on the User object
+-   Add `logout` and `deactivateAccount`
+
+-   Make sure we actually stop the sync loop on logout
+    [\#166](https://github.com/matrix-org/matrix-js-sdk/pull/166)
+-   Zero is a valid power level
+    [\#164](https://github.com/matrix-org/matrix-js-sdk/pull/164)
+-   Verify e2e keys on download
+    [\#163](https://github.com/matrix-org/matrix-js-sdk/pull/163)
+-   Factor crypto stuff out of MatrixClient
+    [\#162](https://github.com/matrix-org/matrix-js-sdk/pull/162)
+-   Refactor device key upload
+    [\#161](https://github.com/matrix-org/matrix-js-sdk/pull/161)
+-   Wrappers for devices API
+    [\#158](https://github.com/matrix-org/matrix-js-sdk/pull/158)
+-   Add deactivate account function
+    [\#160](https://github.com/matrix-org/matrix-js-sdk/pull/160)
+-   client.listDeviceKeys: Expose device display name
+    [\#159](https://github.com/matrix-org/matrix-js-sdk/pull/159)
+-   Add `logout`
+    [\#157](https://github.com/matrix-org/matrix-js-sdk/pull/157)
+-   Fix email registration
+    [\#156](https://github.com/matrix-org/matrix-js-sdk/pull/156)
+-   Factor out MatrixClient methods to MatrixBaseApis
+    [\#155](https://github.com/matrix-org/matrix-js-sdk/pull/155)
+-   Fix some broken tests
+    [\#154](https://github.com/matrix-org/matrix-js-sdk/pull/154)
+-   make jenkins fail the build if the tests fail
+    [\#153](https://github.com/matrix-org/matrix-js-sdk/pull/153)
+-   deviceId-related fixes
+    [\#152](https://github.com/matrix-org/matrix-js-sdk/pull/152)
+-   /login, /register: Add device_id and initial_device_display_name
+    [\#151](https://github.com/matrix-org/matrix-js-sdk/pull/151)
+-   Support global account_data
+    [\#150](https://github.com/matrix-org/matrix-js-sdk/pull/150)
+-   Add more events to User
+    [\#149](https://github.com/matrix-org/matrix-js-sdk/pull/149)
+-   Add API calls for other requestToken endpoints
+    [\#148](https://github.com/matrix-org/matrix-js-sdk/pull/148)
+-   Add register-specific request token endpoint
+    [\#147](https://github.com/matrix-org/matrix-js-sdk/pull/147)
+-   Set a valid SPDX license identifier in package.json
+    [\#139](https://github.com/matrix-org/matrix-js-sdk/pull/139)
+-   Configure encryption on m.room.encryption events
+    [\#145](https://github.com/matrix-org/matrix-js-sdk/pull/145)
+-   Implement device blocking
+    [\#146](https://github.com/matrix-org/matrix-js-sdk/pull/146)
+-   Clearer doc for setRoomDirectoryVisibility
+    [\#144](https://github.com/matrix-org/matrix-js-sdk/pull/144)
+-   crypto: use memberlist to derive recipient list
+    [\#143](https://github.com/matrix-org/matrix-js-sdk/pull/143)
+-   Support for marking devices as unverified
+    [\#142](https://github.com/matrix-org/matrix-js-sdk/pull/142)
+-   Add Olm as an optionalDependency
+    [\#141](https://github.com/matrix-org/matrix-js-sdk/pull/141)
+-   Add room.getAliases() and room.getCanonicalAlias()
+    [\#140](https://github.com/matrix-org/matrix-js-sdk/pull/140)
+-   Change how MatrixEvent manages encrypted events
+    [\#138](https://github.com/matrix-org/matrix-js-sdk/pull/138)
+-   Catch exceptions when encrypting events
+    [\#137](https://github.com/matrix-org/matrix-js-sdk/pull/137)
+-   Support for marking devices as verified
+    [\#136](https://github.com/matrix-org/matrix-js-sdk/pull/136)
+-   Various matrix-client refactorings and fixes
+    [\#134](https://github.com/matrix-org/matrix-js-sdk/pull/134)
+
+# Changes in [0.5.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.4) (2016-06-02)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.3...v0.5.4)
 
- * Correct fix for https://github.com/vector-im/vector-web/issues/1039
- * Make release.sh work on OSX
+-   Correct fix for https://github.com/vector-im/vector-web/issues/1039
+-   Make release.sh work on OSX
 
+# Changes in [0.5.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.3) (2016-06-02)
 
-Changes in [0.5.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.3) (2016-06-02)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.2...v0.5.3)
 
- * Add support for the openid interface
-   [\#133](https://github.com/matrix-org/matrix-js-sdk/pull/133)
- * Bugfix for HTTP upload content when running on node
-   [\#129](https://github.com/matrix-org/matrix-js-sdk/pull/129)
- * Ignore missing profile (displayname and avatar_url) fields on
-   presence events, rather than overwriting existing valid profile
-   data from membership events or elsewhere.
-   Fixes https://github.com/vector-im/vector-web/issues/1039
-
-Changes in [0.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.2) (2016-04-19)
-================================================================================================
+-   Add support for the openid interface
+    [\#133](https://github.com/matrix-org/matrix-js-sdk/pull/133)
+-   Bugfix for HTTP upload content when running on node
+    [\#129](https://github.com/matrix-org/matrix-js-sdk/pull/129)
+-   Ignore missing profile (displayname and avatar_url) fields on
+    presence events, rather than overwriting existing valid profile
+    data from membership events or elsewhere.
+    Fixes https://github.com/vector-im/vector-web/issues/1039
+
+# Changes in [0.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.2) (2016-04-19)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.1...v0.5.2)
 
- * Track the absolute time that presence events are received, so that the
-   relative lastActiveAgo value is meaningful.
-   [\#128](https://github.com/matrix-org/matrix-js-sdk/pull/128)
- * Refactor the addition of events to rooms
-   [\#127](https://github.com/matrix-org/matrix-js-sdk/pull/127)
- * Clean up test shutdown
-   [\#126](https://github.com/matrix-org/matrix-js-sdk/pull/126)
- * Add methods to get (and set) pushers
-   [\#125](https://github.com/matrix-org/matrix-js-sdk/pull/125)
- * URL previewing support
-   [\#122](https://github.com/matrix-org/matrix-js-sdk/pull/122)
- * Avoid paginating forever in private rooms
-   [\#124](https://github.com/matrix-org/matrix-js-sdk/pull/124)
- * Fix a bug where we recreated sync filters
-   [\#123](https://github.com/matrix-org/matrix-js-sdk/pull/123)
- * Implement HTTP timeouts in realtime
-   [\#121](https://github.com/matrix-org/matrix-js-sdk/pull/121)
-
-Changes in [0.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.1) (2016-03-30)
-================================================================================================
+-   Track the absolute time that presence events are received, so that the
+    relative lastActiveAgo value is meaningful.
+    [\#128](https://github.com/matrix-org/matrix-js-sdk/pull/128)
+-   Refactor the addition of events to rooms
+    [\#127](https://github.com/matrix-org/matrix-js-sdk/pull/127)
+-   Clean up test shutdown
+    [\#126](https://github.com/matrix-org/matrix-js-sdk/pull/126)
+-   Add methods to get (and set) pushers
+    [\#125](https://github.com/matrix-org/matrix-js-sdk/pull/125)
+-   URL previewing support
+    [\#122](https://github.com/matrix-org/matrix-js-sdk/pull/122)
+-   Avoid paginating forever in private rooms
+    [\#124](https://github.com/matrix-org/matrix-js-sdk/pull/124)
+-   Fix a bug where we recreated sync filters
+    [\#123](https://github.com/matrix-org/matrix-js-sdk/pull/123)
+-   Implement HTTP timeouts in realtime
+    [\#121](https://github.com/matrix-org/matrix-js-sdk/pull/121)
+
+# Changes in [0.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.1) (2016-03-30)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.0...v0.5.1)
 
- * Only count joined members for the member count in notifications.
-   [\#119](https://github.com/matrix-org/matrix-js-sdk/pull/119)
- * Add maySendEvent to match maySendStateEvent
-   [\#118](https://github.com/matrix-org/matrix-js-sdk/pull/118)
+-   Only count joined members for the member count in notifications.
+    [\#119](https://github.com/matrix-org/matrix-js-sdk/pull/119)
+-   Add maySendEvent to match maySendStateEvent
+    [\#118](https://github.com/matrix-org/matrix-js-sdk/pull/118)
+
+# Changes in [0.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.0) (2016-03-22)
 
-Changes in [0.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.0) (2016-03-22)
-================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.4.2...v0.5.0)
 
 **BREAKING CHANGES**:
- * `opts.pendingEventOrdering`==`end` is no longer supported in the arguments to
-   `MatrixClient.startClient()`. Instead we provide a `detached` option, which
-   puts pending events into a completely separate list in the Room, accessible
-   via `Room.getPendingEvents()`.
-   [\#111](https://github.com/matrix-org/matrix-js-sdk/pull/111)
+
+-   `opts.pendingEventOrdering`==`end` is no longer supported in the arguments to
+    `MatrixClient.startClient()`. Instead we provide a `detached` option, which
+    puts pending events into a completely separate list in the Room, accessible
+    via `Room.getPendingEvents()`.
+    [\#111](https://github.com/matrix-org/matrix-js-sdk/pull/111)
 
 Other improvements:
- * Log the stack when we get a sync error
-   [\#109](https://github.com/matrix-org/matrix-js-sdk/pull/109)
- * Refactor transmitted-messages code
-   [\#110](https://github.com/matrix-org/matrix-js-sdk/pull/110)
- * Add a method to the js sdk to look up 3pids on the ID server.
-   [\#113](https://github.com/matrix-org/matrix-js-sdk/pull/113)
- * Support for cancelling pending events
-   [\#112](https://github.com/matrix-org/matrix-js-sdk/pull/112)
- * API to stop peeking
-   [\#114](https://github.com/matrix-org/matrix-js-sdk/pull/114)
- * update store user metadata based on membership events rather than presence
-   [\#116](https://github.com/matrix-org/matrix-js-sdk/pull/116)
- * Include a counter in generated transaction IDs
-   [\#115](https://github.com/matrix-org/matrix-js-sdk/pull/115)
- * get/setRoomVisibility API
-   [\#117](https://github.com/matrix-org/matrix-js-sdk/pull/117)
-
-Changes in [0.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.4.2) (2016-03-17)
-================================================================================================
+
+-   Log the stack when we get a sync error
+    [\#109](https://github.com/matrix-org/matrix-js-sdk/pull/109)
+-   Refactor transmitted-messages code
+    [\#110](https://github.com/matrix-org/matrix-js-sdk/pull/110)
+-   Add a method to the js sdk to look up 3pids on the ID server.
+    [\#113](https://github.com/matrix-org/matrix-js-sdk/pull/113)
+-   Support for cancelling pending events
+    [\#112](https://github.com/matrix-org/matrix-js-sdk/pull/112)
+-   API to stop peeking
+    [\#114](https://github.com/matrix-org/matrix-js-sdk/pull/114)
+-   update store user metadata based on membership events rather than presence
+    [\#116](https://github.com/matrix-org/matrix-js-sdk/pull/116)
+-   Include a counter in generated transaction IDs
+    [\#115](https://github.com/matrix-org/matrix-js-sdk/pull/115)
+-   get/setRoomVisibility API
+    [\#117](https://github.com/matrix-org/matrix-js-sdk/pull/117)
+
+# Changes in [0.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.4.2) (2016-03-17)
+
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.4.1...v0.4.2)
 
- * Try again if a pagination request gives us no new messages
-   [\#98](https://github.com/matrix-org/matrix-js-sdk/pull/98)
- * Add a delay before we start polling the connectivity check endpoint
-   [\#99](https://github.com/matrix-org/matrix-js-sdk/pull/99)
- * Clean up a codepath that was only used for crypto messages
-   [\#101](https://github.com/matrix-org/matrix-js-sdk/pull/101)
- * Add maySendStateEvent method, ported from react-sdk (but fixed).
-   [\#94](https://github.com/matrix-org/matrix-js-sdk/pull/94)
- * Add Session.logged_out event
-   [\#100](https://github.com/matrix-org/matrix-js-sdk/pull/100)
- * make presence work when peeking.
-   [\#103](https://github.com/matrix-org/matrix-js-sdk/pull/103)
- * Add RoomState.mayClientSendStateEvent()
-   [\#104](https://github.com/matrix-org/matrix-js-sdk/pull/104)
- * Fix displaynames for member join events
-   [\#108](https://github.com/matrix-org/matrix-js-sdk/pull/108)
-
-Changes in 0.4.1
-================
+-   Try again if a pagination request gives us no new messages
+    [\#98](https://github.com/matrix-org/matrix-js-sdk/pull/98)
+-   Add a delay before we start polling the connectivity check endpoint
+    [\#99](https://github.com/matrix-org/matrix-js-sdk/pull/99)
+-   Clean up a codepath that was only used for crypto messages
+    [\#101](https://github.com/matrix-org/matrix-js-sdk/pull/101)
+-   Add maySendStateEvent method, ported from react-sdk (but fixed).
+    [\#94](https://github.com/matrix-org/matrix-js-sdk/pull/94)
+-   Add Session.logged_out event
+    [\#100](https://github.com/matrix-org/matrix-js-sdk/pull/100)
+-   make presence work when peeking.
+    [\#103](https://github.com/matrix-org/matrix-js-sdk/pull/103)
+-   Add RoomState.mayClientSendStateEvent()
+    [\#104](https://github.com/matrix-org/matrix-js-sdk/pull/104)
+-   Fix displaynames for member join events
+    [\#108](https://github.com/matrix-org/matrix-js-sdk/pull/108)
+
+# Changes in 0.4.1
 
 Improvements:
- * Check that `/sync` filters are correct before reusing them, and recreate
-   them if not (https://github.com/matrix-org/matrix-js-sdk/pull/85).
- * Fire a `Room.timelineReset` event when a room's timeline is reset by a gappy
-   `/sync` (https://github.com/matrix-org/matrix-js-sdk/pull/87,
-   https://github.com/matrix-org/matrix-js-sdk/pull/93).
- * Make `TimelineWindow.load()` faster in the simple case of loading the live
-   timeline (https://github.com/matrix-org/matrix-js-sdk/pull/88).
- * Update room-name calculation code to use the name of the sender of the
-   invite when invited to a room
-   (https://github.com/matrix-org/matrix-js-sdk/pull/89).
- * Don't reset the timeline when we join a room after peeking into it
-   (https://github.com/matrix-org/matrix-js-sdk/pull/91).
- * Fire `Room.localEchoUpdated` events as local echoes progress through their
-   transmission process (https://github.com/matrix-org/matrix-js-sdk/pull/95,
-   https://github.com/matrix-org/matrix-js-sdk/pull/97).
- * Avoid getting stuck in a pagination loop when the server sends us only
-   messages we've already seen
-   (https://github.com/matrix-org/matrix-js-sdk/pull/96).
+
+-   Check that `/sync` filters are correct before reusing them, and recreate
+    them if not (https://github.com/matrix-org/matrix-js-sdk/pull/85).
+-   Fire a `Room.timelineReset` event when a room's timeline is reset by a gappy
+    `/sync` (https://github.com/matrix-org/matrix-js-sdk/pull/87,
+    https://github.com/matrix-org/matrix-js-sdk/pull/93).
+-   Make `TimelineWindow.load()` faster in the simple case of loading the live
+    timeline (https://github.com/matrix-org/matrix-js-sdk/pull/88).
+-   Update room-name calculation code to use the name of the sender of the
+    invite when invited to a room
+    (https://github.com/matrix-org/matrix-js-sdk/pull/89).
+-   Don't reset the timeline when we join a room after peeking into it
+    (https://github.com/matrix-org/matrix-js-sdk/pull/91).
+-   Fire `Room.localEchoUpdated` events as local echoes progress through their
+    transmission process (https://github.com/matrix-org/matrix-js-sdk/pull/95,
+    https://github.com/matrix-org/matrix-js-sdk/pull/97).
+-   Avoid getting stuck in a pagination loop when the server sends us only
+    messages we've already seen
+    (https://github.com/matrix-org/matrix-js-sdk/pull/96).
 
 New methods:
- * Add `MatrixClient.setPushRuleActions` to set the actions for a push
-   notification rule (https://github.com/matrix-org/matrix-js-sdk/pull/90)
- * Add `RoomState.maySendStateEvent` which determines if a given user has
-   permission to send a state event
-   (https://github.com/matrix-org/matrix-js-sdk/pull/94)
 
-Changes in 0.4.0
-================
+-   Add `MatrixClient.setPushRuleActions` to set the actions for a push
+    notification rule (https://github.com/matrix-org/matrix-js-sdk/pull/90)
+-   Add `RoomState.maySendStateEvent` which determines if a given user has
+    permission to send a state event
+    (https://github.com/matrix-org/matrix-js-sdk/pull/94)
+
+# Changes in 0.4.0
 
 **BREAKING CHANGES**:
- * `RoomMember.getAvatarUrl()` and `MatrixClient.mxcUrlToHttp()` now return the
+
+-   `RoomMember.getAvatarUrl()` and `MatrixClient.mxcUrlToHttp()` now return the
     empty string when given anything other than an mxc:// URL. This ensures that
     clients never inadvertantly reference content directly, leaking information
     to third party servers. The `allowDirectLinks` option is provided if the client
     wants to allow such links.
- * Add a 'bindEmail' option to register()
+-   Add a 'bindEmail' option to register()
 
 Improvements:
- * Support third party invites
- * More appropriate naming for third party invite rooms
- * Poll the 'versions' endpoint to re-establish connectivity
- * Catch exceptions when syncing
- * Room tag support
- * Generate implicit read receipts
- * Support CAS login
- * Guest access support
- * Never return non-mxc URLs by default
- * Ability to cancel file uploads
- * Use the Matrix C/S API v2 with r0 prefix
- * Account data support
- * Support non-contiguous event timelines
- * Support new unread counts
- * Local echo for read-receipts
 
+-   Support third party invites
+-   More appropriate naming for third party invite rooms
+-   Poll the 'versions' endpoint to re-establish connectivity
+-   Catch exceptions when syncing
+-   Room tag support
+-   Generate implicit read receipts
+-   Support CAS login
+-   Guest access support
+-   Never return non-mxc URLs by default
+-   Ability to cancel file uploads
+-   Use the Matrix C/S API v2 with r0 prefix
+-   Account data support
+-   Support non-contiguous event timelines
+-   Support new unread counts
+-   Local echo for read-receipts
 
 New methods:
- * Add method to fetch URLs not on the home or identity server
- * Method to get the last receipt for a user
- * Method to get all known users
- * Method to delete an alias
-
-
-Changes in 0.3.0
-================
-
- * `MatrixClient.getAvatarUrlForMember` has been removed and replaced with
-   `RoomMember.getAvatarUrl`. Arguments remain the same except the homeserver
-   URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
-
-   ```javascript
-   // before
-   var url = client.getAvatarUrlForMember(member, width, height, resize, allowDefault)
-   // after
-   var url = member.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault)
-   ```
- * `MatrixClient.getAvatarUrlForRoom` has been removed and replaced with
-   `Room.getAvatarUrl`. Arguments remain the same except the homeserver
-   URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
-
-   ```javascript
-   // before
-   var url = client.getAvatarUrlForRoom(room, width, height, resize, allowDefault)
-   // after
-   var url = room.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault)
-   ```
-
- * `s/Room.getMembersWithMemership/Room.getMembersWithMem`b`ership/g`
+
+-   Add method to fetch URLs not on the home or identity server
+-   Method to get the last receipt for a user
+-   Method to get all known users
+-   Method to delete an alias
+
+# Changes in 0.3.0
+
+-   `MatrixClient.getAvatarUrlForMember` has been removed and replaced with
+    `RoomMember.getAvatarUrl`. Arguments remain the same except the homeserver
+    URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
+
+    ```javascript
+    // before
+    var url = client.getAvatarUrlForMember(member, width, height, resize, allowDefault);
+    // after
+    var url = member.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault);
+    ```
+
+-   `MatrixClient.getAvatarUrlForRoom` has been removed and replaced with
+    `Room.getAvatarUrl`. Arguments remain the same except the homeserver
+    URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
+
+    ```javascript
+    // before
+    var url = client.getAvatarUrlForRoom(room, width, height, resize, allowDefault);
+    // after
+    var url = room.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault);
+    ```
+
+-   `s/Room.getMembersWithMemership/Room.getMembersWithMem`b`ership/g`
 
 New methods:
- * Added support for sending receipts via
-   `MatrixClient.sendReceipt(event, receiptType, callback)` and
-   `MatrixClient.sendReadReceipt(event, callback)`.
- * Added support for receiving receipts via
-   `Room.getReceiptsForEvent(event)` and `Room.getUsersReadUpTo(event)`. Receipts
-   can be directly added to a `Room` using `Room.addReceipt(event)` though the
-   `MatrixClient` does this for you.
- * Added support for muting local video and audio via the new methods
-   `MatrixCall.setMicrophoneMuted()`, `MatrixCall.isMicrophoneMuted(muted)`,
-   `MatrixCall.isLocalVideoMuted()` and `Matrix.setLocalVideoMuted(muted)`.
- * Added **experimental** support for screen-sharing in Chrome via
-   `MatrixCall.placeScreenSharingCall(remoteVideoElement, localVideoElement)`.
- * Added ability to perform server-side searches using
-   `MatrixClient.searchMessageText(opts)` and `MatrixClient.search(opts)`.
+
+-   Added support for sending receipts via
+    `MatrixClient.sendReceipt(event, receiptType, callback)` and
+    `MatrixClient.sendReadReceipt(event, callback)`.
+-   Added support for receiving receipts via
+    `Room.getReceiptsForEvent(event)` and `Room.getUsersReadUpTo(event)`. Receipts
+    can be directly added to a `Room` using `Room.addReceipt(event)` though the
+    `MatrixClient` does this for you.
+-   Added support for muting local video and audio via the new methods
+    `MatrixCall.setMicrophoneMuted()`, `MatrixCall.isMicrophoneMuted(muted)`,
+    `MatrixCall.isLocalVideoMuted()` and `Matrix.setLocalVideoMuted(muted)`.
+-   Added **experimental** support for screen-sharing in Chrome via
+    `MatrixCall.placeScreenSharingCall(remoteVideoElement, localVideoElement)`.
+-   Added ability to perform server-side searches using
+    `MatrixClient.searchMessageText(opts)` and `MatrixClient.search(opts)`.
 
 Improvements:
- * Improve the performance of initial sync processing from `O(n^2)` to `O(n)`.
- * `Room.name` will now take into account `m.room.canonical_alias` events.
- * `MatrixClient.startClient` now takes an Object `opts` rather than a Number in
-   a backwards-compatible way. This `opts` allows syncing configuration options
-   to be specified including `includeArchivedRooms` and `resolveInvitesToProfiles`.
- * `Room` objects which represent room invitations will now have state populated
-   from `invite_room_state` if it is included in the `m.room.member` event.
- * `Room.getAvatarUrl` will now take into account `m.room.avatar` events.
-
-Changes in 0.2.2
-================
+
+-   Improve the performance of initial sync processing from `O(n^2)` to `O(n)`.
+-   `Room.name` will now take into account `m.room.canonical_alias` events.
+-   `MatrixClient.startClient` now takes an Object `opts` rather than a Number in
+    a backwards-compatible way. This `opts` allows syncing configuration options
+    to be specified including `includeArchivedRooms` and `resolveInvitesToProfiles`.
+-   `Room` objects which represent room invitations will now have state populated
+    from `invite_room_state` if it is included in the `m.room.member` event.
+-   `Room.getAvatarUrl` will now take into account `m.room.avatar` events.
+
+# Changes in 0.2.2
 
 Bug fixes:
- * Null pointer fixes for VoIP calling and push notification processing.
- * Set the `Content-Type` to `application/octet-stream` in the event that the
-   file object has no `type`.
+
+-   Null pointer fixes for VoIP calling and push notification processing.
+-   Set the `Content-Type` to `application/octet-stream` in the event that the
+    file object has no `type`.
 
 New methods:
- * Added `MatrixClient.getCasServer()` which calls through to the HTTP endpoint
-   `/login/cas`.
- * Added `MatrixClient.loginWithCas(ticket, service)` which logs in with the
-   type `m.login.cas`.
- * Added `MatrixClient.getHomeserverUrl()` which returns the URL passed in the
-   constructor.
- * Added `MatrixClient.getIdentityServerUrl()` which returns the URL passed in
-   the constructor.
- * Added `getLastModifiedTime()` to `RoomMember`, `RoomState` and `User` objects.
-   This makes it easier to see if the object in question has changed, which can
-   be used to improve performance by only rendering when these objects change.
-
-Changes in 0.2.1
-================
+
+-   Added `MatrixClient.getCasServer()` which calls through to the HTTP endpoint
+    `/login/cas`.
+-   Added `MatrixClient.loginWithCas(ticket, service)` which logs in with the
+    type `m.login.cas`.
+-   Added `MatrixClient.getHomeserverUrl()` which returns the URL passed in the
+    constructor.
+-   Added `MatrixClient.getIdentityServerUrl()` which returns the URL passed in
+    the constructor.
+-   Added `getLastModifiedTime()` to `RoomMember`, `RoomState` and `User` objects.
+    This makes it easier to see if the object in question has changed, which can
+    be used to improve performance by only rendering when these objects change.
+
+# Changes in 0.2.1
 
 **BREAKING CHANGES**
- * `MatrixClient.joinRoom` has changed from `(roomIdOrAlias, callback)` to
-   `(roomIdOrAlias, opts, callback)`.
+
+-   `MatrixClient.joinRoom` has changed from `(roomIdOrAlias, callback)` to
+    `(roomIdOrAlias, opts, callback)`.
 
 Bug fixes:
- * The `Content-Type` of file uploads is now explicitly set, without relying
-   on the browser to do it for us.
+
+-   The `Content-Type` of file uploads is now explicitly set, without relying
+    on the browser to do it for us.
 
 Improvements:
- * The `MatrixScheduler.RETRY_BACKOFF_RATELIMIT` function will not retry when
-   the response is a 400,401,403.
- * The text returned from a room invite now includes who the invite was from.
- * There is now a try/catch block around the `request` function which will
-   reject/errback appropriately if an exception is thrown synchronously in it.
+
+-   The `MatrixScheduler.RETRY_BACKOFF_RATELIMIT` function will not retry when
+    the response is a 400,401,403.
+-   The text returned from a room invite now includes who the invite was from.
+-   There is now a try/catch block around the `request` function which will
+    reject/errback appropriately if an exception is thrown synchronously in it.
 
 New methods:
- * `MatrixClient.createAlias(alias, roomId)`
- * `MatrixClient.getRoomIdForAlias(alias)`
- * `MatrixClient.sendNotice(roomId, body, txnId, callback)`
- * `MatrixClient.sendHtmlNotice(roomId, body, htmlBody, callback)`
+
+-   `MatrixClient.createAlias(alias, roomId)`
+-   `MatrixClient.getRoomIdForAlias(alias)`
+-   `MatrixClient.sendNotice(roomId, body, txnId, callback)`
+-   `MatrixClient.sendHtmlNotice(roomId, body, htmlBody, callback)`
 
 Modified methods:
- * `MatrixClient.joinRoom(roomIdOrAlias, opts)` where `opts` can include a
-   `syncRoom: true|false` flag to control whether a room initial sync is
-   performed after joining the room.
- * `MatrixClient.getAvatarUrlForMember` has a new last arg `allowDefault` which
-   returns the default identicon URL if `true`.
- * `MatrixClient.getAvatarUrlForRoom` has a new last arg `allowDefault` which
-   is passed through to the default identicon generation for
-   `getAvatarUrlForMember`.
 
+-   `MatrixClient.joinRoom(roomIdOrAlias, opts)` where `opts` can include a
+    `syncRoom: true|false` flag to control whether a room initial sync is
+    performed after joining the room.
+-   `MatrixClient.getAvatarUrlForMember` has a new last arg `allowDefault` which
+    returns the default identicon URL if `true`.
+-   `MatrixClient.getAvatarUrlForRoom` has a new last arg `allowDefault` which
+    is passed through to the default identicon generation for
+    `getAvatarUrlForMember`.
 
-Changes in 0.2.0
-================
+# Changes in 0.2.0
 
 **BREAKING CHANGES**:
- * `MatrixClient.setPowerLevel` now expects a `MatrixEvent` and not an `Object`
-   for the `event` parameter.
+
+-   `MatrixClient.setPowerLevel` now expects a `MatrixEvent` and not an `Object`
+    for the `event` parameter.
 
 New features:
- * Added `EventStatus.QUEUED` which is set on an event when it is waiting to be
-   sent by the scheduler and there are other events in front.
- * Added support for processing push rules on an event. This can be obtained by
-   calling `MatrixClient.getPushActionsForEvent(event)`.
- * Added WebRTC support. Outbound calls can be made via
-   `call = global.createNewMatrixCall(MatrixClient, roomId)` followed by
-   `call.placeVoiceCall()` or `call.placeVideoCall(remoteEle, localEle)`.
-   Inbound calls will be received via the event `"Call.incoming"` which provides
-   a call object which can be followed with `call.answer()` or `call.hangup()`.
- * Added the ability to upload files to the media repository.
- * Added the ability to change the client's password.
- * Added the ability to register with an email via an identity server.
- * Handle presence events by updating the associated `User` object.
- * Handle redaction events.
- * Added infrastructure for supporting End-to-End encryption. E2E is *NOT*
-   available in this version.
+
+-   Added `EventStatus.QUEUED` which is set on an event when it is waiting to be
+    sent by the scheduler and there are other events in front.
+-   Added support for processing push rules on an event. This can be obtained by
+    calling `MatrixClient.getPushActionsForEvent(event)`.
+-   Added WebRTC support. Outbound calls can be made via
+    `call = global.createNewMatrixCall(MatrixClient, roomId)` followed by
+    `call.placeVoiceCall()` or `call.placeVideoCall(remoteEle, localEle)`.
+    Inbound calls will be received via the event `"Call.incoming"` which provides
+    a call object which can be followed with `call.answer()` or `call.hangup()`.
+-   Added the ability to upload files to the media repository.
+-   Added the ability to change the client's password.
+-   Added the ability to register with an email via an identity server.
+-   Handle presence events by updating the associated `User` object.
+-   Handle redaction events.
+-   Added infrastructure for supporting End-to-End encryption. E2E is _NOT_
+    available in this version.
 
 New methods:
- * `MatrixClient.getUser(userId)`
- * `MatrixClient.getPushActionsForEvent(event)`
- * `MatrixClient.setPassword(auth, newPassword)`
- * `MatrixClient.loginWithSAML2(relayState, callback)`
- * `MatrixClient.getAvatarUrlForMember(member, w, h, method)`
- * `MatrixClient.mxcUrlToHttp(url, w, h, method)`
- * `MatrixClient.getAvatarUrlForRoom(room, w, h, method)`
- * `MatrixClient.uploadContent(file, callback)`
- * `Room.getMembersWithMembership(membership)`
- * `MatrixScheduler.getQueueForEvent(event)`
- * `MatrixScheduler.removeEventFromQueue(event)`
- * `$DATA_STORE.setSyncToken(token)`
- * `$DATA_STORE.getSyncToken()`
-
-Crypto infrastructure (crypto is *NOT* available in this version):
- * `global.CRYPTO_ENABLED`
- * `MatrixClient.isCryptoEnabled()`
- * `MatrixClient.uploadKeys(maxKeys)`
- * `MatrixClient.downloadKeys(userIds, forceDownload)`
- * `MatrixClient.listDeviceKeys(userId)`
- * `MatrixClient.setRoomEncryption(roomId, config)`
- * `MatrixClient.isRoomEncrypted(roomId)`
+
+-   `MatrixClient.getUser(userId)`
+-   `MatrixClient.getPushActionsForEvent(event)`
+-   `MatrixClient.setPassword(auth, newPassword)`
+-   `MatrixClient.loginWithSAML2(relayState, callback)`
+-   `MatrixClient.getAvatarUrlForMember(member, w, h, method)`
+-   `MatrixClient.mxcUrlToHttp(url, w, h, method)`
+-   `MatrixClient.getAvatarUrlForRoom(room, w, h, method)`
+-   `MatrixClient.uploadContent(file, callback)`
+-   `Room.getMembersWithMembership(membership)`
+-   `MatrixScheduler.getQueueForEvent(event)`
+-   `MatrixScheduler.removeEventFromQueue(event)`
+-   `$DATA_STORE.setSyncToken(token)`
+-   `$DATA_STORE.getSyncToken()`
+
+Crypto infrastructure (crypto is _NOT_ available in this version):
+
+-   `global.CRYPTO_ENABLED`
+-   `MatrixClient.isCryptoEnabled()`
+-   `MatrixClient.uploadKeys(maxKeys)`
+-   `MatrixClient.downloadKeys(userIds, forceDownload)`
+-   `MatrixClient.listDeviceKeys(userId)`
+-   `MatrixClient.setRoomEncryption(roomId, config)`
+-   `MatrixClient.isRoomEncrypted(roomId)`
 
 New classes:
- * `MatrixCall`
- * `WebStorageStore` - *WIP; unstable*
- * `WebStorageSessionStore` - *WIP; unstable*
+
+-   `MatrixCall`
+-   `WebStorageStore` - _WIP; unstable_
+-   `WebStorageSessionStore` - _WIP; unstable_
 
 Bug fixes:
- * Member name bugfix: Fixed an issue which prevented `RoomMember.name` being
-   disambiguated if there was exactly 1 other person with the same display name.
- * Member name bugfix: Disambiguate both clashing display names with user IDs in
-   the event of a clash.
- * Room state bugfix: Fixed a bug which incorrectly overwrote power levels
-   locally for a room.
- * Room name bugfix: Ignore users who have left the room when determining a room
-   name.
- * Events bugfix: Fixed a bug which prevented the `sender` and `target`
-   properties from being set.
-
-Changes in 0.1.1
-================
+
+-   Member name bugfix: Fixed an issue which prevented `RoomMember.name` being
+    disambiguated if there was exactly 1 other person with the same display name.
+-   Member name bugfix: Disambiguate both clashing display names with user IDs in
+    the event of a clash.
+-   Room state bugfix: Fixed a bug which incorrectly overwrote power levels
+    locally for a room.
+-   Room name bugfix: Ignore users who have left the room when determining a room
+    name.
+-   Events bugfix: Fixed a bug which prevented the `sender` and `target`
+    properties from being set.
+
+# Changes in 0.1.1
 
 **BREAKING CHANGES**:
- * `Room.calculateRoomName` is now private. Use `Room.recalculate` instead, and
-   access the calculated name via `Room.name`.
- * `new MatrixClient(...)` no longer creates a `MatrixInMemoryStore` if
-   `opts.store` is not specified. Instead, the `createClient` global function
-   creates it and passes it to the constructor. This change will not affect
-   users who have always used `createClient` to create a `MatrixClient`.
- * `"Room"` events will now be emitted when the Room has *finished* being
-   populated with state rather than at the moment of creation. This will fire
-   when the SDK encounters a room it doesn't know about (just arrived from the
-   event stream; e.g. a room invite) and will also fire after syncing room
-   state (e.g. after calling joinRoom).
- * `MatrixClient.joinRoom` now returns a `Room` object when resolved, not an
-   object with a `room_id` property.
- * `MatrixClient.scrollback` now expects a `Room` arg instead of a `room_id`
-   and `from` token. Construct a `new Room(roomId)` if you want to continue
-   using this directly, then set the pagination token using
-   `room.oldState.paginationToken = from`. It now resolves to a `Room` object
-   instead of the raw HTTP response.
+
+-   `Room.calculateRoomName` is now private. Use `Room.recalculate` instead, and
+    access the calculated name via `Room.name`.
+-   `new MatrixClient(...)` no longer creates a `MatrixInMemoryStore` if
+    `opts.store` is not specified. Instead, the `createClient` global function
+    creates it and passes it to the constructor. This change will not affect
+    users who have always used `createClient` to create a `MatrixClient`.
+-   `"Room"` events will now be emitted when the Room has _finished_ being
+    populated with state rather than at the moment of creation. This will fire
+    when the SDK encounters a room it doesn't know about (just arrived from the
+    event stream; e.g. a room invite) and will also fire after syncing room
+    state (e.g. after calling joinRoom).
+-   `MatrixClient.joinRoom` now returns a `Room` object when resolved, not an
+    object with a `room_id` property.
+-   `MatrixClient.scrollback` now expects a `Room` arg instead of a `room_id`
+    and `from` token. Construct a `new Room(roomId)` if you want to continue
+    using this directly, then set the pagination token using
+    `room.oldState.paginationToken = from`. It now resolves to a `Room` object
+    instead of the raw HTTP response.
 
 New properties:
- * `User.events`
- * `RoomMember.events`
+
+-   `User.events`
+-   `RoomMember.events`
 
 New methods:
- * `Room.hasMembershipState(userId, membership)`
- * `MatrixClient.resendEvent(event, room)`
+
+-   `Room.hasMembershipState(userId, membership)`
+-   `MatrixClient.resendEvent(event, room)`
 
 New features:
- * Local echo. When you send an event using the SDK it will immediately be
-   added to `Room.timeline` with the `event.status` of `EventStatus.SENDING`.
-   When the event is finally sent, this status will be removed.
- * Not sent status. When an event fails to send using the SDK, it will have the
-   `event.status` of `EventStatus.NOT_SENT`.
- * Retries. If events fail to send, they will be automatically retried.
- * Manual resending. Events which failed to send can be passed to
-   `MatrixClient.resendEvent(event, room)` to resend them.
- * Queueing. Messages sent in quick succession will be queued to preserve the
-   order in which they were submitted.
- * Room state is automatcally synchronised when joining a room (including if
-   another device joins a room).
- * Scrollback. You can request earlier events in a room using
-   `MatrixClient.scrollback(room, limit, callback)`.
+
+-   Local echo. When you send an event using the SDK it will immediately be
+    added to `Room.timeline` with the `event.status` of `EventStatus.SENDING`.
+    When the event is finally sent, this status will be removed.
+-   Not sent status. When an event fails to send using the SDK, it will have the
+    `event.status` of `EventStatus.NOT_SENT`.
+-   Retries. If events fail to send, they will be automatically retried.
+-   Manual resending. Events which failed to send can be passed to
+    `MatrixClient.resendEvent(event, room)` to resend them.
+-   Queueing. Messages sent in quick succession will be queued to preserve the
+    order in which they were submitted.
+-   Room state is automatcally synchronised when joining a room (including if
+    another device joins a room).
+-   Scrollback. You can request earlier events in a room using
+    `MatrixClient.scrollback(room, limit, callback)`.
 
 Bug fixes:
- * Fixed a bug which prevented the event stream from polling. Some devices will
-   black hole requests when they hibernate, meaning that the callbacks will
-   never fire. We now maintain a local timer to forcibly restart the request.
+
+-   Fixed a bug which prevented the event stream from polling. Some devices will
+    black hole requests when they hibernate, meaning that the callbacks will
+    never fire. We now maintain a local timer to forcibly restart the request.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7405ed23fd5..a7fd0989fc6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,5 +1,3 @@
-Contributing code to matrix-js-sdk
-==================================
+# Contributing code to matrix-js-sdk
 
 matrix-js-sdk follows the same pattern as https://github.com/vector-im/element-web/blob/develop/CONTRIBUTING.md
-
diff --git a/README.md b/README.md
index bb86a6f9431..79d6417c409 100644
--- a/README.md
+++ b/README.md
@@ -6,27 +6,25 @@
 [![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
 [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=bugs)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
 
-Matrix JavaScript SDK
-=====================
+# Matrix JavaScript SDK
 
 This is the [Matrix](https://matrix.org) Client-Server SDK for JavaScript and TypeScript. This SDK can be run in a
 browser or in Node.js.
 
 The Matrix specification is constantly evolving - while this SDK aims for maximum backwards compatibility, it only
 guarantees that a feature will be supported for at least 4 spec releases. For example, if a feature the js-sdk supports
-is removed in v1.4 then the feature is *eligible* for removal from the SDK when v1.8 is released. This SDK has no
+is removed in v1.4 then the feature is _eligible_ for removal from the SDK when v1.8 is released. This SDK has no
 guarantee on implementing all features of any particular spec release, currently. This can mean that the SDK will call
 endpoints from before Matrix 1.1, for example.
 
-Quickstart
-==========
+# Quickstart
+
+## In a browser
 
-In a browser
-------------
 Download the browser version from
 https://github.com/matrix-org/matrix-js-sdk/releases/latest and add that as a
-``<script>`` to your page. There will be a global variable ``matrixcs``
-attached to ``window`` through which you can access the SDK. See below for how to
+`<script>` to your page. There will be a global variable `matrixcs`
+attached to `window` through which you can access the SDK. See below for how to
 include libolm to enable end-to-end-encryption.
 
 The browser bundle supports recent versions of browsers. Typically this is ES2015
@@ -35,8 +33,7 @@ or `> 0.5%, last 2 versions, Firefox ESR, not dead` if using
 
 Please check [the working browser example](examples/browser) for more information.
 
-In Node.js
-----------
+## In Node.js
 
 Ensure you have the latest LTS version of Node.js installed.
 This library relies on `fetch` which is available in Node from v18.0.0 - it should work fine also with polyfills.
@@ -45,14 +42,14 @@ If you wish to use a ponyfill or adapter of some sort then pass it as `fetchFn`
 Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install)
 if you do not have it already.
 
-``yarn add matrix-js-sdk``
+`yarn add matrix-js-sdk`
 
 ```javascript
-  import * as sdk from "matrix-js-sdk";
-  const client = sdk.createClient("https://matrix.org");
-  client.publicRooms(function(err, data) {
+import * as sdk from "matrix-js-sdk";
+const client = sdk.createClient("https://matrix.org");
+client.publicRooms(function (err, data) {
     console.log("Public Rooms: %s", JSON.stringify(data));
-  });
+});
 ```
 
 See below for how to include libolm to enable end-to-end-encryption. Please check
@@ -61,14 +58,14 @@ See below for how to include libolm to enable end-to-end-encryption. Please chec
 To start the client:
 
 ```javascript
-await client.startClient({initialSyncLimit: 10});
+await client.startClient({ initialSyncLimit: 10 });
 ```
 
 You can perform a call to `/sync` to get the current state of the client:
 
 ```javascript
-client.once('sync', function(state, prevState, res) {
-    if(state === 'PREPARED') {
+client.once("sync", function (state, prevState, res) {
+    if (state === "PREPARED") {
         console.log("prepared");
     } else {
         console.log(state);
@@ -81,8 +78,8 @@ To send a message:
 
 ```javascript
 const content = {
-    "body": "message text",
-    "msgtype": "m.text"
+    body: "message text",
+    msgtype: "m.text",
 };
 client.sendEvent("roomId", "m.room.message", content, "", (err, res) => {
     console.log(err);
@@ -92,11 +89,11 @@ client.sendEvent("roomId", "m.room.message", content, "", (err, res) => {
 To listen for message events:
 
 ```javascript
-client.on("Room.timeline", function(event, room, toStartOfTimeline) {
-  if (event.getType() !== "m.room.message") {
-    return; // only use messages
-  }
-  console.log(event.event.content.body);
+client.on("Room.timeline", function (event, room, toStartOfTimeline) {
+    if (event.getType() !== "m.room.message") {
+        return; // only use messages
+    }
+    console.log(event.event.content.body);
 });
 ```
 
@@ -104,73 +101,70 @@ By default, the `matrix-js-sdk` client uses the `MemoryStore` to store events as
 
 ```javascript
 Object.keys(client.store.rooms).forEach((roomId) => {
-  client.getRoom(roomId).timeline.forEach(t => {
-      console.log(t.event);
-  });
+    client.getRoom(roomId).timeline.forEach((t) => {
+        console.log(t.event);
+    });
 });
 ```
 
-What does this SDK do?
-----------------------
+## What does this SDK do?
 
 This SDK provides a full object model around the Matrix Client-Server API and emits
 events for incoming data and state changes. Aside from wrapping the HTTP API, it:
- - Handles syncing (via `/initialSync` and `/events`)
- - Handles the generation of "friendly" room and member names.
- - Handles historical `RoomMember` information (e.g. display names).
- - Manages room member state across multiple events (e.g. it handles typing, power
-   levels and membership changes).
- - Exposes high-level objects like `Rooms`, `RoomState`, `RoomMembers` and `Users`
-   which can be listened to for things like name changes, new messages, membership
-   changes, presence changes, and more.
- - Handle "local echo" of messages sent using the SDK. This means that messages
-   that have just been sent will appear in the timeline as 'sending', until it
-   completes. This is beneficial because it prevents there being a gap between
-   hitting the send button and having the "remote echo" arrive.
- - Mark messages which failed to send as not sent.
- - Automatically retry requests to send messages due to network errors.
- - Automatically retry requests to send messages due to rate limiting errors.
- - Handle queueing of messages.
- - Handles pagination.
- - Handle assigning push actions for events.
- - Handles room initial sync on accepting invites.
- - Handles WebRTC calling.
+
+-   Handles syncing (via `/initialSync` and `/events`)
+-   Handles the generation of "friendly" room and member names.
+-   Handles historical `RoomMember` information (e.g. display names).
+-   Manages room member state across multiple events (e.g. it handles typing, power
+    levels and membership changes).
+-   Exposes high-level objects like `Rooms`, `RoomState`, `RoomMembers` and `Users`
+    which can be listened to for things like name changes, new messages, membership
+    changes, presence changes, and more.
+-   Handle "local echo" of messages sent using the SDK. This means that messages
+    that have just been sent will appear in the timeline as 'sending', until it
+    completes. This is beneficial because it prevents there being a gap between
+    hitting the send button and having the "remote echo" arrive.
+-   Mark messages which failed to send as not sent.
+-   Automatically retry requests to send messages due to network errors.
+-   Automatically retry requests to send messages due to rate limiting errors.
+-   Handle queueing of messages.
+-   Handles pagination.
+-   Handle assigning push actions for events.
+-   Handles room initial sync on accepting invites.
+-   Handles WebRTC calling.
 
 Later versions of the SDK will:
- - Expose a `RoomSummary` which would be suitable for a recents page.
- - Provide different pluggable storage layers (e.g. local storage, database-backed)
 
-Usage
-=====
+-   Expose a `RoomSummary` which would be suitable for a recents page.
+-   Provide different pluggable storage layers (e.g. local storage, database-backed)
 
+# Usage
 
-Conventions
------------
+## Conventions
 
 ### Emitted events
 
-The SDK will emit events using an ``EventEmitter``. It also
-emits object models (e.g. ``Rooms``, ``RoomMembers``) when they
+The SDK will emit events using an `EventEmitter`. It also
+emits object models (e.g. `Rooms`, `RoomMembers`) when they
 are updated.
 
 ```javascript
-  // Listen for low-level MatrixEvents
-  client.on("event", function(event) {
+// Listen for low-level MatrixEvents
+client.on("event", function (event) {
     console.log(event.getType());
-  });
+});
 
-  // Listen for typing changes
-  client.on("RoomMember.typing", function(event, member) {
+// Listen for typing changes
+client.on("RoomMember.typing", function (event, member) {
     if (member.typing) {
-      console.log(member.name + " is typing...");
-    }
-    else {
-      console.log(member.name + " stopped typing.");
+        console.log(member.name + " is typing...");
+    } else {
+        console.log(member.name + " stopped typing.");
     }
-  });
+});
 
-  // start the client to setup the connection to the server
-  client.startClient();
+// start the client to setup the connection to the server
+client.startClient();
 ```
 
 ### Promises and Callbacks
@@ -187,11 +181,11 @@ The typical usage is something like:
   });
 ```
 
-Alternatively, if you have a Node.js-style ``callback(err, result)`` function,
+Alternatively, if you have a Node.js-style `callback(err, result)` function,
 you can pass the result of the promise into it with something like:
 
 ```javascript
-  matrixClient.someMethod(arg1, arg2).nodeify(callback);
+matrixClient.someMethod(arg1, arg2).nodeify(callback);
 ```
 
 The main thing to note is that it is problematic to discard the result of a
@@ -199,61 +193,65 @@ promise-returning function, as that will cause exceptions to go unobserved.
 
 Methods which return a promise show this in their documentation.
 
-Many methods in the SDK support *both* Node.js-style callbacks *and* Promises,
-via an optional ``callback`` argument. The callback support is now deprecated:
-new methods do not include a ``callback`` argument, and in the future it may be
+Many methods in the SDK support _both_ Node.js-style callbacks _and_ Promises,
+via an optional `callback` argument. The callback support is now deprecated:
+new methods do not include a `callback` argument, and in the future it may be
 removed from existing methods.
 
-Examples
---------
+## Examples
+
 This section provides some useful code snippets which demonstrate the
 core functionality of the SDK. These examples assume the SDK is setup like this:
 
 ```javascript
-   import * as sdk from "matrix-js-sdk";
-   const myUserId = "@example:localhost";
-   const myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
-   const matrixClient = sdk.createClient({
-       baseUrl: "http://localhost:8008",
-       accessToken: myAccessToken,
-       userId: myUserId
-   });
+import * as sdk from "matrix-js-sdk";
+const myUserId = "@example:localhost";
+const myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
+const matrixClient = sdk.createClient({
+    baseUrl: "http://localhost:8008",
+    accessToken: myAccessToken,
+    userId: myUserId,
+});
 ```
 
 ### Automatically join rooms when invited
 
 ```javascript
-   matrixClient.on("RoomMember.membership", function(event, member) {
-       if (member.membership === "invite" && member.userId === myUserId) {
-           matrixClient.joinRoom(member.roomId).then(function() {
-               console.log("Auto-joined %s", member.roomId);
-           });
-       }
-   });
-
-   matrixClient.startClient();
+matrixClient.on("RoomMember.membership", function (event, member) {
+    if (member.membership === "invite" && member.userId === myUserId) {
+        matrixClient.joinRoom(member.roomId).then(function () {
+            console.log("Auto-joined %s", member.roomId);
+        });
+    }
+});
+
+matrixClient.startClient();
 ```
 
 ### Print out messages for all rooms
 
 ```javascript
-   matrixClient.on("Room.timeline", function(event, room, toStartOfTimeline) {
-       if (toStartOfTimeline) {
-           return; // don't print paginated results
-       }
-       if (event.getType() !== "m.room.message") {
-           return; // only print messages
-       }
-       console.log(
-           // the room name will update with m.room.name events automatically
-           "(%s) %s :: %s", room.name, event.getSender(), event.getContent().body
-       );
-   });
-
-   matrixClient.startClient();
+matrixClient.on("Room.timeline", function (event, room, toStartOfTimeline) {
+    if (toStartOfTimeline) {
+        return; // don't print paginated results
+    }
+    if (event.getType() !== "m.room.message") {
+        return; // only print messages
+    }
+    console.log(
+        // the room name will update with m.room.name events automatically
+        "(%s) %s :: %s",
+        room.name,
+        event.getSender(),
+        event.getContent().body,
+    );
+});
+
+matrixClient.startClient();
 ```
 
 Output:
+
 ```
   (My Room) @megan:localhost :: Hello world
   (My Room) @megan:localhost :: how are you?
@@ -265,27 +263,24 @@ Output:
 ### Print out membership lists whenever they are changed
 
 ```javascript
-   matrixClient.on("RoomState.members", function(event, state, member) {
-       const room = matrixClient.getRoom(state.roomId);
-       if (!room) {
-           return;
-       }
-       const memberList = state.getMembers();
-       console.log(room.name);
-       console.log(Array(room.name.length + 1).join("="));  // underline
-       for (var i = 0; i < memberList.length; i++) {
-           console.log(
-               "(%s) %s",
-               memberList[i].membership,
-               memberList[i].name
-           );
-       }
-   });
-
-   matrixClient.startClient();
+matrixClient.on("RoomState.members", function (event, state, member) {
+    const room = matrixClient.getRoom(state.roomId);
+    if (!room) {
+        return;
+    }
+    const memberList = state.getMembers();
+    console.log(room.name);
+    console.log(Array(room.name.length + 1).join("=")); // underline
+    for (var i = 0; i < memberList.length; i++) {
+        console.log("(%s) %s", memberList[i].membership, memberList[i].name);
+    }
+});
+
+matrixClient.startClient();
 ```
 
 Output:
+
 ```
   My Room
   =======
@@ -295,8 +290,7 @@ Output:
   (invite) @charlie:localhost
 ```
 
-API Reference
-=============
+# API Reference
 
 A hosted reference can be found at
 http://matrix-org.github.io/matrix-js-sdk/index.html
@@ -310,21 +304,20 @@ host the API reference from the source files like this:
   $ python -m http.server 8005
 ```
 
-Then visit ``http://localhost:8005`` to see the API docs.
+Then visit `http://localhost:8005` to see the API docs.
 
-End-to-end encryption support
-=============================
+# End-to-end encryption support
 
 The SDK supports end-to-end encryption via the Olm and Megolm protocols, using
 [libolm](https://gitlab.matrix.org/matrix-org/olm). It is left up to the
-application to make libolm available, via the ``Olm`` global.
+application to make libolm available, via the `Olm` global.
 
-It is also necessary to call ``await matrixClient.initCrypto()`` after creating a new
-``MatrixClient`` (but **before** calling ``matrixClient.startClient()``) to
+It is also necessary to call `await matrixClient.initCrypto()` after creating a new
+`MatrixClient` (but **before** calling `matrixClient.startClient()`) to
 initialise the crypto layer.
 
-If the ``Olm`` global is not available, the SDK will show a warning, as shown
-below; ``initCrypto()`` will also fail.
+If the `Olm` global is not available, the SDK will show a warning, as shown
+below; `initCrypto()` will also fail.
 
 ```
 Unable to load crypto module: crypto will be disabled: Error: global.Olm is not defined
@@ -336,41 +329,42 @@ specification.
 
 To provide the Olm library in a browser application:
 
- * download the transpiled libolm (from https://packages.matrix.org/npm/olm/).
- * load ``olm.js`` as a ``<script>`` *before* ``browser-matrix.js``.
+-   download the transpiled libolm (from https://packages.matrix.org/npm/olm/).
+-   load `olm.js` as a `<script>` _before_ `browser-matrix.js`.
 
 To provide the Olm library in a node.js application:
 
- * ``yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz``
-   (replace the URL with the latest version you want to use from
+-   `yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz`
+    (replace the URL with the latest version you want to use from
     https://packages.matrix.org/npm/olm/)
- * ``global.Olm = require('olm');`` *before* loading ``matrix-js-sdk``.
+-   `global.Olm = require('olm');` _before_ loading `matrix-js-sdk`.
 
 If you want to package Olm as dependency for your node.js application, you can
-use ``yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz``. If your
-application also works without e2e crypto enabled, add ``--optional`` to mark it
+use `yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz`. If your
+application also works without e2e crypto enabled, add `--optional` to mark it
 as an optional dependency.
 
+# Contributing
 
-Contributing
-============
-*This section is for people who want to modify the SDK. If you just
-want to use this SDK, skip this section.*
+_This section is for people who want to modify the SDK. If you just
+want to use this SDK, skip this section._
 
 First, you need to pull in the right build tools:
+
 ```
  $ yarn install
 ```
 
-Building
---------
+## Building
 
 To build a browser version from scratch when developing::
+
 ```
  $ yarn build
 ```
 
 To run tests (Jest):
+
 ```
  $ yarn test
 ```
@@ -379,6 +373,7 @@ To run tests (Jest):
 > The `sync-browserify.spec.ts` requires a browser build (`yarn build`) in order to pass
 
 To run linting:
+
 ```
  $ yarn lint
 ```
diff --git a/docs/storage-notes.md b/docs/storage-notes.md
index 55bc1243782..0f615298908 100644
--- a/docs/storage-notes.md
+++ b/docs/storage-notes.md
@@ -20,19 +20,19 @@ blurrier.
 
 When we are low on disk space overall or near the group limit / origin quota:
 
-* Chrome
-    * Log database may fail to start with AbortError
-    * IndexedDB fails to start for crypto: AbortError in connect from
-      indexeddb-store-worker
-    * When near the quota, QuotaExceededError is used more consistently
-* Firefox
-    * The first error will be QuotaExceededError
-    * Future write attempts will fail with various errors when space is low,
-      including nonsense like "InvalidStateError: A mutation operation was
-      attempted on a database that did not allow mutations."
-    * Once you start getting errors, the DB is effectively wedged in read-only
-      mode
-    * Can revive access if you reopen the DB
+-   Chrome
+    -   Log database may fail to start with AbortError
+    -   IndexedDB fails to start for crypto: AbortError in connect from
+        indexeddb-store-worker
+    -   When near the quota, QuotaExceededError is used more consistently
+-   Firefox
+    -   The first error will be QuotaExceededError
+    -   Future write attempts will fail with various errors when space is low,
+        including nonsense like "InvalidStateError: A mutation operation was
+        attempted on a database that did not allow mutations."
+    -   Once you start getting errors, the DB is effectively wedged in read-only
+        mode
+    -   Can revive access if you reopen the DB
 
 ## Cache Eviction
 
@@ -41,9 +41,9 @@ limited by a single quota, in practice, browsers appear to handle `localStorage`
 separately from the others, so it has a separate quota limit and isn't evicted
 when low on space.
 
-* Chrome, Firefox
-    * IndexedDB for origin deleted
-    * Local Storage remains in place
+-   Chrome, Firefox
+    -   IndexedDB for origin deleted
+    -   Local Storage remains in place
 
 ## Persistent Storage
 
@@ -51,20 +51,20 @@ Storage Standard offers a `navigator.storage.persist` API that can be used to
 request persistent storage that won't be deleted by the browser because of low
 space.
 
-* Chrome
-    * Chrome 75 seems to grant this without any prompt based on [interaction
-      criteria](https://developers.google.com/web/updates/2016/06/persistent-storage)
-* Firefox
-    * Firefox 67 shows a prompt to grant
-    * Reverting persistent seems to require revoking permission _and_ clearing
-      site data
+-   Chrome
+    -   Chrome 75 seems to grant this without any prompt based on [interaction
+        criteria](https://developers.google.com/web/updates/2016/06/persistent-storage)
+-   Firefox
+    -   Firefox 67 shows a prompt to grant
+    -   Reverting persistent seems to require revoking permission _and_ clearing
+        site data
 
 ## Storage Estimation
 
 Storage Standard offers a `navigator.storage.estimate` API to get some clue of
 how much space remains.
 
-* Chrome, Firefox
-    * Can run this at any time to request an estimate of space remaining
-* Firefox
-    * Returns `0` for `usage` if a site is persisted
+-   Chrome, Firefox
+    -   Can run this at any time to request an estimate of space remaining
+-   Firefox
+    -   Returns `0` for `usage` if a site is persisted
diff --git a/examples/browser/README.md b/examples/browser/README.md
index 45c1d20217c..3f52a4c4610 100644
--- a/examples/browser/README.md
+++ b/examples/browser/README.md
@@ -6,4 +6,4 @@ To try it out, **you must build the SDK first** and then host this folder:
  $ python -m http.server 8003
 ```
 
-Then visit ``http://localhost:8003``.
+Then visit `http://localhost:8003`.
diff --git a/examples/browser/browserTest.js b/examples/browser/browserTest.js
index 891dd176b06..834c731cb7a 100644
--- a/examples/browser/browserTest.js
+++ b/examples/browser/browserTest.js
@@ -1,6 +1,6 @@
 console.log("Loading browser sdk");
 
-var client = matrixcs.createClient({baseUrl: "https://matrix.org"});
+var client = matrixcs.createClient({ baseUrl: "https://matrix.org" });
 client.publicRooms().then(function (data) {
     console.log("data %s [...]", JSON.stringify(data).substring(0, 100));
     console.log("Congratulations! The SDK is working on the browser!");
diff --git a/examples/browser/index.html b/examples/browser/index.html
index 3262a33d5ec..659c18d1929 100644
--- a/examples/browser/index.html
+++ b/examples/browser/index.html
@@ -1,18 +1,17 @@
 <html lang="en">
-<head>
-<title>Test</title>
-<meta charset="utf-8"/>
-<link rel="icon" href="data:,">
-<script src="lib/matrix.js"></script>
-<script src="browserTest.js"></script>
-</head>
-<body>
-	Sanity Testing (check the console) : This example is here to make sure that
-    the SDK works inside a browser. It simply does a GET /publicRooms on
-    matrix.org
-    <br/>
-    You should see a message confirming that the SDK works below:
-    <br/>
-    <div id="result"></div>
-</body>
+    <head>
+        <title>Test</title>
+        <meta charset="utf-8" />
+        <link rel="icon" href="data:," />
+        <script src="lib/matrix.js"></script>
+        <script src="browserTest.js"></script>
+    </head>
+    <body>
+        Sanity Testing (check the console) : This example is here to make sure that the SDK works inside a browser. It
+        simply does a GET /publicRooms on matrix.org
+        <br />
+        You should see a message confirming that the SDK works below:
+        <br />
+        <div id="result"></div>
+    </body>
 </html>
diff --git a/examples/crypto-browser/olm-device-export-import.html b/examples/crypto-browser/olm-device-export-import.html
index 7f4b356b1f8..c6efc76e1c3 100644
--- a/examples/crypto-browser/olm-device-export-import.html
+++ b/examples/crypto-browser/olm-device-export-import.html
@@ -1,59 +1,60 @@
 <!DOCTYPE html>
 <html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta http-equiv="X-UA-Compatible" content="ie=edge">
-    <title>Test Crypto in Browser</title>
-    <script src="lib/olm.js"></script>
-    <script src="lib/matrix.js"></script>
-</head>
-<body>
-    <h1>Testing export/import of Olm devices in the browser</h1>
-    <ul>
-        <li>
-            Make sure you built the current version of the Matrix JS SDK
-            (<code>yarn build</code>)
-        </li>
-        <li>
-            copy <code>olm.js</code> and <code>olm.wasm</code>
-            from a recent release of Olm (was tested with version 3.1.4)
-            in directory <code>lib/</code>
-        </li>
-        <li>start a local Matrix homeserver (on port 8008, or change the port in the code)</li>
-        <li>Serve this HTML file (e.g. <code>python3 -m http.server</code>) and go to it through your browser</li>
-        <li>
-            in the JS console, do:
-            <pre>
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <meta http-equiv="X-UA-Compatible" content="ie=edge" />
+        <title>Test Crypto in Browser</title>
+        <script src="lib/olm.js"></script>
+        <script src="lib/matrix.js"></script>
+    </head>
+    <body>
+        <h1>Testing export/import of Olm devices in the browser</h1>
+        <ul>
+            <li>Make sure you built the current version of the Matrix JS SDK (<code>yarn build</code>)</li>
+            <li>
+                copy <code>olm.js</code> and <code>olm.wasm</code> from a recent release of Olm (was tested with version
+                3.1.4) in directory <code>lib/</code>
+            </li>
+            <li>start a local Matrix homeserver (on port 8008, or change the port in the code)</li>
+            <li>Serve this HTML file (e.g. <code>python3 -m http.server</code>) and go to it through your browser</li>
+            <li>
+                in the JS console, do:
+                <pre>
 aliceMatrixClient = await newMatrixClient("alice-"+randomHex());
 await aliceMatrixClient.exportDevice();
 await aliceMatrixClient.getAccessToken();
-            </pre>
-        </li>
-        <li>
-            copy the result of <code>exportDevice</code> and <code>getAccessToken</code> somewhere
-            (<strong>not</strong> in a JS variable as it will be destroyed when you refresh the page)
-        </li>
-        <li><strong>refresh the page (F5)</strong> to make sure the client is destroyed</li>
-        <li>
-            Do the following, replacing <code>ALICE_ID</code>
-            with the user ID of Alice (you can find it in the exported data)
-            <pre>
+            </pre
+                >
+            </li>
+            <li>
+                copy the result of <code>exportDevice</code> and <code>getAccessToken</code> somewhere (<strong
+                    >not</strong
+                >
+                in a JS variable as it will be destroyed when you refresh the page)
+            </li>
+            <li><strong>refresh the page (F5)</strong> to make sure the client is destroyed</li>
+            <li>
+                Do the following, replacing <code>ALICE_ID</code>
+                with the user ID of Alice (you can find it in the exported data)
+                <pre>
 bobMatrixClient = await newMatrixClient("bob-"+randomHex());
 roomId = await bobMatrixClient.createEncryptedRoom([ALICE_ID]);
 await bobMatrixClient.sendTextMessage('Hi Alice!', roomId);
-            </pre>
-        </li>
-        <li>Again, <strong>refresh the page (F5)</strong>. You may want to clear your console as well.</li>
-        <li>
-            Now do the following, using the exported data and the access token you saved previously:
-            <pre>
+            </pre
+                >
+            </li>
+            <li>Again, <strong>refresh the page (F5)</strong>. You may want to clear your console as well.</li>
+            <li>
+                Now do the following, using the exported data and the access token you saved previously:
+                <pre>
 aliceMatrixClient = await importMatrixClient(EXPORTED_DATA, ACCESS_TOKEN);
-            </pre>
-        </li>
-        <li>You should see the message sent by Bob printed in the console.</li>
-    </ul>
+            </pre
+                >
+            </li>
+            <li>You should see the message sent by Bob printed in the console.</li>
+        </ul>
 
-    <script src="olm-device-export-import.js"></script>
-</body>
-</html>
\ No newline at end of file
+        <script src="olm-device-export-import.js"></script>
+    </body>
+</html>
diff --git a/examples/crypto-browser/olm-device-export-import.js b/examples/crypto-browser/olm-device-export-import.js
index 0529b73fd8c..ef5be8a65d4 100644
--- a/examples/crypto-browser/olm-device-export-import.js
+++ b/examples/crypto-browser/olm-device-export-import.js
@@ -1,34 +1,26 @@
 if (!Olm) {
-    console.error(
-        "global.Olm does not seem to be present."
-        + " Did you forget to add olm in the lib/ directory?"
-    );
+    console.error("global.Olm does not seem to be present." + " Did you forget to add olm in the lib/ directory?");
 }
 
-const BASE_URL = 'http://localhost:8008';
-const ROOM_CRYPTO_CONFIG = { algorithm: 'm.megolm.v1.aes-sha2' };
-const PASSWORD = 'password';
+const BASE_URL = "http://localhost:8008";
+const ROOM_CRYPTO_CONFIG = { algorithm: "m.megolm.v1.aes-sha2" };
+const PASSWORD = "password";
 
 // useful to create new usernames
-window.randomHex = () => Math.floor(Math.random() * (10**6)).toString(16);
+window.randomHex = () => Math.floor(Math.random() * 10 ** 6).toString(16);
 
 window.newMatrixClient = async function (username) {
     const registrationClient = matrixcs.createClient(BASE_URL);
 
-    const userRegisterResult = await registrationClient.register(
-      username,
-      PASSWORD,
-      null,
-      { type: 'm.login.dummy' }
-    );
-  
+    const userRegisterResult = await registrationClient.register(username, PASSWORD, null, { type: "m.login.dummy" });
+
     const matrixClient = matrixcs.createClient({
-      baseUrl: BASE_URL,
-      userId: userRegisterResult.user_id,
-      accessToken: userRegisterResult.access_token,
-      deviceId: userRegisterResult.device_id,
-      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
-      cryptoStore: new matrixcs.MemoryCryptoStore(),
+        baseUrl: BASE_URL,
+        userId: userRegisterResult.user_id,
+        accessToken: userRegisterResult.access_token,
+        deviceId: userRegisterResult.device_id,
+        sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
+        cryptoStore: new matrixcs.MemoryCryptoStore(),
     });
 
     extendMatrixClient(matrixClient);
@@ -36,15 +28,15 @@ window.newMatrixClient = async function (username) {
     await matrixClient.initCrypto();
     await matrixClient.startClient();
     return matrixClient;
-}
+};
 
 window.importMatrixClient = async function (exportedDevice, accessToken) {
     const matrixClient = matrixcs.createClient({
-      baseUrl: BASE_URL,
-      deviceToImport: exportedDevice,
-      accessToken,
-      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
-      cryptoStore: new matrixcs.MemoryCryptoStore(),
+        baseUrl: BASE_URL,
+        deviceToImport: exportedDevice,
+        accessToken,
+        sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
+        cryptoStore: new matrixcs.MemoryCryptoStore(),
     });
 
     extendMatrixClient(matrixClient);
@@ -52,71 +44,62 @@ window.importMatrixClient = async function (exportedDevice, accessToken) {
     await matrixClient.initCrypto();
     await matrixClient.startClient();
     return matrixClient;
-}
+};
 
 function extendMatrixClient(matrixClient) {
     // automatic join
-    matrixClient.on('RoomMember.membership', async (event, member) => {
-        if (member.membership === 'invite' && member.userId === matrixClient.getUserId()) {
+    matrixClient.on("RoomMember.membership", async (event, member) => {
+        if (member.membership === "invite" && member.userId === matrixClient.getUserId()) {
             await matrixClient.joinRoom(member.roomId);
             // setting up of room encryption seems to be triggered automatically
             // but if we don't wait for it the first messages we send are unencrypted
-            await matrixClient.setRoomEncryption(member.roomId, { algorithm: 'm.megolm.v1.aes-sha2' })
+            await matrixClient.setRoomEncryption(member.roomId, { algorithm: "m.megolm.v1.aes-sha2" });
         }
     });
 
-    matrixClient.onDecryptedMessage = message => {
-        console.log('Got encrypted message: ', message);
-    }
+    matrixClient.onDecryptedMessage = (message) => {
+        console.log("Got encrypted message: ", message);
+    };
 
-    matrixClient.on('Event.decrypted', (event) => {
-        if (event.getType() === 'm.room.message'){
+    matrixClient.on("Event.decrypted", (event) => {
+        if (event.getType() === "m.room.message") {
             matrixClient.onDecryptedMessage(event.getContent().body);
         } else {
-            console.log('decrypted an event of type', event.getType());
+            console.log("decrypted an event of type", event.getType());
             console.log(event);
         }
     });
-  
-    matrixClient.createEncryptedRoom = async function(usersToInvite) {
-        const {
-          room_id: roomId,
-        } = await this.createRoom({
-          visibility: 'private',
-          invite: usersToInvite,
+
+    matrixClient.createEncryptedRoom = async function (usersToInvite) {
+        const { room_id: roomId } = await this.createRoom({
+            visibility: "private",
+            invite: usersToInvite,
         });
 
         // matrixClient.setRoomEncryption() only updates local state
         // but does not send anything to the server
         // (see https://github.com/matrix-org/matrix-js-sdk/issues/905)
         // so we do it ourselves with 'sendStateEvent'
-        await this.sendStateEvent(
-          roomId, 'm.room.encryption', ROOM_CRYPTO_CONFIG,
-        );
-        await this.setRoomEncryption(
-          roomId, ROOM_CRYPTO_CONFIG,
-        );
+        await this.sendStateEvent(roomId, "m.room.encryption", ROOM_CRYPTO_CONFIG);
+        await this.setRoomEncryption(roomId, ROOM_CRYPTO_CONFIG);
 
         // Marking all devices as verified
         let room = this.getRoom(roomId);
-        let members = (await room.getEncryptionTargetMembers()).map(x => x["userId"])
+        let members = (await room.getEncryptionTargetMembers()).map((x) => x["userId"]);
         let memberkeys = await this.downloadKeys(members);
         for (const userId in memberkeys) {
-          for (const deviceId in memberkeys[userId]) {
-            await this.setDeviceVerified(userId, deviceId);
-          }
+            for (const deviceId in memberkeys[userId]) {
+                await this.setDeviceVerified(userId, deviceId);
+            }
         }
 
         return roomId;
-    }
-
-    matrixClient.sendTextMessage = async function(message, roomId) {
-        return matrixClient.sendMessage(
-            roomId,
-            {
-                body: message,
-                msgtype: 'm.text',
-            }
-        )
-    }
-}
\ No newline at end of file
+    };
+
+    matrixClient.sendTextMessage = async function (message, roomId) {
+        return matrixClient.sendMessage(roomId, {
+            body: message,
+            msgtype: "m.text",
+        });
+    };
+}
diff --git a/examples/node/README.md b/examples/node/README.md
index 0c96940dfd1..6947931e6e6 100644
--- a/examples/node/README.md
+++ b/examples/node/README.md
@@ -1,6 +1,5 @@
 This is a functional terminal app which allows you to see the room list for a user, join rooms, send messages and view room membership lists.
 
-
 To try it out, you will need to edit `app.js` to configure it for your `homeserver`, `access_token` and `user_id`. Then run:
 
 ```
@@ -24,7 +23,7 @@ Room list index commands:
 Room commands:
   '/exit' Return to the room list index.
   '/members' Show the room member list.
-  
+
 $ /enter 2
 
 [2015-06-12 15:14:54] Megan2 <<< herro
diff --git a/examples/node/app.js b/examples/node/app.js
index ae7eb707690..e381f6c51cb 100644
--- a/examples/node/app.js
+++ b/examples/node/app.js
@@ -5,7 +5,7 @@ var clc = require("cli-color");
 var matrixClient = sdk.createClient({
     baseUrl: "http://localhost:8008",
     accessToken: myAccessToken,
-    userId: myUserId
+    userId: myUserId,
 });
 
 // Data structures
@@ -14,15 +14,15 @@ var viewingRoom = null;
 var numMessagesToShow = 20;
 
 // Reading from stdin
-var CLEAR_CONSOLE = '\x1B[2J';
+var CLEAR_CONSOLE = "\x1B[2J";
 var readline = require("readline");
 var rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    completer: completer
+    completer: completer,
 });
 rl.setPrompt("$ ");
-rl.on('line', function(line) {
+rl.on("line", function (line) {
     if (line.trim().length === 0) {
         rl.prompt();
         return;
@@ -37,14 +37,11 @@ rl.on('line', function(line) {
         if (line === "/exit") {
             viewingRoom = null;
             printRoomList();
-        }
-        else if (line === "/members") {
+        } else if (line === "/members") {
             printMemberList(viewingRoom);
-        }
-        else if (line === "/roominfo") {
+        } else if (line === "/roominfo") {
             printRoomInfo(viewingRoom);
-        }
-        else if (line === "/resend") {
+        } else if (line === "/resend") {
             // get the oldest not sent event.
             var notSentEvent;
             for (var i = 0; i < viewingRoom.timeline.length; i++) {
@@ -54,76 +51,84 @@ rl.on('line', function(line) {
                 }
             }
             if (notSentEvent) {
-                matrixClient.resendEvent(notSentEvent, viewingRoom).then(function() {
-                    printMessages();
-                    rl.prompt();
-                }, function(err) {
-                    printMessages();
-                    print("/resend Error: %s", err);
-                    rl.prompt();
-                });
+                matrixClient.resendEvent(notSentEvent, viewingRoom).then(
+                    function () {
+                        printMessages();
+                        rl.prompt();
+                    },
+                    function (err) {
+                        printMessages();
+                        print("/resend Error: %s", err);
+                        rl.prompt();
+                    },
+                );
                 printMessages();
                 rl.prompt();
             }
-        }
-        else if (line.indexOf("/more ") === 0) {
+        } else if (line.indexOf("/more ") === 0) {
             var amount = parseInt(line.split(" ")[1]) || 20;
-            matrixClient.scrollback(viewingRoom, amount).then(function(room) {
-                printMessages();
-                rl.prompt();
-            }, function(err) {
-                print("/more Error: %s", err);
-            });
-        }
-        else if (line.indexOf("/invite ") === 0) {
+            matrixClient.scrollback(viewingRoom, amount).then(
+                function (room) {
+                    printMessages();
+                    rl.prompt();
+                },
+                function (err) {
+                    print("/more Error: %s", err);
+                },
+            );
+        } else if (line.indexOf("/invite ") === 0) {
             var userId = line.split(" ")[1].trim();
-            matrixClient.invite(viewingRoom.roomId, userId).then(function() {
-                printMessages();
-                rl.prompt();
-            }, function(err) {
-                print("/invite Error: %s", err);
-            });
-        }
-        else if (line.indexOf("/file ") === 0) {
+            matrixClient.invite(viewingRoom.roomId, userId).then(
+                function () {
+                    printMessages();
+                    rl.prompt();
+                },
+                function (err) {
+                    print("/invite Error: %s", err);
+                },
+            );
+        } else if (line.indexOf("/file ") === 0) {
             var filename = line.split(" ")[1].trim();
             var stream = fs.createReadStream(filename);
-            matrixClient.uploadContent({
-                stream: stream,
-                name: filename
-            }).then(function(url) {
-                var content = {
-                    msgtype: "m.file",
-                    body: filename,
-                    url: JSON.parse(url).content_uri
-                };
-                matrixClient.sendMessage(viewingRoom.roomId, content);
-            });
-        }
-        else {
-            matrixClient.sendTextMessage(viewingRoom.roomId, line).finally(function() {
+            matrixClient
+                .uploadContent({
+                    stream: stream,
+                    name: filename,
+                })
+                .then(function (url) {
+                    var content = {
+                        msgtype: "m.file",
+                        body: filename,
+                        url: JSON.parse(url).content_uri,
+                    };
+                    matrixClient.sendMessage(viewingRoom.roomId, content);
+                });
+        } else {
+            matrixClient.sendTextMessage(viewingRoom.roomId, line).finally(function () {
                 printMessages();
                 rl.prompt();
             });
             // print local echo immediately
             printMessages();
         }
-    }
-    else {
+    } else {
         if (line.indexOf("/join ") === 0) {
             var roomIndex = line.split(" ")[1];
             viewingRoom = roomList[roomIndex];
             if (viewingRoom.getMember(myUserId).membership === "invite") {
                 // join the room first
-                matrixClient.joinRoom(viewingRoom.roomId).then(function(room) {
-                    setRoomList();
-                    viewingRoom = room;
-                    printMessages();
-                    rl.prompt();
-                }, function(err) {
-                    print("/join Error: %s", err);
-                });
-            }
-            else {
+                matrixClient.joinRoom(viewingRoom.roomId).then(
+                    function (room) {
+                        setRoomList();
+                        viewingRoom = room;
+                        printMessages();
+                        rl.prompt();
+                    },
+                    function (err) {
+                        print("/join Error: %s", err);
+                    },
+                );
+            } else {
                 printMessages();
             }
         }
@@ -133,18 +138,18 @@ rl.on('line', function(line) {
 // ==== END User input
 
 // show the room list after syncing.
-matrixClient.on("sync", function(state, prevState, data) {
+matrixClient.on("sync", function (state, prevState, data) {
     switch (state) {
         case "PREPARED":
-          setRoomList();
-          printRoomList();
-          printHelp();
-          rl.prompt();
-        break;
-   }
+            setRoomList();
+            printRoomList();
+            printHelp();
+            rl.prompt();
+            break;
+    }
 });
 
-matrixClient.on("Room", function() {
+matrixClient.on("Room", function () {
     setRoomList();
     if (!viewingRoom) {
         printRoomList();
@@ -153,7 +158,7 @@ matrixClient.on("Room", function() {
 });
 
 // print incoming messages.
-matrixClient.on("Room.timeline", function(event, room, toStartOfTimeline) {
+matrixClient.on("Room.timeline", function (event, room, toStartOfTimeline) {
     if (toStartOfTimeline) {
         return; // don't print paginated results
     }
@@ -165,20 +170,19 @@ matrixClient.on("Room.timeline", function(event, room, toStartOfTimeline) {
 
 function setRoomList() {
     roomList = matrixClient.getRooms();
-    roomList.sort(function(a,b) {
+    roomList.sort(function (a, b) {
         // < 0 = a comes first (lower index) - we want high indexes = newer
-        var aMsg = a.timeline[a.timeline.length-1];
+        var aMsg = a.timeline[a.timeline.length - 1];
         if (!aMsg) {
             return -1;
         }
-        var bMsg = b.timeline[b.timeline.length-1];
+        var bMsg = b.timeline[b.timeline.length - 1];
         if (!bMsg) {
             return 1;
         }
         if (aMsg.getTs() > bMsg.getTs()) {
             return 1;
-        }
-        else if (aMsg.getTs() < bMsg.getTs()) {
+        } else if (aMsg.getTs() < bMsg.getTs()) {
             return -1;
         }
         return 0;
@@ -189,16 +193,15 @@ function printRoomList() {
     print(CLEAR_CONSOLE);
     print("Room List:");
     var fmts = {
-        "invite": clc.cyanBright,
-        "leave": clc.blackBright
+        invite: clc.cyanBright,
+        leave: clc.blackBright,
     };
     for (var i = 0; i < roomList.length; i++) {
-        var msg = roomList[i].timeline[roomList[i].timeline.length-1];
+        var msg = roomList[i].timeline[roomList[i].timeline.length - 1];
         var dateStr = "---";
         var fmt;
         if (msg) {
-            dateStr = new Date(msg.getTs()).toISOString().replace(
-                /T/, ' ').replace(/\..+/, '');
+            dateStr = new Date(msg.getTs()).toISOString().replace(/T/, " ").replace(/\..+/, "");
         }
         var myMembership = roomList[i].getMyMembership();
         if (myMembership) {
@@ -207,9 +210,10 @@ function printRoomList() {
         var roomName = fixWidth(roomList[i].name, 25);
         print(
             "[%s] %s (%s members)  %s",
-            i, fmt ? fmt(roomName) : roomName,
+            i,
+            fmt ? fmt(roomName) : roomName,
             roomList[i].getJoinedMembers().length,
-            dateStr
+            dateStr,
         );
     }
 }
@@ -230,12 +234,12 @@ function printHelp() {
 }
 
 function completer(line) {
-    var completions = [
-        "/help", "/join ", "/exit", "/members", "/more ", "/resend", "/invite"
-    ];
-    var hits = completions.filter(function(c) { return c.indexOf(line) == 0 });
+    var completions = ["/help", "/join ", "/exit", "/members", "/more ", "/resend", "/invite"];
+    var hits = completions.filter(function (c) {
+        return c.indexOf(line) == 0;
+    });
     // show all completions if none found
-    return [hits.length ? hits : completions, line]
+    return [hits.length ? hits : completions, line];
 }
 
 function printMessages() {
@@ -252,14 +256,14 @@ function printMessages() {
 
 function printMemberList(room) {
     var fmts = {
-        "join": clc.green,
-        "ban": clc.red,
-        "invite": clc.blue,
-        "leave": clc.blackBright
+        join: clc.green,
+        ban: clc.red,
+        invite: clc.blue,
+        leave: clc.blackBright,
     };
     var members = room.currentState.getMembers();
     // sorted based on name.
-    members.sort(function(a, b) {
+    members.sort(function (a, b) {
         if (a.name > b.name) {
             return -1;
         }
@@ -268,21 +272,24 @@ function printMemberList(room) {
         }
         return 0;
     });
-    print("Membership list for room \"%s\"", room.name);
+    print('Membership list for room "%s"', room.name);
     print(new Array(room.name.length + 28).join("-"));
-    room.currentState.getMembers().forEach(function(member) {
+    room.currentState.getMembers().forEach(function (member) {
         if (!member.membership) {
             return;
         }
-        var fmt = fmts[member.membership] || function(a){return a;};
-        var membershipWithPadding = (
-            member.membership + new Array(10 - member.membership.length).join(" ")
-        );
+        var fmt =
+            fmts[member.membership] ||
+            function (a) {
+                return a;
+            };
+        var membershipWithPadding = member.membership + new Array(10 - member.membership.length).join(" ");
         print(
-            "%s"+fmt(" :: ")+"%s"+fmt(" (")+"%s"+fmt(")"),
-            membershipWithPadding, member.name,
-            (member.userId === myUserId ? "Me" : member.userId),
-            fmt
+            "%s" + fmt(" :: ") + "%s" + fmt(" (") + "%s" + fmt(")"),
+            membershipWithPadding,
+            member.name,
+            member.userId === myUserId ? "Me" : member.userId,
+            fmt,
         );
     });
 }
@@ -292,38 +299,31 @@ function printRoomInfo(room) {
     var eTypeHeader = "    Event Type(state_key)    ";
     var sendHeader = "        Sender        ";
     // pad content to 100
-    var restCount = (
-        100 - "Content".length - " | ".length - " | ".length -
-        eTypeHeader.length - sendHeader.length
-    );
-    var padSide = new Array(Math.floor(restCount/2)).join(" ");
+    var restCount = 100 - "Content".length - " | ".length - " | ".length - eTypeHeader.length - sendHeader.length;
+    var padSide = new Array(Math.floor(restCount / 2)).join(" ");
     var contentHeader = padSide + "Content" + padSide;
-    print(eTypeHeader+sendHeader+contentHeader);
+    print(eTypeHeader + sendHeader + contentHeader);
     print(new Array(100).join("-"));
-    eventMap.keys().forEach(function(eventType) {
-        if (eventType === "m.room.member") { return; } // use /members instead.
+    eventMap.keys().forEach(function (eventType) {
+        if (eventType === "m.room.member") {
+            return;
+        } // use /members instead.
         var eventEventMap = eventMap.get(eventType);
-        eventEventMap.keys().forEach(function(stateKey) {
-            var typeAndKey = eventType + (
-                stateKey.length > 0 ? "("+stateKey+")" : ""
-            );
+        eventEventMap.keys().forEach(function (stateKey) {
+            var typeAndKey = eventType + (stateKey.length > 0 ? "(" + stateKey + ")" : "");
             var typeStr = fixWidth(typeAndKey, eTypeHeader.length);
             var event = eventEventMap.get(stateKey);
             var sendStr = fixWidth(event.getSender(), sendHeader.length);
-            var contentStr = fixWidth(
-                JSON.stringify(event.getContent()), contentHeader.length
-            );
-            print(typeStr+" | "+sendStr+" | "+contentStr);
+            var contentStr = fixWidth(JSON.stringify(event.getContent()), contentHeader.length);
+            print(typeStr + " | " + sendStr + " | " + contentStr);
         });
-    })
+    });
 }
 
 function printLine(event) {
     var fmt;
     var name = event.sender ? event.sender.name : event.getSender();
-    var time = new Date(
-        event.getTs()
-    ).toISOString().replace(/T/, ' ').replace(/\..+/, '');
+    var time = new Date(event.getTs()).toISOString().replace(/T/, " ").replace(/\..+/, "");
     var separator = "<<<";
     if (event.getSender() === myUserId) {
         name = "Me";
@@ -331,8 +331,7 @@ function printLine(event) {
         if (event.status === sdk.EventStatus.SENDING) {
             separator = "...";
             fmt = clc.xterm(8);
-        }
-        else if (event.status === sdk.EventStatus.NOT_SENT) {
+        } else if (event.status === sdk.EventStatus.NOT_SENT) {
             separator = " x ";
             fmt = clc.redBright;
         }
@@ -341,69 +340,58 @@ function printLine(event) {
 
     var maxNameWidth = 15;
     if (name.length > maxNameWidth) {
-        name = name.slice(0, maxNameWidth-1) + "\u2026";
+        name = name.slice(0, maxNameWidth - 1) + "\u2026";
     }
 
     if (event.getType() === "m.room.message") {
         body = event.getContent().body;
-    }
-    else if (event.isState()) {
+    } else if (event.isState()) {
         var stateName = event.getType();
         if (event.getStateKey().length > 0) {
-            stateName += " ("+event.getStateKey()+")";
+            stateName += " (" + event.getStateKey() + ")";
         }
-        body = (
-            "[State: "+stateName+" updated to: "+JSON.stringify(event.getContent())+"]"
-        );
+        body = "[State: " + stateName + " updated to: " + JSON.stringify(event.getContent()) + "]";
         separator = "---";
         fmt = clc.xterm(249).italic;
-    }
-    else {
+    } else {
         // random message event
-        body = (
-            "[Message: "+event.getType()+" Content: "+JSON.stringify(event.getContent())+"]"
-        );
+        body = "[Message: " + event.getType() + " Content: " + JSON.stringify(event.getContent()) + "]";
         separator = "---";
         fmt = clc.xterm(249).italic;
     }
     if (fmt) {
-        print(
-            "[%s] %s %s %s", time, name, separator, body, fmt
-        );
-    }
-    else {
+        print("[%s] %s %s %s", time, name, separator, body, fmt);
+    } else {
         print("[%s] %s %s %s", time, name, separator, body);
     }
 }
 
 function print(str, formatter) {
-    if (typeof arguments[arguments.length-1] === "function") {
+    if (typeof arguments[arguments.length - 1] === "function") {
         // last arg is the formatter so get rid of it and use it on each
         // param passed in but not the template string.
         var newArgs = [];
         var i = 0;
-        for (i=0; i<arguments.length-1; i++) {
+        for (i = 0; i < arguments.length - 1; i++) {
             newArgs.push(arguments[i]);
         }
-        var fmt = arguments[arguments.length-1];
-        for (i=0; i<newArgs.length; i++) {
+        var fmt = arguments[arguments.length - 1];
+        for (i = 0; i < newArgs.length; i++) {
             newArgs[i] = fmt(newArgs[i]);
         }
         console.log.apply(console.log, newArgs);
-    }
-    else {
+    } else {
         console.log.apply(console.log, arguments);
     }
 }
 
 function fixWidth(str, len) {
     if (str.length > len) {
-        return str.substring(0, len-2) + "\u2026";
-    }
-    else if (str.length < len) {
+        return str.substring(0, len - 2) + "\u2026";
+    } else if (str.length < len) {
         return str + new Array(len - str.length).join(" ");
     }
     return str;
 }
 
-matrixClient.startClient(numMessagesToShow);  // messages for each room.
+matrixClient.startClient(numMessagesToShow); // messages for each room.
diff --git a/examples/node/package.json b/examples/node/package.json
index 6319e367db4..dc81b0e0071 100644
--- a/examples/node/package.json
+++ b/examples/node/package.json
@@ -1,14 +1,14 @@
 {
-  "name": "example-app",
-  "version": "0.0.0",
-  "description": "",
-  "main": "app.js",
-  "scripts": {
-    "preinstall": "npm install ../.."
-  },
-  "author": "",
-  "license": "Apache 2.0",
-  "dependencies": {
-    "cli-color": "^1.0.0"
-  }
+    "name": "example-app",
+    "version": "0.0.0",
+    "description": "",
+    "main": "app.js",
+    "scripts": {
+        "preinstall": "npm install ../.."
+    },
+    "author": "",
+    "license": "Apache 2.0",
+    "dependencies": {
+        "cli-color": "^1.0.0"
+    }
 }
diff --git a/examples/voip/README.md b/examples/voip/README.md
index c3f3d67ddaf..f4a9d6cc1c7 100644
--- a/examples/voip/README.md
+++ b/examples/voip/README.md
@@ -6,4 +6,4 @@ To try it out, **you must build the SDK first** and then host this folder:
  $ python -m SimpleHTTPServer 8003
 ```
 
-Then visit ``http://localhost:8003``.
+Then visit `http://localhost:8003`.
diff --git a/examples/voip/browserTest.js b/examples/voip/browserTest.js
index 4a78db3ef2b..397cb67dba0 100644
--- a/examples/voip/browserTest.js
+++ b/examples/voip/browserTest.js
@@ -9,7 +9,7 @@ const client = matrixcs.createClient({
     baseUrl: BASE_URL,
     accessToken: TOKEN,
     userId: USER_ID,
-    deviceId: DEVICE_ID
+    deviceId: DEVICE_ID,
 });
 let call;
 
@@ -21,18 +21,16 @@ function disableButtons(place, answer, hangup) {
 
 function addListeners(call) {
     let lastError = "";
-    call.on("hangup", function() {
+    call.on("hangup", function () {
         disableButtons(false, true, true);
-        document.getElementById("result").innerHTML = (
-            "<p>Call ended. Last error: "+lastError+"</p>"
-        );
+        document.getElementById("result").innerHTML = "<p>Call ended. Last error: " + lastError + "</p>";
     });
-    call.on("error", function(err) {
+    call.on("error", function (err) {
         lastError = err.message;
         call.hangup();
         disableButtons(false, true, true);
     });
-    call.on("feeds_changed", function(feeds) {
+    call.on("feeds_changed", function (feeds) {
         const localFeed = feeds.find((feed) => feed.isLocal());
         const remoteFeed = feeds.find((feed) => !feed.isLocal());
 
@@ -51,33 +49,38 @@ function addListeners(call) {
     });
 }
 
-window.onload = function() {
+window.onload = function () {
     document.getElementById("result").innerHTML = "<p>Please wait. Syncing...</p>";
-    document.getElementById("config").innerHTML = "<p>" +
-        "Homeserver: <code>"+BASE_URL+"</code><br/>"+
-        "Room: <code>"+ROOM_ID+"</code><br/>"+
-        "User: <code>"+USER_ID+"</code><br/>"+
+    document.getElementById("config").innerHTML =
+        "<p>" +
+        "Homeserver: <code>" +
+        BASE_URL +
+        "</code><br/>" +
+        "Room: <code>" +
+        ROOM_ID +
+        "</code><br/>" +
+        "User: <code>" +
+        USER_ID +
+        "</code><br/>" +
         "</p>";
     disableButtons(true, true, true);
 };
 
-client.on("sync", function(state, prevState, data) {
+client.on("sync", function (state, prevState, data) {
     switch (state) {
         case "PREPARED":
-          syncComplete();
-        break;
-   }
+            syncComplete();
+            break;
+    }
 });
 
 function syncComplete() {
     document.getElementById("result").innerHTML = "<p>Ready for calls.</p>";
     disableButtons(false, true, true);
 
-    document.getElementById("call").onclick = function() {
+    document.getElementById("call").onclick = function () {
         console.log("Placing call...");
-        call = matrixcs.createNewMatrixCall(
-            client, ROOM_ID
-        );
+        call = matrixcs.createNewMatrixCall(client, ROOM_ID);
         console.log("Call => %s", call);
         addListeners(call);
         call.placeVideoCall();
@@ -85,14 +88,14 @@ function syncComplete() {
         disableButtons(true, true, false);
     };
 
-    document.getElementById("hangup").onclick = function() {
+    document.getElementById("hangup").onclick = function () {
         console.log("Hanging up call...");
         console.log("Call => %s", call);
         call.hangup();
         document.getElementById("result").innerHTML = "<p>Hungup call.</p>";
     };
 
-    document.getElementById("answer").onclick = function() {
+    document.getElementById("answer").onclick = function () {
         console.log("Answering call...");
         console.log("Call => %s", call);
         call.answer();
@@ -100,7 +103,7 @@ function syncComplete() {
         document.getElementById("result").innerHTML = "<p>Answered call.</p>";
     };
 
-    client.on("Call.incoming", function(c) {
+    client.on("Call.incoming", function (c) {
         console.log("Call ringing");
         disableButtons(true, false, false);
         document.getElementById("result").innerHTML = "<p>Incoming call...</p>";
diff --git a/examples/voip/index.html b/examples/voip/index.html
index ab96790a60d..5d33bd43767 100644
--- a/examples/voip/index.html
+++ b/examples/voip/index.html
@@ -1,25 +1,23 @@
 <html>
+    <head>
+        <title>VoIP Test</title>
+        <script src="lib/matrix.js"></script>
+        <script src="browserTest.js"></script>
+    </head>
 
-<head>
-    <title>VoIP Test</title>
-    <script src="lib/matrix.js"></script>
-    <script src="browserTest.js"></script>
-</head>
-
-<body>
-    You can place and receive calls with this example. Make sure to edit the
-    constants in <code>browserTest.js</code> first.
-    <div id="config"></div>
-    <div id="result"></div>
-    <button id="call">Place Call</button>
-    <button id="answer">Answer Call</button>
-    <button id="hangup">Hangup Call</button>
-    <div id="videoBackground" class="video-background">
-        <video class="video-element" id="local"></video>
-        <video class="video-element" id="remote"></video>
-    </div>
-</body>
-
+    <body>
+        You can place and receive calls with this example. Make sure to edit the constants in
+        <code>browserTest.js</code> first.
+        <div id="config"></div>
+        <div id="result"></div>
+        <button id="call">Place Call</button>
+        <button id="answer">Answer Call</button>
+        <button id="hangup">Hangup Call</button>
+        <div id="videoBackground" class="video-background">
+            <video class="video-element" id="local"></video>
+            <video class="video-element" id="remote"></video>
+        </div>
+    </body>
 </html>
 
 <style>
@@ -31,4 +29,4 @@
     .video-element {
         height: 100%;
     }
-</style>
\ No newline at end of file
+</style>
diff --git a/package.json b/package.json
index 331033b47de..3b58bb25633 100644
--- a/package.json
+++ b/package.json
@@ -1,146 +1,146 @@
 {
-  "name": "matrix-js-sdk",
-  "version": "22.0.0",
-  "description": "Matrix Client-Server SDK for Javascript",
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "scripts": {
-    "prepublishOnly": "yarn build",
-    "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
-    "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
-    "clean": "rimraf lib dist",
-    "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
-    "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
-    "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
-    "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
-    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
-    "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
-    "gendoc": "typedoc",
-    "lint": "yarn lint:types && yarn lint:js",
-    "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
-    "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
-    "lint:types": "tsc --noEmit",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "coverage": "yarn test --coverage"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/matrix-org/matrix-js-sdk"
-  },
-  "keywords": [
-    "matrix-org"
-  ],
-  "main": "./src/index.ts",
-  "browser": "./lib/browser-index.ts",
-  "matrix_src_main": "./src/index.ts",
-  "matrix_src_browser": "./src/browser-index.ts",
-  "matrix_lib_main": "./lib/index.js",
-  "matrix_lib_typings": "./lib/index.d.ts",
-  "author": "matrix.org",
-  "license": "Apache-2.0",
-  "files": [
-    "dist",
-    "lib",
-    "src",
-    "git-revision.txt",
-    "CHANGELOG.md",
-    "CONTRIBUTING.rst",
-    "LICENSE",
-    "README.md",
-    "package.json",
-    "release.sh"
-  ],
-  "dependencies": {
-    "@babel/runtime": "^7.12.5",
-    "another-json": "^0.2.0",
-    "bs58": "^5.0.0",
-    "content-type": "^1.0.4",
-    "loglevel": "^1.7.1",
-    "matrix-events-sdk": "0.0.1",
-    "matrix-widget-api": "^1.0.0",
-    "p-retry": "4",
-    "qs": "^6.9.6",
-    "sdp-transform": "^2.14.1",
-    "unhomoglyph": "^1.0.6",
-    "uuid": "7"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.12.10",
-    "@babel/core": "^7.12.10",
-    "@babel/eslint-parser": "^7.12.10",
-    "@babel/eslint-plugin": "^7.12.10",
-    "@babel/plugin-proposal-class-properties": "^7.12.1",
-    "@babel/plugin-proposal-numeric-separator": "^7.12.7",
-    "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
-    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-transform-runtime": "^7.12.10",
-    "@babel/preset-env": "^7.12.11",
-    "@babel/preset-typescript": "^7.12.7",
-    "@babel/register": "^7.12.10",
-    "@casualbot/jest-sonar-reporter": "^2.2.5",
-    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
-    "@types/bs58": "^4.0.1",
-    "@types/content-type": "^1.1.5",
-    "@types/domexception": "^4.0.0",
-    "@types/jest": "^29.0.0",
-    "@types/node": "18",
-    "@types/sdp-transform": "^2.4.5",
-    "@types/uuid": "7",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
-    "allchange": "^1.0.6",
-    "babel-jest": "^29.0.0",
-    "babelify": "^10.0.0",
-    "better-docs": "^2.4.0-beta.9",
-    "browserify": "^17.0.0",
-    "docdash": "^2.0.0",
-    "domexception": "^4.0.0",
-    "eslint": "8.28.0",
-    "eslint-config-google": "^0.14.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-import-resolver-typescript": "^3.5.1",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jsdoc": "^39.6.4",
-    "eslint-plugin-matrix-org": "https://github.com/matrix-org/eslint-plugin-matrix-org.git#weeman1337/prettier",
-    "eslint-plugin-tsdoc": "^0.2.17",
-    "eslint-plugin-unicorn": "^45.0.0",
-    "exorcist": "^2.0.0",
-    "fake-indexeddb": "^4.0.0",
-    "jest": "^29.0.0",
-    "jest-environment-jsdom": "^29.0.0",
-    "jest-localstorage-mock": "^2.4.6",
-    "jest-mock": "^29.0.0",
-    "matrix-mock-request": "^2.5.0",
-    "prettier": "2.8.0",
-    "rimraf": "^3.0.2",
-    "terser": "^5.5.1",
-    "tsify": "^5.0.2",
-    "typedoc": "^0.23.20",
-    "typedoc-plugin-missing-exports": "^1.0.0",
-    "typescript": "^4.5.3"
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "testMatch": [
-      "<rootDir>/spec/**/*.spec.{js,ts}"
+    "name": "matrix-js-sdk",
+    "version": "22.0.0",
+    "description": "Matrix Client-Server SDK for Javascript",
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "scripts": {
+        "prepublishOnly": "yarn build",
+        "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
+        "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
+        "clean": "rimraf lib dist",
+        "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
+        "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
+        "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
+        "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
+        "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
+        "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
+        "gendoc": "typedoc",
+        "lint": "yarn lint:types && yarn lint:js",
+        "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
+        "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
+        "lint:types": "tsc --noEmit",
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "coverage": "yarn test --coverage"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/matrix-org/matrix-js-sdk"
+    },
+    "keywords": [
+        "matrix-org"
     ],
-    "setupFilesAfterEnv": [
-      "<rootDir>/spec/setupTests.ts"
+    "main": "./src/index.ts",
+    "browser": "./lib/browser-index.ts",
+    "matrix_src_main": "./src/index.ts",
+    "matrix_src_browser": "./src/browser-index.ts",
+    "matrix_lib_main": "./lib/index.js",
+    "matrix_lib_typings": "./lib/index.d.ts",
+    "author": "matrix.org",
+    "license": "Apache-2.0",
+    "files": [
+        "dist",
+        "lib",
+        "src",
+        "git-revision.txt",
+        "CHANGELOG.md",
+        "CONTRIBUTING.rst",
+        "LICENSE",
+        "README.md",
+        "package.json",
+        "release.sh"
     ],
-    "collectCoverageFrom": [
-      "<rootDir>/src/**/*.{js,ts}"
-    ],
-    "coverageReporters": [
-      "text-summary",
-      "lcov"
-    ],
-    "testResultsProcessor": "@casualbot/jest-sonar-reporter"
-  },
-  "@casualbot/jest-sonar-reporter": {
-    "outputDirectory": "coverage",
-    "outputName": "jest-sonar-report.xml",
-    "relativePaths": true
-  }
+    "dependencies": {
+        "@babel/runtime": "^7.12.5",
+        "another-json": "^0.2.0",
+        "bs58": "^5.0.0",
+        "content-type": "^1.0.4",
+        "loglevel": "^1.7.1",
+        "matrix-events-sdk": "0.0.1",
+        "matrix-widget-api": "^1.0.0",
+        "p-retry": "4",
+        "qs": "^6.9.6",
+        "sdp-transform": "^2.14.1",
+        "unhomoglyph": "^1.0.6",
+        "uuid": "7"
+    },
+    "devDependencies": {
+        "@babel/cli": "^7.12.10",
+        "@babel/core": "^7.12.10",
+        "@babel/eslint-parser": "^7.12.10",
+        "@babel/eslint-plugin": "^7.12.10",
+        "@babel/plugin-proposal-class-properties": "^7.12.1",
+        "@babel/plugin-proposal-numeric-separator": "^7.12.7",
+        "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
+        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+        "@babel/plugin-transform-runtime": "^7.12.10",
+        "@babel/preset-env": "^7.12.11",
+        "@babel/preset-typescript": "^7.12.7",
+        "@babel/register": "^7.12.10",
+        "@casualbot/jest-sonar-reporter": "^2.2.5",
+        "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
+        "@types/bs58": "^4.0.1",
+        "@types/content-type": "^1.1.5",
+        "@types/domexception": "^4.0.0",
+        "@types/jest": "^29.0.0",
+        "@types/node": "18",
+        "@types/sdp-transform": "^2.4.5",
+        "@types/uuid": "7",
+        "@typescript-eslint/eslint-plugin": "^5.45.0",
+        "@typescript-eslint/parser": "^5.45.0",
+        "allchange": "^1.0.6",
+        "babel-jest": "^29.0.0",
+        "babelify": "^10.0.0",
+        "better-docs": "^2.4.0-beta.9",
+        "browserify": "^17.0.0",
+        "docdash": "^2.0.0",
+        "domexception": "^4.0.0",
+        "eslint": "8.28.0",
+        "eslint-config-google": "^0.14.0",
+        "eslint-config-prettier": "^8.5.0",
+        "eslint-import-resolver-typescript": "^3.5.1",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-jsdoc": "^39.6.4",
+        "eslint-plugin-matrix-org": "https://github.com/matrix-org/eslint-plugin-matrix-org.git#weeman1337/prettier",
+        "eslint-plugin-tsdoc": "^0.2.17",
+        "eslint-plugin-unicorn": "^45.0.0",
+        "exorcist": "^2.0.0",
+        "fake-indexeddb": "^4.0.0",
+        "jest": "^29.0.0",
+        "jest-environment-jsdom": "^29.0.0",
+        "jest-localstorage-mock": "^2.4.6",
+        "jest-mock": "^29.0.0",
+        "matrix-mock-request": "^2.5.0",
+        "prettier": "2.8.0",
+        "rimraf": "^3.0.2",
+        "terser": "^5.5.1",
+        "tsify": "^5.0.2",
+        "typedoc": "^0.23.20",
+        "typedoc-plugin-missing-exports": "^1.0.0",
+        "typescript": "^4.5.3"
+    },
+    "jest": {
+        "testEnvironment": "node",
+        "testMatch": [
+            "<rootDir>/spec/**/*.spec.{js,ts}"
+        ],
+        "setupFilesAfterEnv": [
+            "<rootDir>/spec/setupTests.ts"
+        ],
+        "collectCoverageFrom": [
+            "<rootDir>/src/**/*.{js,ts}"
+        ],
+        "coverageReporters": [
+            "text-summary",
+            "lcov"
+        ],
+        "testResultsProcessor": "@casualbot/jest-sonar-reporter"
+    },
+    "@casualbot/jest-sonar-reporter": {
+        "outputDirectory": "coverage",
+        "outputName": "jest-sonar-report.xml",
+        "relativePaths": true
+    }
 }
diff --git a/scripts/switch_package_to_release.js b/scripts/switch_package_to_release.js
index 830c92dc46e..2ef9bb09cb2 100755
--- a/scripts/switch_package_to_release.js
+++ b/scripts/switch_package_to_release.js
@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
-const fsProm = require('fs/promises');
+const fsProm = require("fs/promises");
 
-const PKGJSON = 'package.json';
+const PKGJSON = "package.json";
 
 async function main() {
-    const pkgJson = JSON.parse(await fsProm.readFile(PKGJSON, 'utf8'));
-    for (const field of ['main', 'typings']) {
-        if (pkgJson["matrix_lib_"+field] !== undefined) {
-            pkgJson[field] = pkgJson["matrix_lib_"+field];
+    const pkgJson = JSON.parse(await fsProm.readFile(PKGJSON, "utf8"));
+    for (const field of ["main", "typings"]) {
+        if (pkgJson["matrix_lib_" + field] !== undefined) {
+            pkgJson[field] = pkgJson["matrix_lib_" + field];
         }
     }
     await fsProm.writeFile(PKGJSON, JSON.stringify(pkgJson, null, 2));
diff --git a/spec/TestClient.ts b/spec/TestClient.ts
index 8b54fd92ab9..19a8d42c5e5 100644
--- a/spec/TestClient.ts
+++ b/spec/TestClient.ts
@@ -17,12 +17,12 @@ limitations under the License.
 */
 
 // load olm before the sdk if possible
-import './olm-loader';
+import "./olm-loader";
 
-import MockHttpBackend from 'matrix-mock-request';
+import MockHttpBackend from "matrix-mock-request";
 
-import { LocalStorageCryptoStore } from '../src/crypto/store/localStorage-crypto-store';
-import { logger } from '../src/logger';
+import { LocalStorageCryptoStore } from "../src/crypto/store/localStorage-crypto-store";
+import { logger } from "../src/logger";
 import { syncPromise } from "./test-utils/test-utils";
 import { createClient } from "../src/matrix";
 import { ICreateClientOpts, IDownloadKeyResult, MatrixClient, PendingEventOrdering } from "../src/client";
@@ -30,7 +30,7 @@ import { MockStorageApi } from "./MockStorageApi";
 import { encodeUri } from "../src/utils";
 import { IDeviceKeys, IOneTimeKey } from "../src/crypto/dehydration";
 import { IKeyBackupSession } from "../src/crypto/keybackup";
-import { IKeysUploadResponse, IUploadKeysRequest } from '../src/client';
+import { IKeysUploadResponse, IUploadKeysRequest } from "../src/client";
 
 /**
  * Wrapper for a MockStorageApi, MockHttpBackend and MatrixClient
@@ -73,14 +73,14 @@ export class TestClient {
     }
 
     public toString(): string {
-        return 'TestClient[' + this.userId + ']';
+        return "TestClient[" + this.userId + "]";
     }
 
     /**
      * start the client, and wait for it to initialise.
      */
     public start(): Promise<void> {
-        logger.log(this + ': starting');
+        logger.log(this + ": starting");
         this.httpBackend.when("GET", "/versions").respond(200, {});
         this.httpBackend.when("GET", "/pushrules").respond(200, {});
         this.httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
@@ -95,11 +95,8 @@ export class TestClient {
             pendingEventOrdering: PendingEventOrdering.Detached,
         });
 
-        return Promise.all([
-            this.httpBackend.flushAllExpected(),
-            syncPromise(this.client),
-        ]).then(() => {
-            logger.log(this + ': started');
+        return Promise.all([this.httpBackend.flushAllExpected(), syncPromise(this.client)]).then(() => {
+            logger.log(this + ": started");
         });
     }
 
@@ -116,12 +113,13 @@ export class TestClient {
      * Set up expectations that the client will upload device keys.
      */
     public expectDeviceKeyUpload() {
-        this.httpBackend.when("POST", "/keys/upload")
+        this.httpBackend
+            .when("POST", "/keys/upload")
             .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content) => {
                 expect(content.one_time_keys).toBe(undefined);
                 expect(content.device_keys).toBeTruthy();
 
-                logger.log(this + ': received device keys');
+                logger.log(this + ": received device keys");
                 // we expect this to happen before any one-time keys are uploaded.
                 expect(Object.keys(this.oneTimeKeys!).length).toEqual(0);
 
@@ -143,30 +141,35 @@ export class TestClient {
             return Promise.resolve(this.oneTimeKeys!);
         }
 
-        this.httpBackend.when("POST", "/keys/upload")
+        this.httpBackend
+            .when("POST", "/keys/upload")
             .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content: IUploadKeysRequest) => {
                 expect(content.device_keys).toBe(undefined);
                 expect(content.one_time_keys).toBe(undefined);
-                return { one_time_key_counts: {
-                    signed_curve25519: Object.keys(this.oneTimeKeys!).length,
-                } };
+                return {
+                    one_time_key_counts: {
+                        signed_curve25519: Object.keys(this.oneTimeKeys!).length,
+                    },
+                };
             });
 
-        this.httpBackend.when("POST", "/keys/upload")
+        this.httpBackend
+            .when("POST", "/keys/upload")
             .respond<IKeysUploadResponse, IUploadKeysRequest>(200, (_path, content: IUploadKeysRequest) => {
                 expect(content.device_keys).toBe(undefined);
                 expect(content.one_time_keys).toBeTruthy();
                 expect(content.one_time_keys).not.toEqual({});
-                logger.log('%s: received %i one-time keys', this,
-                    Object.keys(content.one_time_keys!).length);
+                logger.log("%s: received %i one-time keys", this, Object.keys(content.one_time_keys!).length);
                 this.oneTimeKeys = content.one_time_keys;
-                return { one_time_key_counts: {
-                    signed_curve25519: Object.keys(this.oneTimeKeys!).length,
-                } };
+                return {
+                    one_time_key_counts: {
+                        signed_curve25519: Object.keys(this.oneTimeKeys!).length,
+                    },
+                };
             });
 
         // this can take ages
-        return this.httpBackend.flush('/keys/upload', 2, 1000).then((flushed) => {
+        return this.httpBackend.flush("/keys/upload", 2, 1000).then((flushed) => {
             expect(flushed).toEqual(2);
             return this.oneTimeKeys!;
         });
@@ -180,23 +183,27 @@ export class TestClient {
      * @param response -   response to the query.
      */
     public expectKeyQuery(response: IDownloadKeyResult) {
-        this.httpBackend.when('POST', '/keys/query').respond<IDownloadKeyResult>(
-            200, (_path, content) => {
-                Object.keys(response.device_keys).forEach((userId) => {
-                    expect((content.device_keys! as Record<string, any>)[userId]).toEqual([]);
-                });
-                return response;
+        this.httpBackend.when("POST", "/keys/query").respond<IDownloadKeyResult>(200, (_path, content) => {
+            Object.keys(response.device_keys).forEach((userId) => {
+                expect((content.device_keys! as Record<string, any>)[userId]).toEqual([]);
             });
+            return response;
+        });
     }
 
     /**
      * Set up expectations that the client will query key backups for a particular session
      */
     public expectKeyBackupQuery(roomId: string, sessionId: string, status: number, response: IKeyBackupSession) {
-        this.httpBackend.when('GET', encodeUri("/room_keys/keys/$roomId/$sessionId", {
-            $roomId: roomId,
-            $sessionId: sessionId,
-        })).respond(status, response);
+        this.httpBackend
+            .when(
+                "GET",
+                encodeUri("/room_keys/keys/$roomId/$sessionId", {
+                    $roomId: roomId,
+                    $sessionId: sessionId,
+                }),
+            )
+            .respond(status, response);
     }
 
     /**
@@ -205,7 +212,7 @@ export class TestClient {
      * @returns base64 device key
      */
     public getDeviceKey(): string {
-        const keyId = 'curve25519:' + this.deviceId;
+        const keyId = "curve25519:" + this.deviceId;
         return this.deviceKeys!.keys[keyId];
     }
 
@@ -215,7 +222,7 @@ export class TestClient {
      * @returns base64 device key
      */
     public getSigningKey(): string {
-        const keyId = 'ed25519:' + this.deviceId;
+        const keyId = "ed25519:" + this.deviceId;
         return this.deviceKeys!.keys[keyId];
     }
 
@@ -224,10 +231,7 @@ export class TestClient {
      */
     public flushSync(): Promise<void> {
         logger.log(`${this}: flushSync`);
-        return Promise.all([
-            this.httpBackend.flush('/sync', 1),
-            syncPromise(this.client),
-        ]).then(() => {
+        return Promise.all([this.httpBackend.flush("/sync", 1), syncPromise(this.client)]).then(() => {
             logger.log(`${this}: flushSync completed`);
         });
     }
diff --git a/spec/browserify/sync-browserify.spec.ts b/spec/browserify/sync-browserify.spec.ts
index 6898c3e1cdc..82cade65df0 100644
--- a/spec/browserify/sync-browserify.spec.ts
+++ b/spec/browserify/sync-browserify.spec.ts
@@ -24,7 +24,7 @@ const DEVICE_ID = "device_id";
 const ACCESS_TOKEN = "access_token";
 const ROOM_ID = "!room_id:server.test";
 
-describe("Browserify Test", function() {
+describe("Browserify Test", function () {
     let client: MatrixClient;
     let httpBackend: HttpBackend;
 
@@ -68,9 +68,7 @@ describe("Browserify Test", function() {
                 join: {
                     [ROOM_ID]: {
                         timeline: {
-                            events: [
-                                event,
-                            ],
+                            events: [event],
                             limited: false,
                         },
                     },
@@ -81,7 +79,7 @@ describe("Browserify Test", function() {
         httpBackend.when("GET", "/sync").respond(200, syncData);
         httpBackend.when("GET", "/sync").respond(200, syncData);
 
-        const syncPromise = new Promise(r => client.once(global.matrixcs.ClientEvent.Sync, r));
+        const syncPromise = new Promise((r) => client.once(global.matrixcs.ClientEvent.Sync, r));
         const unexpectedErrorFn = jest.fn();
         client.once(global.matrixcs.ClientEvent.SyncUnexpectedError, unexpectedErrorFn);
 
diff --git a/spec/integ/devicelist-integ.spec.ts b/spec/integ/devicelist-integ.spec.ts
index 35af27e51dc..e9dac66efe6 100644
--- a/spec/integ/devicelist-integ.spec.ts
+++ b/spec/integ/devicelist-integ.spec.ts
@@ -16,9 +16,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { TestClient } from '../TestClient';
-import * as testUtils from '../test-utils/test-utils';
-import { logger } from '../../src/logger';
+import { TestClient } from "../TestClient";
+import * as testUtils from "../test-utils/test-utils";
+import { logger } from "../../src/logger";
 
 const ROOM_ID = "!room:id";
 
@@ -31,20 +31,22 @@ const ROOM_ID = "!room:id";
 function getSyncResponse(roomMembers: string[]) {
     const stateEvents = [
         testUtils.mkEvent({
-            type: 'm.room.encryption',
-            skey: '',
+            type: "m.room.encryption",
+            skey: "",
             content: {
-                algorithm: 'm.megolm.v1.aes-sha2',
+                algorithm: "m.megolm.v1.aes-sha2",
             },
         }),
     ];
 
     Array.prototype.push.apply(
         stateEvents,
-        roomMembers.map((m) => testUtils.mkMembership({
-            mship: 'join',
-            sender: m,
-        })),
+        roomMembers.map((m) =>
+            testUtils.mkMembership({
+                mship: "join",
+                sender: m,
+            }),
+        ),
     );
 
     const syncResponse = {
@@ -63,9 +65,9 @@ function getSyncResponse(roomMembers: string[]) {
     return syncResponse;
 }
 
-describe("DeviceList management:", function() {
+describe("DeviceList management:", function () {
     if (!global.Olm) {
-        logger.warn('not running deviceList tests: Olm not present');
+        logger.warn("not running deviceList tests: Olm not present");
         return;
     }
 
@@ -73,14 +75,12 @@ describe("DeviceList management:", function() {
     let sessionStoreBackend: Storage;
 
     async function createTestClient() {
-        const testClient = new TestClient(
-            "@alice:localhost", "xzcvb", "akjgkrgjs", sessionStoreBackend,
-        );
+        const testClient = new TestClient("@alice:localhost", "xzcvb", "akjgkrgjs", sessionStoreBackend);
         await testClient.client.initCrypto();
         return testClient;
     }
 
-    beforeEach(async function() {
+    beforeEach(async function () {
         // we create our own sessionStoreBackend so that we can use it for
         // another TestClient.
         sessionStoreBackend = new testUtils.MockStorageApi();
@@ -88,311 +88,311 @@ describe("DeviceList management:", function() {
         aliceTestClient = await createTestClient();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         return aliceTestClient.stop();
     });
 
-    it("Alice shouldn't do a second /query for non-e2e-capable devices", function() {
+    it("Alice shouldn't do a second /query for non-e2e-capable devices", function () {
         aliceTestClient.expectKeyQuery({
-            device_keys: { '@alice:localhost': {} },
+            device_keys: { "@alice:localhost": {} },
             failures: {},
         });
-        return aliceTestClient.start().then(function() {
-            const syncResponse = getSyncResponse(['@bob:xyz']);
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+        return aliceTestClient
+            .start()
+            .then(function () {
+                const syncResponse = getSyncResponse(["@bob:xyz"]);
+                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
 
-            return aliceTestClient.flushSync();
-        }).then(function() {
-            logger.log("Forcing alice to download our device keys");
+                return aliceTestClient.flushSync();
+            })
+            .then(function () {
+                logger.log("Forcing alice to download our device keys");
 
-            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(200, {
-                device_keys: {
-                    '@bob:xyz': {},
-                },
-            });
+                aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
+                    device_keys: {
+                        "@bob:xyz": {},
+                    },
+                });
 
-            return Promise.all([
-                aliceTestClient.client.downloadKeys(['@bob:xyz']),
-                aliceTestClient.httpBackend.flush('/keys/query', 1),
-            ]);
-        }).then(function() {
-            logger.log("Telling alice to send a megolm message");
-
-            aliceTestClient.httpBackend.when(
-                'PUT', '/send/',
-            ).respond(200, {
-                event_id: '$event_id',
-            });
+                return Promise.all([
+                    aliceTestClient.client.downloadKeys(["@bob:xyz"]),
+                    aliceTestClient.httpBackend.flush("/keys/query", 1),
+                ]);
+            })
+            .then(function () {
+                logger.log("Telling alice to send a megolm message");
+
+                aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, {
+                    event_id: "$event_id",
+                });
 
-            return Promise.all([
-                aliceTestClient.client.sendTextMessage(ROOM_ID, 'test'),
+                return Promise.all([
+                    aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
 
-                // the crypto stuff can take a while, so give the requests a whole second.
-                aliceTestClient.httpBackend.flushAllExpected({
-                    timeout: 1000,
-                }),
-            ]);
-        });
+                    // the crypto stuff can take a while, so give the requests a whole second.
+                    aliceTestClient.httpBackend.flushAllExpected({
+                        timeout: 1000,
+                    }),
+                ]);
+            });
     });
 
     it.skip("We should not get confused by out-of-order device query responses", () => {
         // https://github.com/vector-im/element-web/issues/3126
         aliceTestClient.expectKeyQuery({
-            device_keys: { '@alice:localhost': {} },
+            device_keys: { "@alice:localhost": {} },
             failures: {},
         });
-        return aliceTestClient.start().then(() => {
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(
-                200, getSyncResponse(['@bob:xyz', '@chris:abc']));
-            return aliceTestClient.flushSync();
-        }).then(() => {
-            // to make sure the initial device queries are flushed out, we
-            // attempt to send a message.
-
-            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-                200, {
+        return aliceTestClient
+            .start()
+            .then(() => {
+                aliceTestClient.httpBackend
+                    .when("GET", "/sync")
+                    .respond(200, getSyncResponse(["@bob:xyz", "@chris:abc"]));
+                return aliceTestClient.flushSync();
+            })
+            .then(() => {
+                // to make sure the initial device queries are flushed out, we
+                // attempt to send a message.
+
+                aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
                     device_keys: {
-                        '@bob:xyz': {},
-                        '@chris:abc': {},
+                        "@bob:xyz": {},
+                        "@chris:abc": {},
                     },
-                },
-            );
-
-            aliceTestClient.httpBackend.when('PUT', '/send/').respond(
-                200, { event_id: '$event1' });
-
-            return Promise.all([
-                aliceTestClient.client.sendTextMessage(ROOM_ID, 'test'),
-                aliceTestClient.httpBackend.flush('/keys/query', 1).then(
-                    () => aliceTestClient.httpBackend.flush('/send/', 1),
-                ),
-                aliceTestClient.client.crypto!.deviceList.saveIfDirty(),
-            ]);
-        }).then(() => {
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                expect(data!.syncToken).toEqual(1);
-            });
-
-            // invalidate bob's and chris's device lists in separate syncs
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, {
-                next_batch: '2',
-                device_lists: {
-                    changed: ['@bob:xyz'],
-                },
-            });
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(200, {
-                next_batch: '3',
-                device_lists: {
-                    changed: ['@chris:abc'],
-                },
-            });
-            // flush both syncs
-            return aliceTestClient.flushSync().then(() => {
-                return aliceTestClient.flushSync();
-            });
-        }).then(() => {
-            // check that we don't yet have a request for chris's devices.
-            aliceTestClient.httpBackend.when('POST', '/keys/query', {
-                device_keys: {
-                    '@chris:abc': {},
-                },
-                token: '3',
-            }).respond(200, {
-                device_keys: { '@chris:abc': {} },
-            });
-            return aliceTestClient.httpBackend.flush('/keys/query', 1);
-        }).then((flushed) => {
-            expect(flushed).toEqual(0);
-            return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-        }).then(() => {
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus['@bob:xyz'];
-                if (bobStat != 1 && bobStat != 2) {
-                    throw new Error('Unexpected status for bob: wanted 1 or 2, got ' +
-                        bobStat);
-                }
-                const chrisStat = data!.trackingStatus['@chris:abc'];
-                if (chrisStat != 1 && chrisStat != 2) {
-                    throw new Error(
-                        'Unexpected status for chris: wanted 1 or 2, got ' + chrisStat,
-                    );
-                }
-            });
+                });
 
-            // now add an expectation for a query for bob's devices, and let
-            // it complete.
-            aliceTestClient.httpBackend.when('POST', '/keys/query', {
-                device_keys: {
-                    '@bob:xyz': {},
-                },
-                token: '2',
-            }).respond(200, {
-                device_keys: { '@bob:xyz': {} },
-            });
-            return aliceTestClient.httpBackend.flush('/keys/query', 1);
-        }).then((flushed) => {
-            expect(flushed).toEqual(1);
-
-            // wait for the client to stop processing the response
-            return aliceTestClient.client.downloadKeys(['@bob:xyz']);
-        }).then(() => {
-            return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-        }).then(() => {
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus['@bob:xyz'];
-                expect(bobStat).toEqual(3);
-                const chrisStat = data!.trackingStatus['@chris:abc'];
-                if (chrisStat != 1 && chrisStat != 2) {
-                    throw new Error(
-                        'Unexpected status for chris: wanted 1 or 2, got ' + bobStat,
-                    );
-                }
-            });
+                aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, { event_id: "$event1" });
+
+                return Promise.all([
+                    aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
+                    aliceTestClient.httpBackend
+                        .flush("/keys/query", 1)
+                        .then(() => aliceTestClient.httpBackend.flush("/send/", 1)),
+                    aliceTestClient.client.crypto!.deviceList.saveIfDirty(),
+                ]);
+            })
+            .then(() => {
+                // @ts-ignore accessing a protected field
+                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                    expect(data!.syncToken).toEqual(1);
+                });
 
-            // now let the query for chris's devices complete.
-            return aliceTestClient.httpBackend.flush('/keys/query', 1);
-        }).then((flushed) => {
-            expect(flushed).toEqual(1);
+                // invalidate bob's and chris's device lists in separate syncs
+                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+                    next_batch: "2",
+                    device_lists: {
+                        changed: ["@bob:xyz"],
+                    },
+                });
+                aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+                    next_batch: "3",
+                    device_lists: {
+                        changed: ["@chris:abc"],
+                    },
+                });
+                // flush both syncs
+                return aliceTestClient.flushSync().then(() => {
+                    return aliceTestClient.flushSync();
+                });
+            })
+            .then(() => {
+                // check that we don't yet have a request for chris's devices.
+                aliceTestClient.httpBackend
+                    .when("POST", "/keys/query", {
+                        device_keys: {
+                            "@chris:abc": {},
+                        },
+                        token: "3",
+                    })
+                    .respond(200, {
+                        device_keys: { "@chris:abc": {} },
+                    });
+                return aliceTestClient.httpBackend.flush("/keys/query", 1);
+            })
+            .then((flushed) => {
+                expect(flushed).toEqual(0);
+                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
+            })
+            .then(() => {
+                // @ts-ignore accessing a protected field
+                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                    const bobStat = data!.trackingStatus["@bob:xyz"];
+                    if (bobStat != 1 && bobStat != 2) {
+                        throw new Error("Unexpected status for bob: wanted 1 or 2, got " + bobStat);
+                    }
+                    const chrisStat = data!.trackingStatus["@chris:abc"];
+                    if (chrisStat != 1 && chrisStat != 2) {
+                        throw new Error("Unexpected status for chris: wanted 1 or 2, got " + chrisStat);
+                    }
+                });
 
-            // wait for the client to stop processing the response
-            return aliceTestClient.client.downloadKeys(['@chris:abc']);
-        }).then(() => {
-            return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
-        }).then(() => {
-            // @ts-ignore accessing a protected field
-            aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus['@bob:xyz'];
-                const chrisStat = data!.trackingStatus['@bob:xyz'];
+                // now add an expectation for a query for bob's devices, and let
+                // it complete.
+                aliceTestClient.httpBackend
+                    .when("POST", "/keys/query", {
+                        device_keys: {
+                            "@bob:xyz": {},
+                        },
+                        token: "2",
+                    })
+                    .respond(200, {
+                        device_keys: { "@bob:xyz": {} },
+                    });
+                return aliceTestClient.httpBackend.flush("/keys/query", 1);
+            })
+            .then((flushed) => {
+                expect(flushed).toEqual(1);
+
+                // wait for the client to stop processing the response
+                return aliceTestClient.client.downloadKeys(["@bob:xyz"]);
+            })
+            .then(() => {
+                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
+            })
+            .then(() => {
+                // @ts-ignore accessing a protected field
+                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                    const bobStat = data!.trackingStatus["@bob:xyz"];
+                    expect(bobStat).toEqual(3);
+                    const chrisStat = data!.trackingStatus["@chris:abc"];
+                    if (chrisStat != 1 && chrisStat != 2) {
+                        throw new Error("Unexpected status for chris: wanted 1 or 2, got " + bobStat);
+                    }
+                });
 
-                expect(bobStat).toEqual(3);
-                expect(chrisStat).toEqual(3);
-                expect(data!.syncToken).toEqual(3);
+                // now let the query for chris's devices complete.
+                return aliceTestClient.httpBackend.flush("/keys/query", 1);
+            })
+            .then((flushed) => {
+                expect(flushed).toEqual(1);
+
+                // wait for the client to stop processing the response
+                return aliceTestClient.client.downloadKeys(["@chris:abc"]);
+            })
+            .then(() => {
+                return aliceTestClient.client.crypto!.deviceList.saveIfDirty();
+            })
+            .then(() => {
+                // @ts-ignore accessing a protected field
+                aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
+                    const bobStat = data!.trackingStatus["@bob:xyz"];
+                    const chrisStat = data!.trackingStatus["@bob:xyz"];
+
+                    expect(bobStat).toEqual(3);
+                    expect(chrisStat).toEqual(3);
+                    expect(data!.syncToken).toEqual(3);
+                });
             });
-        });
     });
 
     // https://github.com/vector-im/element-web/issues/4983
     describe("Alice should know she has stale device lists", () => {
-        beforeEach(async function() {
+        beforeEach(async function () {
             await aliceTestClient.start();
 
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(
-                200, getSyncResponse(['@bob:xyz']));
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
             await aliceTestClient.flushSync();
 
-            aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-                200, {
-                    device_keys: {
-                        '@bob:xyz': {},
-                    },
+            aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, {
+                device_keys: {
+                    "@bob:xyz": {},
                 },
-            );
-            await aliceTestClient.httpBackend.flush('/keys/query', 1);
+            });
+            await aliceTestClient.httpBackend.flush("/keys/query", 1);
             await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
 
             // @ts-ignore accessing a protected field
             aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus['@bob:xyz'];
+                const bobStat = data!.trackingStatus["@bob:xyz"];
 
                 // Alice should be tracking bob's device list
-                expect(bobStat).toBeGreaterThan(
-                    0,
-                );
+                expect(bobStat).toBeGreaterThan(0);
             });
         });
 
-        it("when Bob leaves", async function() {
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(
-                200, {
-                    next_batch: 2,
-                    device_lists: {
-                        left: ['@bob:xyz'],
-                    },
-                    rooms: {
-                        join: {
-                            [ROOM_ID]: {
-                                timeline: {
-                                    events: [
-                                        testUtils.mkMembership({
-                                            mship: 'leave',
-                                            sender: '@bob:xyz',
-                                        }),
-                                    ],
-                                },
+        it("when Bob leaves", async function () {
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+                next_batch: 2,
+                device_lists: {
+                    left: ["@bob:xyz"],
+                },
+                rooms: {
+                    join: {
+                        [ROOM_ID]: {
+                            timeline: {
+                                events: [
+                                    testUtils.mkMembership({
+                                        mship: "leave",
+                                        sender: "@bob:xyz",
+                                    }),
+                                ],
                             },
                         },
                     },
                 },
-            );
+            });
 
             await aliceTestClient.flushSync();
             await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
 
             // @ts-ignore accessing a protected field
             aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus['@bob:xyz'];
+                const bobStat = data!.trackingStatus["@bob:xyz"];
 
                 // Alice should have marked bob's device list as untracked
-                expect(bobStat).toEqual(
-                    0,
-                );
+                expect(bobStat).toEqual(0);
             });
         });
 
-        it("when Alice leaves", async function() {
-            aliceTestClient.httpBackend.when('GET', '/sync').respond(
-                200, {
-                    next_batch: 2,
-                    device_lists: {
-                        left: ['@bob:xyz'],
-                    },
-                    rooms: {
-                        leave: {
-                            [ROOM_ID]: {
-                                timeline: {
-                                    events: [
-                                        testUtils.mkMembership({
-                                            mship: 'leave',
-                                            sender: '@bob:xyz',
-                                        }),
-                                    ],
-                                },
+        it("when Alice leaves", async function () {
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
+                next_batch: 2,
+                device_lists: {
+                    left: ["@bob:xyz"],
+                },
+                rooms: {
+                    leave: {
+                        [ROOM_ID]: {
+                            timeline: {
+                                events: [
+                                    testUtils.mkMembership({
+                                        mship: "leave",
+                                        sender: "@bob:xyz",
+                                    }),
+                                ],
                             },
                         },
                     },
                 },
-            );
+            });
 
             await aliceTestClient.flushSync();
             await aliceTestClient.client.crypto!.deviceList.saveIfDirty();
 
             // @ts-ignore accessing a protected field
             aliceTestClient.client.cryptoStore!.getEndToEndDeviceData(null, (data) => {
-                const bobStat = data!.trackingStatus['@bob:xyz'];
+                const bobStat = data!.trackingStatus["@bob:xyz"];
 
                 // Alice should have marked bob's device list as untracked
                 expect(bobStat).toEqual(0);
             });
         });
 
-        it("when Bob leaves whilst Alice is offline", async function() {
+        it("when Bob leaves whilst Alice is offline", async function () {
             aliceTestClient.stop();
 
             const anotherTestClient = await createTestClient();
 
             try {
                 await anotherTestClient.start();
-                anotherTestClient.httpBackend.when('GET', '/sync').respond(
-                    200, getSyncResponse([]));
+                anotherTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse([]));
                 await anotherTestClient.flushSync();
                 await anotherTestClient.client?.crypto?.deviceList?.saveIfDirty();
 
                 // @ts-ignore accessing private property
                 anotherTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
-                    const bobStat = data!.trackingStatus['@bob:xyz'];
+                    const bobStat = data!.trackingStatus["@bob:xyz"];
 
                     // Alice should have marked bob's device list as untracked
                     expect(bobStat).toEqual(0);
diff --git a/spec/integ/matrix-client-crypto.spec.ts b/spec/integ/matrix-client-crypto.spec.ts
index 74366a21b6b..326b8578bc7 100644
--- a/spec/integ/matrix-client-crypto.spec.ts
+++ b/spec/integ/matrix-client-crypto.spec.ts
@@ -26,15 +26,15 @@ limitations under the License.
  */
 
 // load olm before the sdk if possible
-import '../olm-loader';
+import "../olm-loader";
 
 import type { Session } from "@matrix-org/olm";
-import { logger } from '../../src/logger';
+import { logger } from "../../src/logger";
 import * as testUtils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
 import { CRYPTO_ENABLED, IClaimKeysRequest, IQueryKeysRequest, IUploadKeysRequest } from "../../src/client";
 import { ClientEvent, IContent, ISendEventResponse, MatrixClient, MatrixEvent } from "../../src/matrix";
-import { DeviceInfo } from '../../src/crypto/deviceinfo';
+import { DeviceInfo } from "../../src/crypto/deviceinfo";
 import { IDeviceKeys, IOneTimeKey } from "../../src/crypto/dehydration";
 
 let aliTestClient: TestClient;
@@ -68,13 +68,12 @@ function expectQueryKeys(querier: TestClient, uploader: TestClient): Promise<num
 
     const uploaderKeys: Record<string, IDeviceKeys> = {};
     uploaderKeys[uploader.deviceId!] = uploader.deviceKeys!;
-    querier.httpBackend.when("POST", "/keys/query")
-        .respond(200, function(_path, content: IQueryKeysRequest) {
-            expect(content.device_keys![uploader.userId!]).toEqual([]);
-            const result: Record<string, Record<string, IDeviceKeys>> = {};
-            result[uploader.userId!] = uploaderKeys;
-            return { device_keys: result };
-        });
+    querier.httpBackend.when("POST", "/keys/query").respond(200, function (_path, content: IQueryKeysRequest) {
+        expect(content.device_keys![uploader.userId!]).toEqual([]);
+        const result: Record<string, Record<string, IDeviceKeys>> = {};
+        result[uploader.userId!] = uploaderKeys;
+        return { device_keys: result };
+    });
     return querier.httpBackend.flush("/keys/query", 1);
 }
 const expectAliQueryKeys = () => expectQueryKeys(aliTestClient, bobTestClient);
@@ -87,12 +86,10 @@ const expectBobQueryKeys = () => expectQueryKeys(bobTestClient, aliTestClient);
  */
 async function expectAliClaimKeys(): Promise<void> {
     const keys = await bobTestClient.awaitOneTimeKeyUpload();
-    aliTestClient.httpBackend.when(
-        "POST", "/keys/claim",
-    ).respond(200, function(_path, content: IClaimKeysRequest) {
+    aliTestClient.httpBackend.when("POST", "/keys/claim").respond(200, function (_path, content: IClaimKeysRequest) {
         const claimType = content.one_time_keys![bobUserId][bobDeviceId];
         expect(claimType).toEqual("signed_curve25519");
-        let keyId = '';
+        let keyId = "";
         for (keyId in keys) {
             if (bobTestClient.oneTimeKeys!.hasOwnProperty(keyId)) {
                 if (keyId.indexOf(claimType + ":") === 0) {
@@ -133,8 +130,7 @@ async function aliDownloadsKeys(): Promise<void> {
     aliTestClient.client.cryptoStore.getEndToEndDeviceData(null, (data) => {
         const devices = data!.devices[bobUserId]!;
         expect(devices[bobDeviceId].keys).toEqual(bobTestClient.deviceKeys!.keys);
-        expect(devices[bobDeviceId].verified).
-            toBe(DeviceInfo.DeviceVerification.UNVERIFIED);
+        expect(devices[bobDeviceId].verified).toBe(DeviceInfo.DeviceVerification.UNVERIFIED);
     });
 }
 
@@ -157,9 +153,7 @@ async function aliSendsFirstMessage(): Promise<OlmPayload> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const [_, ciphertext] = await Promise.all([
         sendMessage(aliTestClient.client),
-        expectAliQueryKeys()
-            .then(expectAliClaimKeys)
-            .then(expectAliSendMessageRequest),
+        expectAliQueryKeys().then(expectAliClaimKeys).then(expectAliSendMessageRequest),
     ]);
     return ciphertext;
 }
@@ -172,10 +166,7 @@ async function aliSendsFirstMessage(): Promise<OlmPayload> {
  */
 async function aliSendsMessage(): Promise<OlmPayload> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const [_, ciphertext] = await Promise.all([
-        sendMessage(aliTestClient.client),
-        expectAliSendMessageRequest(),
-    ]);
+    const [_, ciphertext] = await Promise.all([sendMessage(aliTestClient.client), expectAliSendMessageRequest()]);
     return ciphertext;
 }
 
@@ -189,8 +180,7 @@ async function bobSendsReplyMessage(): Promise<OlmPayload> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const [_, ciphertext] = await Promise.all([
         sendMessage(bobTestClient.client),
-        expectBobQueryKeys()
-            .then(expectBobSendMessageRequest),
+        expectBobQueryKeys().then(expectBobSendMessageRequest),
     ]);
     return ciphertext;
 }
@@ -226,15 +216,13 @@ async function expectBobSendMessageRequest(): Promise<OlmPayload> {
 }
 
 function sendMessage(client: MatrixClient): Promise<ISendEventResponse> {
-    return client.sendMessage(
-        roomId, { msgtype: "m.text", body: "Hello, World" },
-    );
+    return client.sendMessage(roomId, { msgtype: "m.text", body: "Hello, World" });
 }
 
 async function expectSendMessageRequest(httpBackend: TestClient["httpBackend"]): Promise<IContent> {
     const path = "/send/m.room.encrypted/";
     const prom = new Promise<IContent>((resolve) => {
-        httpBackend.when("PUT", path).respond(200, function(_path, content) {
+        httpBackend.when("PUT", path).respond(200, function (_path, content) {
             resolve(content);
             return {
                 event_id: "asdfgh",
@@ -249,16 +237,12 @@ async function expectSendMessageRequest(httpBackend: TestClient["httpBackend"]):
 
 function aliRecvMessage(): Promise<void> {
     const message = bobMessages.shift()!;
-    return recvMessage(
-        aliTestClient.httpBackend, aliTestClient.client, bobUserId, message,
-    );
+    return recvMessage(aliTestClient.httpBackend, aliTestClient.client, bobUserId, message);
 }
 
 function bobRecvMessage(): Promise<void> {
     const message = aliMessages.shift()!;
-    return recvMessage(
-        bobTestClient.httpBackend, bobTestClient.client, aliUserId, message,
-    );
+    return recvMessage(bobTestClient.httpBackend, bobTestClient.client, aliUserId, message);
 }
 
 async function recvMessage(
@@ -289,13 +273,12 @@ async function recvMessage(
     httpBackend.when("GET", "/sync").respond(200, syncData);
 
     const eventPromise = new Promise<MatrixEvent>((resolve) => {
-        const onEvent = function(event: MatrixEvent) {
+        const onEvent = function (event: MatrixEvent) {
             // ignore the m.room.member events
             if (event.getType() == "m.room.member") {
                 return;
             }
-            logger.log(client.credentials.userId + " received event",
-                event);
+            logger.log(client.credentials.userId + " received event", event);
 
             client.removeListener(ClientEvent.Event, onEvent);
             resolve(event);
@@ -382,8 +365,7 @@ describe("MatrixClient crypto", () => {
     it("handles failures to upload device keys", async () => {
         // since device keys are uploaded asynchronously, there's not really much to do here other than fail the
         // upload.
-        bobTestClient.httpBackend.when("POST", "/keys/upload")
-            .fail(0, new Error("bleh"));
+        bobTestClient.httpBackend.when("POST", "/keys/upload").fail(0, new Error("bleh"));
         await bobTestClient.httpBackend.flushAllExpected();
     });
 
@@ -398,10 +380,7 @@ describe("MatrixClient crypto", () => {
         const bobDeviceKeys = bobTestClient.deviceKeys!;
         expect(bobDeviceKeys.keys["curve25519:" + bobDeviceId]).toBeTruthy();
         bobDeviceKeys.keys["curve25519:" + bobDeviceId] += "abc";
-        await Promise.all([
-            aliTestClient.client.downloadKeys([bobUserId]),
-            expectAliQueryKeys(),
-        ]);
+        await Promise.all([aliTestClient.client.downloadKeys([bobUserId]), expectAliQueryKeys()]);
         const devices = aliTestClient.client.getStoredDevicesForUser(bobUserId);
         // should get an empty list
         expect(devices).toEqual([]);
@@ -411,26 +390,24 @@ describe("MatrixClient crypto", () => {
         const eveUserId = "@eve:localhost";
 
         const bobDeviceKeys = {
-            algorithms: ['m.olm.v1.curve25519-aes-sha2', 'm.megolm.v1.aes-sha2'],
-            device_id: 'bvcxz',
+            algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+            device_id: "bvcxz",
             keys: {
-                'ed25519:bvcxz': 'pYuWKMCVuaDLRTM/eWuB8OlXEb61gZhfLVJ+Y54tl0Q',
-                'curve25519:bvcxz': '7Gni0loo/nzF0nFp9847RbhElGewzwUXHPrljjBGPTQ',
+                "ed25519:bvcxz": "pYuWKMCVuaDLRTM/eWuB8OlXEb61gZhfLVJ+Y54tl0Q",
+                "curve25519:bvcxz": "7Gni0loo/nzF0nFp9847RbhElGewzwUXHPrljjBGPTQ",
             },
-            user_id: '@eve:localhost',
+            user_id: "@eve:localhost",
             signatures: {
-                '@eve:localhost': {
-                    'ed25519:bvcxz': 'CliUPZ7dyVPBxvhSA1d+X+LYa5b2AYdjcTwG' +
-                        '0stXcIxjaJNemQqtdgwKDtBFl3pN2I13SEijRDCf1A8bYiQMDg',
+                "@eve:localhost": {
+                    "ed25519:bvcxz":
+                        "CliUPZ7dyVPBxvhSA1d+X+LYa5b2AYdjcTwG" + "0stXcIxjaJNemQqtdgwKDtBFl3pN2I13SEijRDCf1A8bYiQMDg",
                 },
             },
         };
 
         const bobKeys: Record<string, typeof bobDeviceKeys> = {};
         bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when(
-            "POST", "/keys/query",
-        ).respond(200, { device_keys: { [bobUserId]: bobKeys } });
+        aliTestClient.httpBackend.when("POST", "/keys/query").respond(200, { device_keys: { [bobUserId]: bobKeys } });
 
         await Promise.all([
             aliTestClient.client.downloadKeys([bobUserId, eveUserId]),
@@ -447,26 +424,24 @@ describe("MatrixClient crypto", () => {
 
     it("Ali gets keys with an incorrect deviceId", async () => {
         const bobDeviceKeys = {
-            algorithms: ['m.olm.v1.curve25519-aes-sha2', 'm.megolm.v1.aes-sha2'],
-            device_id: 'bad_device',
+            algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+            device_id: "bad_device",
             keys: {
-                'ed25519:bad_device': 'e8XlY5V8x2yJcwa5xpSzeC/QVOrU+D5qBgyTK0ko+f0',
-                'curve25519:bad_device': 'YxuuLG/4L5xGeP8XPl5h0d7DzyYVcof7J7do+OXz0xc',
+                "ed25519:bad_device": "e8XlY5V8x2yJcwa5xpSzeC/QVOrU+D5qBgyTK0ko+f0",
+                "curve25519:bad_device": "YxuuLG/4L5xGeP8XPl5h0d7DzyYVcof7J7do+OXz0xc",
             },
-            user_id: '@bob:localhost',
+            user_id: "@bob:localhost",
             signatures: {
-                '@bob:localhost': {
-                    'ed25519:bad_device': 'fEFTq67RaSoIEVBJ8DtmRovbwUBKJ0A' +
-                        'me9m9PDzM9azPUwZ38Xvf6vv1A7W1PSafH4z3Y2ORIyEnZgHaNby3CQ',
+                "@bob:localhost": {
+                    "ed25519:bad_device":
+                        "fEFTq67RaSoIEVBJ8DtmRovbwUBKJ0A" + "me9m9PDzM9azPUwZ38Xvf6vv1A7W1PSafH4z3Y2ORIyEnZgHaNby3CQ",
                 },
             },
         };
 
         const bobKeys: Record<string, typeof bobDeviceKeys> = {};
         bobKeys[bobDeviceId] = bobDeviceKeys;
-        aliTestClient.httpBackend.when(
-            "POST", "/keys/query",
-        ).respond(200, { device_keys: { [bobUserId]: bobKeys } });
+        aliTestClient.httpBackend.when("POST", "/keys/query").respond(200, { device_keys: { [bobUserId]: bobKeys } });
 
         await Promise.all([
             aliTestClient.client.downloadKeys([bobUserId]),
@@ -535,7 +510,7 @@ describe("MatrixClient crypto", () => {
         bobTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
 
         const eventPromise = new Promise<MatrixEvent>((resolve) => {
-            const onEvent = function(event: MatrixEvent) {
+            const onEvent = function (event: MatrixEvent) {
                 logger.log(bobUserId + " received event", event);
                 resolve(event);
             };
@@ -559,11 +534,10 @@ describe("MatrixClient crypto", () => {
         await aliDownloadsKeys();
         aliTestClient.client.setDeviceBlocked(bobUserId, bobDeviceId, true);
         const p1 = sendMessage(aliTestClient.client);
-        const p2 = expectSendMessageRequest(aliTestClient.httpBackend)
-            .then(function(sentContent) {
-                // no unblocked devices, so the ciphertext should be empty
-                expect(sentContent.ciphertext).toEqual({});
-            });
+        const p2 = expectSendMessageRequest(aliTestClient.httpBackend).then(function (sentContent) {
+            // no unblocked devices, so the ciphertext should be empty
+            expect(sentContent.ciphertext).toEqual({});
+        });
         await Promise.all([p1, p2]);
     });
 
@@ -589,9 +563,7 @@ describe("MatrixClient crypto", () => {
         await firstSync(bobTestClient);
         await aliEnablesEncryption();
         await aliSendsFirstMessage();
-        bobTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, {},
-        );
+        bobTestClient.httpBackend.when("POST", "/keys/query").respond(200, {});
         await bobRecvMessage();
         await bobEnablesEncryption();
         const ciphertext = await bobSendsReplyMessage();
@@ -606,17 +578,17 @@ describe("MatrixClient crypto", () => {
         await aliTestClient.start();
         await firstSync(aliTestClient);
         const syncData = {
-            next_batch: '2',
+            next_batch: "2",
             rooms: {
                 join: {
                     [roomId]: {
                         state: {
                             events: [
                                 testUtils.mkEvent({
-                                    type: 'm.room.encryption',
-                                    skey: '',
+                                    type: "m.room.encryption",
+                                    skey: "",
                                     content: {
-                                        algorithm: 'm.olm.v1.curve25519-aes-sha2',
+                                        algorithm: "m.olm.v1.curve25519-aes-sha2",
                                     },
                                 }),
                             ],
@@ -626,9 +598,8 @@ describe("MatrixClient crypto", () => {
             },
         };
 
-        aliTestClient.httpBackend.when('GET', '/sync').respond(
-            200, syncData);
-        await aliTestClient.httpBackend.flush('/sync', 1);
+        aliTestClient.httpBackend.when("GET", "/sync").respond(200, syncData);
+        await aliTestClient.httpBackend.flush("/sync", 1);
         aliTestClient.expectKeyQuery({
             device_keys: {
                 [bobUserId]: {},
@@ -651,7 +622,7 @@ describe("MatrixClient crypto", () => {
         // enqueue expectations:
         // * Sync with empty one_time_keys => upload keys
 
-        logger.log(aliTestClient + ': starting');
+        logger.log(aliTestClient + ": starting");
         httpBackend.when("GET", "/versions").respond(200, {});
         httpBackend.when("GET", "/pushrules").respond(200, {});
         httpBackend.when("POST", "/filter").respond(200, { filter_id: "fid" });
@@ -661,24 +632,20 @@ describe("MatrixClient crypto", () => {
         // it will upload one-time keys.
         httpBackend.when("GET", "/sync").respond(200, syncDataEmpty);
 
-        await Promise.all([
-            aliTestClient.client.startClient({}),
-            httpBackend.flushAllExpected(),
-        ]);
-        logger.log(aliTestClient + ': started');
-        httpBackend.when("POST", "/keys/upload")
-            .respond(200, (_path, content: IUploadKeysRequest) => {
-                expect(content.one_time_keys).toBeTruthy();
-                expect(content.one_time_keys).not.toEqual({});
-                expect(Object.keys(content.one_time_keys!).length).toBeGreaterThanOrEqual(1);
-                // cancel futher calls by telling the client
-                // we have more than we need
-                return {
-                    one_time_key_counts: {
-                        signed_curve25519: 70,
-                    },
-                };
-            });
+        await Promise.all([aliTestClient.client.startClient({}), httpBackend.flushAllExpected()]);
+        logger.log(aliTestClient + ": started");
+        httpBackend.when("POST", "/keys/upload").respond(200, (_path, content: IUploadKeysRequest) => {
+            expect(content.one_time_keys).toBeTruthy();
+            expect(content.one_time_keys).not.toEqual({});
+            expect(Object.keys(content.one_time_keys!).length).toBeGreaterThanOrEqual(1);
+            // cancel futher calls by telling the client
+            // we have more than we need
+            return {
+                one_time_key_counts: {
+                    signed_curve25519: 70,
+                },
+            };
+        });
         await httpBackend.flushAllExpected();
     });
 
@@ -687,7 +654,7 @@ describe("MatrixClient crypto", () => {
             sender: "@bob:example.com",
             room_id: "!someroom",
             content: {
-                algorithm: 'm.megolm.v1.aes-sha2',
+                algorithm: "m.megolm.v1.aes-sha2",
                 session_id: "sessionid",
                 sender_key: "senderkey",
             },
@@ -696,7 +663,7 @@ describe("MatrixClient crypto", () => {
             sender: "@bob:example.com",
             room_id: "!someroom",
             content: {
-                algorithm: 'm.megolm.v1.aes-sha2',
+                algorithm: "m.megolm.v1.aes-sha2",
                 session_id: "sessionid",
                 sender_key: "senderkey",
             },
@@ -705,7 +672,7 @@ describe("MatrixClient crypto", () => {
             sender: "@bob:example.com",
             room_id: "!someroom",
             content: {
-                algorithm: 'm.megolm.v1.aes-sha2',
+                algorithm: "m.megolm.v1.aes-sha2",
                 session_id: "othersessionid",
                 sender_key: "senderkey",
             },
diff --git a/spec/integ/matrix-client-event-emitter.spec.ts b/spec/integ/matrix-client-event-emitter.spec.ts
index d0050e77e21..7e949f08a77 100644
--- a/spec/integ/matrix-client-event-emitter.spec.ts
+++ b/spec/integ/matrix-client-event-emitter.spec.ts
@@ -29,7 +29,7 @@ import {
 import * as utils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
 
-describe("MatrixClient events", function() {
+describe("MatrixClient events", function () {
     const selfUserId = "@alice:localhost";
     const selfAccessToken = "aseukfgwef";
     let client: MatrixClient | undefined;
@@ -46,23 +46,25 @@ describe("MatrixClient events", function() {
         return [client!, httpBackend];
     };
 
-    beforeEach(function() {
+    beforeEach(function () {
         [client!, httpBackend] = setupTests();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         httpBackend?.verifyNoOutstandingExpectation();
         client?.stopClient();
         return httpBackend?.stop();
     });
 
-    describe("emissions", function() {
+    describe("emissions", function () {
         const SYNC_DATA = {
             next_batch: "s_5_3",
             presence: {
                 events: [
                     utils.mkPresence({
-                        user: "@foo:bar", name: "Foo Bar", presence: "online",
+                        user: "@foo:bar",
+                        name: "Foo Bar",
+                        presence: "online",
                     }),
                 ],
             },
@@ -72,7 +74,9 @@ describe("MatrixClient events", function() {
                         timeline: {
                             events: [
                                 utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar", msg: "hmmm",
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    msg: "hmmm",
                                 }),
                             ],
                             prev_batch: "s",
@@ -80,10 +84,13 @@ describe("MatrixClient events", function() {
                         state: {
                             events: [
                                 utils.mkMembership({
-                                    room: "!erufh:bar", mship: "join", user: "@foo:bar",
+                                    room: "!erufh:bar",
+                                    mship: "join",
+                                    user: "@foo:bar",
                                 }),
                                 utils.mkEvent({
-                                    type: "m.room.create", room: "!erufh:bar",
+                                    type: "m.room.create",
+                                    room: "!erufh:bar",
                                     user: "@foo:bar",
                                     content: {
                                         creator: "@foo:bar",
@@ -103,18 +110,23 @@ describe("MatrixClient events", function() {
                         timeline: {
                             events: [
                                 utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar",
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
                                     msg: "ello ello",
                                 }),
                                 utils.mkMessage({
-                                    room: "!erufh:bar", user: "@foo:bar", msg: ":D",
+                                    room: "!erufh:bar",
+                                    user: "@foo:bar",
+                                    msg: ":D",
                                 }),
                             ],
                         },
                         ephemeral: {
                             events: [
                                 utils.mkEvent({
-                                    type: "m.typing", room: "!erufh:bar", content: {
+                                    type: "m.typing",
+                                    room: "!erufh:bar",
+                                    content: {
                                         user_ids: ["@foo:bar"],
                                     },
                                 }),
@@ -125,50 +137,49 @@ describe("MatrixClient events", function() {
             },
         };
 
-        it("should emit events from both the first and subsequent /sync calls",
-            function() {
-                httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-                httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-
-                let expectedEvents: Partial<IEvent>[] = [];
-                expectedEvents = expectedEvents.concat(
-                    SYNC_DATA.presence.events,
-                    SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
-                    SYNC_DATA.rooms.join["!erufh:bar"].state.events,
-                    NEXT_SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
-                    NEXT_SYNC_DATA.rooms.join["!erufh:bar"].ephemeral.events,
-                );
-
-                client!.on(ClientEvent.Event, function(event) {
-                    let found = false;
-                    for (let i = 0; i < expectedEvents.length; i++) {
-                        if (expectedEvents[i].event_id === event.getId()) {
-                            expectedEvents.splice(i, 1);
-                            found = true;
-                            break;
-                        }
+        it("should emit events from both the first and subsequent /sync calls", function () {
+            httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
+            httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+
+            let expectedEvents: Partial<IEvent>[] = [];
+            expectedEvents = expectedEvents.concat(
+                SYNC_DATA.presence.events,
+                SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
+                SYNC_DATA.rooms.join["!erufh:bar"].state.events,
+                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].timeline.events,
+                NEXT_SYNC_DATA.rooms.join["!erufh:bar"].ephemeral.events,
+            );
+
+            client!.on(ClientEvent.Event, function (event) {
+                let found = false;
+                for (let i = 0; i < expectedEvents.length; i++) {
+                    if (expectedEvents[i].event_id === event.getId()) {
+                        expectedEvents.splice(i, 1);
+                        found = true;
+                        break;
                     }
-                    expect(found).toBe(true);
-                });
+                }
+                expect(found).toBe(true);
+            });
 
-                client!.startClient();
+            client!.startClient();
 
-                return Promise.all([
+            return Promise.all([
                 // wait for two SYNCING events
-                    utils.syncPromise(client!).then(() => {
-                        return utils.syncPromise(client!);
-                    }),
-                    httpBackend!.flushAllExpected(),
-                ]).then(() => {
-                    expect(expectedEvents.length).toEqual(0);
-                });
+                utils.syncPromise(client!).then(() => {
+                    return utils.syncPromise(client!);
+                }),
+                httpBackend!.flushAllExpected(),
+            ]).then(() => {
+                expect(expectedEvents.length).toEqual(0);
             });
+        });
 
-        it("should emit User events", function(done) {
+        it("should emit User events", function (done) {
             httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
             httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
             let fired = false;
-            client!.on(UserEvent.Presence, function(event, user) {
+            client!.on(UserEvent.Presence, function (event, user) {
                 fired = true;
                 expect(user).toBeTruthy();
                 expect(event).toBeTruthy();
@@ -177,59 +188,52 @@ describe("MatrixClient events", function() {
                 }
 
                 expect(event.event).toEqual(SYNC_DATA.presence.events[0]);
-                expect(user.presence).toEqual(
-                    SYNC_DATA.presence.events[0]?.content?.presence,
-                );
+                expect(user.presence).toEqual(SYNC_DATA.presence.events[0]?.content?.presence);
             });
             client!.startClient();
 
-            httpBackend!.flushAllExpected().then(function() {
+            httpBackend!.flushAllExpected().then(function () {
                 expect(fired).toBe(true);
                 done();
             });
         });
 
-        it("should emit Room events", function() {
+        it("should emit Room events", function () {
             httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
             httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
             let roomInvokeCount = 0;
             let roomNameInvokeCount = 0;
             let timelineFireCount = 0;
-            client!.on(ClientEvent.Room, function(room) {
+            client!.on(ClientEvent.Room, function (room) {
                 roomInvokeCount++;
                 expect(room.roomId).toEqual("!erufh:bar");
             });
-            client!.on(RoomEvent.Timeline, function(event, room) {
+            client!.on(RoomEvent.Timeline, function (event, room) {
                 timelineFireCount++;
                 expect(room?.roomId).toEqual("!erufh:bar");
             });
-            client!.on(RoomEvent.Name, function(room) {
+            client!.on(RoomEvent.Name, function (room) {
                 roomNameInvokeCount++;
             });
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 2),
-            ]).then(function() {
+            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
                 expect(roomInvokeCount).toEqual(1);
                 expect(roomNameInvokeCount).toEqual(1);
                 expect(timelineFireCount).toEqual(3);
             });
         });
 
-        it("should emit RoomState events", function() {
+        it("should emit RoomState events", function () {
             httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
             httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
 
-            const roomStateEventTypes = [
-                "m.room.member", "m.room.create",
-            ];
+            const roomStateEventTypes = ["m.room.member", "m.room.create"];
             let eventsInvokeCount = 0;
             let membersInvokeCount = 0;
             let newMemberInvokeCount = 0;
-            client!.on(RoomStateEvent.Events, function(event, state) {
+            client!.on(RoomStateEvent.Events, function (event, state) {
                 eventsInvokeCount++;
                 const index = roomStateEventTypes.indexOf(event.getType());
                 expect(index).not.toEqual(-1);
@@ -237,13 +241,13 @@ describe("MatrixClient events", function() {
                     roomStateEventTypes.splice(index, 1);
                 }
             });
-            client!.on(RoomStateEvent.Members, function(event, state, member) {
+            client!.on(RoomStateEvent.Members, function (event, state, member) {
                 membersInvokeCount++;
                 expect(member.roomId).toEqual("!erufh:bar");
                 expect(member.userId).toEqual("@foo:bar");
                 expect(member.membership).toEqual("join");
             });
-            client!.on(RoomStateEvent.NewMember, function(event, state, member) {
+            client!.on(RoomStateEvent.NewMember, function (event, state, member) {
                 newMemberInvokeCount++;
                 expect(member.roomId).toEqual("!erufh:bar");
                 expect(member.userId).toEqual("@foo:bar");
@@ -252,17 +256,14 @@ describe("MatrixClient events", function() {
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 2),
-            ]).then(function() {
+            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
                 expect(membersInvokeCount).toEqual(1);
                 expect(newMemberInvokeCount).toEqual(1);
                 expect(eventsInvokeCount).toEqual(2);
             });
         });
 
-        it("should emit RoomMember events", function() {
+        it("should emit RoomMember events", function () {
             httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
             httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
 
@@ -270,27 +271,24 @@ describe("MatrixClient events", function() {
             let powerLevelInvokeCount = 0;
             let nameInvokeCount = 0;
             let membershipInvokeCount = 0;
-            client!.on(RoomMemberEvent.Name, function(event, member) {
+            client!.on(RoomMemberEvent.Name, function (event, member) {
                 nameInvokeCount++;
             });
-            client!.on(RoomMemberEvent.Typing, function(event, member) {
+            client!.on(RoomMemberEvent.Typing, function (event, member) {
                 typingInvokeCount++;
                 expect(member.typing).toBe(true);
             });
-            client!.on(RoomMemberEvent.PowerLevel, function(event, member) {
+            client!.on(RoomMemberEvent.PowerLevel, function (event, member) {
                 powerLevelInvokeCount++;
             });
-            client!.on(RoomMemberEvent.Membership, function(event, member) {
+            client!.on(RoomMemberEvent.Membership, function (event, member) {
                 membershipInvokeCount++;
                 expect(member.membership).toEqual("join");
             });
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 2),
-            ]).then(function() {
+            return Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 2)]).then(function () {
                 expect(typingInvokeCount).toEqual(1);
                 expect(powerLevelInvokeCount).toEqual(0);
                 expect(nameInvokeCount).toEqual(0);
@@ -298,36 +296,36 @@ describe("MatrixClient events", function() {
             });
         });
 
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN", function() {
-            const error = { errcode: 'M_UNKNOWN_TOKEN' };
+        it("should emit Session.logged_out on M_UNKNOWN_TOKEN", function () {
+            const error = { errcode: "M_UNKNOWN_TOKEN" };
             httpBackend!.when("GET", "/sync").respond(401, error);
 
             let sessionLoggedOutCount = 0;
-            client!.on(HttpApiEvent.SessionLoggedOut, function(errObj) {
+            client!.on(HttpApiEvent.SessionLoggedOut, function (errObj) {
                 sessionLoggedOutCount++;
                 expect(errObj.data).toEqual(error);
             });
 
             client!.startClient();
 
-            return httpBackend!.flushAllExpected().then(function() {
+            return httpBackend!.flushAllExpected().then(function () {
                 expect(sessionLoggedOutCount).toEqual(1);
             });
         });
 
-        it("should emit Session.logged_out on M_UNKNOWN_TOKEN (soft logout)", function() {
-            const error = { errcode: 'M_UNKNOWN_TOKEN', soft_logout: true };
+        it("should emit Session.logged_out on M_UNKNOWN_TOKEN (soft logout)", function () {
+            const error = { errcode: "M_UNKNOWN_TOKEN", soft_logout: true };
             httpBackend!.when("GET", "/sync").respond(401, error);
 
             let sessionLoggedOutCount = 0;
-            client!.on(HttpApiEvent.SessionLoggedOut, function(errObj) {
+            client!.on(HttpApiEvent.SessionLoggedOut, function (errObj) {
                 sessionLoggedOutCount++;
                 expect(errObj.data).toEqual(error);
             });
 
             client!.startClient();
 
-            return httpBackend!.flushAllExpected().then(function() {
+            return httpBackend!.flushAllExpected().then(function () {
                 expect(sessionLoggedOutCount).toEqual(1);
             });
         });
diff --git a/spec/integ/matrix-client-event-timeline.spec.ts b/spec/integ/matrix-client-event-timeline.spec.ts
index 5bbb8275972..63d47540a30 100644
--- a/spec/integ/matrix-client-event-timeline.spec.ts
+++ b/spec/integ/matrix-client-event-timeline.spec.ts
@@ -48,11 +48,17 @@ const withoutRoomId = (e: Partial<IEvent>): Partial<IEvent> => {
 };
 
 const USER_MEMBERSHIP_EVENT = utils.mkMembership({
-    room: roomId, mship: "join", user: userId, name: userName, event: false,
+    room: roomId,
+    mship: "join",
+    user: userId,
+    name: userName,
+    event: false,
 });
 
 const ROOM_NAME_EVENT = utils.mkEvent({
-    type: "m.room.name", room: roomId, user: otherUserId,
+    type: "m.room.name",
+    room: roomId,
+    user: otherUserId,
     content: {
         name: "Old room name",
     },
@@ -67,7 +73,9 @@ const INITIAL_SYNC_DATA = {
                 timeline: {
                     events: [
                         utils.mkMessage({
-                            user: otherUserId, msg: "hello", event: false,
+                            user: otherUserId,
+                            msg: "hello",
+                            event: false,
                         }),
                     ],
                     prev_batch: "f_1_1",
@@ -77,12 +85,14 @@ const INITIAL_SYNC_DATA = {
                         withoutRoomId(ROOM_NAME_EVENT),
                         utils.mkMembership({
                             mship: "join",
-                            user: otherUserId, name: "Bob",
+                            user: otherUserId,
+                            name: "Bob",
                             event: false,
                         }),
                         withoutRoomId(USER_MEMBERSHIP_EVENT),
                         utils.mkEvent({
-                            type: "m.room.create", user: userId,
+                            type: "m.room.create",
+                            user: userId,
                             content: {
                                 creator: userId,
                             },
@@ -97,16 +107,28 @@ const INITIAL_SYNC_DATA = {
 
 const EVENTS = [
     utils.mkMessage({
-        room: roomId, user: userId, msg: "we", event: false,
+        room: roomId,
+        user: userId,
+        msg: "we",
+        event: false,
     }),
     utils.mkMessage({
-        room: roomId, user: userId, msg: "could", event: false,
+        room: roomId,
+        user: userId,
+        msg: "could",
+        event: false,
     }),
     utils.mkMessage({
-        room: roomId, user: userId, msg: "be", event: false,
+        room: roomId,
+        user: userId,
+        msg: "be",
+        event: false,
     }),
     utils.mkMessage({
-        room: roomId, user: userId, msg: "heroes", event: false,
+        room: roomId,
+        user: userId,
+        msg: "heroes",
+        event: false,
     }),
 ];
 
@@ -115,15 +137,15 @@ const THREAD_ROOT = utils.mkEvent({
     user: userId,
     type: "m.room.message",
     content: {
-        "body": "thread root",
-        "msgtype": "m.text",
+        body: "thread root",
+        msgtype: "m.text",
     },
     unsigned: {
         "m.relations": {
             "io.element.thread": {
                 //"latest_event": undefined,
-                "count": 1,
-                "current_user_participated": true,
+                count: 1,
+                current_user_participated: true,
             },
         },
     },
@@ -154,9 +176,9 @@ const SYNC_THREAD_REPLY = withoutRoomId(THREAD_REPLY);
 SYNC_THREAD_ROOT.unsigned = {
     "m.relations": {
         "io.element.thread": {
-            "latest_event": SYNC_THREAD_REPLY,
-            "count": 1,
-            "current_user_participated": true,
+            latest_event: SYNC_THREAD_REPLY,
+            count: 1,
+            current_user_participated: true,
         },
     },
 };
@@ -175,7 +197,7 @@ function startClient(httpBackend: HttpBackend, client: MatrixClient) {
 
     // set up a promise which will resolve once the client is initialised
     const prom = new Promise<void>((resolve) => {
-        client.on(ClientEvent.Sync, function(state) {
+        client.on(ClientEvent.Sync, function (state) {
             logger.log("sync", state);
             if (state != "SYNCING") {
                 return;
@@ -184,55 +206,40 @@ function startClient(httpBackend: HttpBackend, client: MatrixClient) {
         });
     });
 
-    return Promise.all([
-        httpBackend.flushAllExpected(),
-        prom,
-    ]);
+    return Promise.all([httpBackend.flushAllExpected(), prom]);
 }
 
-describe("getEventTimeline support", function() {
+describe("getEventTimeline support", function () {
     let httpBackend: HttpBackend;
     let client: MatrixClient;
 
-    beforeEach(function() {
+    beforeEach(function () {
         const testClient = new TestClient(userId, "DEVICE", accessToken);
         client = testClient.client;
         httpBackend = testClient.httpBackend;
     });
 
-    afterEach(function() {
+    afterEach(function () {
         if (client) {
             client.stopClient();
         }
         return httpBackend.stop();
     });
 
-    it("timeline support must be enabled to work", function() {
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: false },
-        );
+    it("timeline support must be enabled to work", function () {
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: false });
         client = testClient.client;
         httpBackend = testClient.httpBackend;
 
-        return startClient(httpBackend, client).then(function() {
+        return startClient(httpBackend, client).then(function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room!.getTimelineSets()[0];
             expect(client.getEventTimeline(timelineSet, "event")).rejects.toBeTruthy();
         });
     });
 
-    it("timeline support works when enabled", function() {
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
+    it("timeline support works when enabled", function () {
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: true });
         client = testClient.client;
         httpBackend = testClient.httpBackend;
 
@@ -243,106 +250,90 @@ describe("getEventTimeline support", function() {
         });
     });
 
-    it("only works with room timelines", function() {
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
+    it("only works with room timelines", function () {
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: true });
         client = testClient.client;
         httpBackend = testClient.httpBackend;
 
-        return startClient(httpBackend, client).then(function() {
+        return startClient(httpBackend, client).then(function () {
             const timelineSet = new EventTimelineSet(undefined);
             expect(client.getEventTimeline(timelineSet, "event")).rejects.toBeTruthy();
         });
     });
 
-    it("scrollback should be able to scroll back to before a gappy /sync", function() {
+    it("scrollback should be able to scroll back to before a gappy /sync", function () {
         // need a client with timelineSupport disabled to make this work
         let room: Room | undefined;
 
-        return startClient(httpBackend, client).then(function() {
-            room = client.getRoom(roomId)!;
-
-            httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: "s_5_4",
-                rooms: {
-                    join: {
-                        "!foo:bar": {
-                            timeline: {
-                                events: [
-                                    withoutRoomId(EVENTS[0]),
-                                ],
-                                prev_batch: "f_1_1",
+        return startClient(httpBackend, client)
+            .then(function () {
+                room = client.getRoom(roomId)!;
+
+                httpBackend.when("GET", "/sync").respond(200, {
+                    next_batch: "s_5_4",
+                    rooms: {
+                        join: {
+                            "!foo:bar": {
+                                timeline: {
+                                    events: [withoutRoomId(EVENTS[0])],
+                                    prev_batch: "f_1_1",
+                                },
                             },
                         },
                     },
-                },
-            });
+                });
 
-            httpBackend.when("GET", "/sync").respond(200, {
-                next_batch: "s_5_5",
-                rooms: {
-                    join: {
-                        "!foo:bar": {
-                            timeline: {
-                                events: [
-                                    withoutRoomId(EVENTS[1]),
-                                ],
-                                limited: true,
-                                prev_batch: "f_1_2",
+                httpBackend.when("GET", "/sync").respond(200, {
+                    next_batch: "s_5_5",
+                    rooms: {
+                        join: {
+                            "!foo:bar": {
+                                timeline: {
+                                    events: [withoutRoomId(EVENTS[1])],
+                                    limited: true,
+                                    prev_batch: "f_1_2",
+                                },
                             },
                         },
                     },
-                },
-            });
+                });
 
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client, 2),
-            ]);
-        }).then(function() {
-            expect(room!.timeline.length).toEqual(1);
-            expect(room!.timeline[0].event).toEqual(EVENTS[1]);
-
-            httpBackend.when("GET", "/messages").respond(200, {
-                chunk: [EVENTS[0]],
-                start: "pagin_start",
-                end: "pagin_end",
+                return Promise.all([httpBackend.flushAllExpected(), utils.syncPromise(client, 2)]);
+            })
+            .then(function () {
+                expect(room!.timeline.length).toEqual(1);
+                expect(room!.timeline[0].event).toEqual(EVENTS[1]);
+
+                httpBackend.when("GET", "/messages").respond(200, {
+                    chunk: [EVENTS[0]],
+                    start: "pagin_start",
+                    end: "pagin_end",
+                });
+                httpBackend.flush("/messages", 1);
+                return client.scrollback(room!);
+            })
+            .then(function () {
+                expect(room!.timeline.length).toEqual(2);
+                expect(room!.timeline[0].event).toEqual(EVENTS[0]);
+                expect(room!.timeline[1].event).toEqual(EVENTS[1]);
+                expect(room!.oldState.paginationToken).toEqual("pagin_end");
             });
-            httpBackend.flush("/messages", 1);
-            return client.scrollback(room!);
-        }).then(function() {
-            expect(room!.timeline.length).toEqual(2);
-            expect(room!.timeline[0].event).toEqual(EVENTS[0]);
-            expect(room!.timeline[1].event).toEqual(EVENTS[1]);
-            expect(room!.oldState.paginationToken).toEqual("pagin_end");
-        });
     });
 });
 
-describe("MatrixClient event timelines", function() {
+describe("MatrixClient event timelines", function () {
     let client: MatrixClient;
     let httpBackend: HttpBackend;
 
-    beforeEach(function() {
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
+    beforeEach(function () {
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: true });
         client = testClient.client;
         httpBackend = testClient.httpBackend;
 
         return startClient(httpBackend, client);
     });
 
-    afterEach(function() {
+    afterEach(function () {
         httpBackend.verifyNoOutstandingExpectation();
         client.stopClient();
         Thread.setServerSideSupport(FeatureSupport.None);
@@ -354,42 +345,36 @@ describe("MatrixClient event timelines", function() {
         return Promise.all([promise, httpBackend.flushAllExpected()]).then(([result]) => result);
     }
 
-    describe("getEventTimeline", function() {
-        it("should create a new timeline for new events", function() {
+    describe("getEventTimeline", function () {
+        it("should create a new timeline for new events", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/event1%3Abar")
-                .respond(200, function() {
-                    return {
-                        start: "start_token",
-                        events_before: [EVENTS[1], EVENTS[0]],
-                        event: EVENTS[2],
-                        events_after: [EVENTS[3]],
-                        state: [
-                            ROOM_NAME_EVENT,
-                            USER_MEMBERSHIP_EVENT,
-                        ],
-                        end: "end_token",
-                    };
-                });
+            httpBackend.when("GET", "/rooms/!foo%3Abar/context/event1%3Abar").respond(200, function () {
+                return {
+                    start: "start_token",
+                    events_before: [EVENTS[1], EVENTS[0]],
+                    event: EVENTS[2],
+                    events_after: [EVENTS[3]],
+                    state: [ROOM_NAME_EVENT, USER_MEMBERSHIP_EVENT],
+                    end: "end_token",
+                };
+            });
 
             return Promise.all([
-                client.getEventTimeline(timelineSet, "event1:bar").then(function(tl) {
+                client.getEventTimeline(timelineSet, "event1:bar").then(function (tl) {
                     expect(tl!.getEvents().length).toEqual(4);
                     for (let i = 0; i < 4; i++) {
                         expect(tl!.getEvents()[i].event).toEqual(EVENTS[i]);
                         expect(tl!.getEvents()[i]?.sender?.name).toEqual(userName);
                     }
-                    expect(tl!.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token");
-                    expect(tl!.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token");
+                    expect(tl!.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("start_token");
+                    expect(tl!.getPaginationToken(EventTimeline.FORWARDS)).toEqual("end_token");
                 }),
                 httpBackend.flushAllExpected(),
             ]);
         });
 
-        it("should return existing timeline for known events", function() {
+        it("should return existing timeline for known events", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
             httpBackend.when("GET", "/sync").respond(200, {
@@ -398,9 +383,7 @@ describe("MatrixClient event timelines", function() {
                     join: {
                         "!foo:bar": {
                             timeline: {
-                                events: [
-                                    withoutRoomId(EVENTS[0]),
-                                ],
+                                events: [withoutRoomId(EVENTS[0])],
                                 prev_batch: "f_1_2",
                             },
                         },
@@ -408,23 +391,21 @@ describe("MatrixClient event timelines", function() {
                 },
             });
 
-            return Promise.all([
-                httpBackend.flush("/sync"),
-                utils.syncPromise(client),
-            ]).then(function() {
-                return client.getEventTimeline(timelineSet, EVENTS[0].event_id!);
-            }).then(function(tl) {
-                expect(tl!.getEvents().length).toEqual(2);
-                expect(tl!.getEvents()[1].event).toEqual(EVENTS[0]);
-                expect(tl!.getEvents()[1]?.sender?.name).toEqual(userName);
-                expect(tl!.getPaginationToken(EventTimeline.BACKWARDS))
-                    .toEqual("f_1_1");
-                // expect(tl.getPaginationToken(EventTimeline.FORWARDS))
-                //    .toEqual("s_5_4");
-            });
+            return Promise.all([httpBackend.flush("/sync"), utils.syncPromise(client)])
+                .then(function () {
+                    return client.getEventTimeline(timelineSet, EVENTS[0].event_id!);
+                })
+                .then(function (tl) {
+                    expect(tl!.getEvents().length).toEqual(2);
+                    expect(tl!.getEvents()[1].event).toEqual(EVENTS[0]);
+                    expect(tl!.getEvents()[1]?.sender?.name).toEqual(userName);
+                    expect(tl!.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("f_1_1");
+                    // expect(tl.getPaginationToken(EventTimeline.FORWARDS))
+                    //    .toEqual("s_5_4");
+                });
         });
 
-        it("should update timelines where they overlap a previous /sync", function() {
+        it("should update timelines where they overlap a previous /sync", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
             httpBackend.when("GET", "/sync").respond(200, {
@@ -433,9 +414,7 @@ describe("MatrixClient event timelines", function() {
                     join: {
                         "!foo:bar": {
                             timeline: {
-                                events: [
-                                    withoutRoomId(EVENTS[3]),
-                                ],
+                                events: [withoutRoomId(EVENTS[3])],
                                 prev_batch: "f_1_2",
                             },
                         },
@@ -443,9 +422,9 @@ describe("MatrixClient event timelines", function() {
                 },
             });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[2].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[2].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token",
                         events_before: [EVENTS[1]],
@@ -457,36 +436,34 @@ describe("MatrixClient event timelines", function() {
                 });
 
             const prom = new Promise((resolve, reject) => {
-                client.on(ClientEvent.Sync, function() {
-                    client.getEventTimeline(timelineSet, EVENTS[2].event_id!,
-                    ).then(function(tl) {
-                        expect(tl!.getEvents().length).toEqual(4);
-                        expect(tl!.getEvents()[0].event).toEqual(EVENTS[1]);
-                        expect(tl!.getEvents()[1].event).toEqual(EVENTS[2]);
-                        expect(tl!.getEvents()[3].event).toEqual(EVENTS[3]);
-                        expect(tl!.getPaginationToken(EventTimeline.BACKWARDS))
-                            .toEqual("start_token");
-                        // expect(tl.getPaginationToken(EventTimeline.FORWARDS))
-                        //    .toEqual("s_5_4");
-                    }).then(resolve, reject);
+                client.on(ClientEvent.Sync, function () {
+                    client
+                        .getEventTimeline(timelineSet, EVENTS[2].event_id!)
+                        .then(function (tl) {
+                            expect(tl!.getEvents().length).toEqual(4);
+                            expect(tl!.getEvents()[0].event).toEqual(EVENTS[1]);
+                            expect(tl!.getEvents()[1].event).toEqual(EVENTS[2]);
+                            expect(tl!.getEvents()[3].event).toEqual(EVENTS[3]);
+                            expect(tl!.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("start_token");
+                            // expect(tl.getPaginationToken(EventTimeline.FORWARDS))
+                            //    .toEqual("s_5_4");
+                        })
+                        .then(resolve, reject);
                 });
             });
 
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                prom,
-            ]);
+            return Promise.all([httpBackend.flushAllExpected(), prom]);
         });
 
-        it("should join timelines where they overlap a previous /context", function() {
+        it("should join timelines where they overlap a previous /context", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
             // we fetch event 0, then 2, then 3, and finally 1. 1 is returned
             // with context which joins them all up.
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[0].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token0",
                         events_before: [],
@@ -497,9 +474,9 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[2].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[2].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token2",
                         events_before: [],
@@ -510,9 +487,9 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[3].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[3].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token3",
                         events_before: [],
@@ -523,9 +500,9 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[1].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[1].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token4",
                         events_before: [EVENTS[0]],
@@ -539,64 +516,63 @@ describe("MatrixClient event timelines", function() {
             let tl0: EventTimeline;
             let tl3: EventTimeline;
             return Promise.all([
-                client.getEventTimeline(timelineSet, EVENTS[0].event_id!,
-                ).then(function(tl) {
-                    expect(tl!.getEvents().length).toEqual(1);
-                    tl0 = tl!;
-                    return client.getEventTimeline(timelineSet, EVENTS[2].event_id!);
-                }).then(function(tl) {
-                    expect(tl!.getEvents().length).toEqual(1);
-                    return client.getEventTimeline(timelineSet, EVENTS[3].event_id!);
-                }).then(function(tl) {
-                    expect(tl!.getEvents().length).toEqual(1);
-                    tl3 = tl!;
-                    return client.getEventTimeline(timelineSet, EVENTS[1].event_id!);
-                }).then(function(tl) {
-                    // we expect it to get merged in with event 2
-                    expect(tl!.getEvents().length).toEqual(2);
-                    expect(tl!.getEvents()[0].event).toEqual(EVENTS[1]);
-                    expect(tl!.getEvents()[1].event).toEqual(EVENTS[2]);
-                    expect(tl!.getNeighbouringTimeline(EventTimeline.BACKWARDS))
-                        .toBe(tl0);
-                    expect(tl!.getNeighbouringTimeline(EventTimeline.FORWARDS))
-                        .toBe(tl3);
-                    expect(tl0.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token0");
-                    expect(tl0.getPaginationToken(EventTimeline.FORWARDS))
-                        .toBe(null);
-                    expect(tl3.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toBe(null);
-                    expect(tl3.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token3");
-                }),
+                client
+                    .getEventTimeline(timelineSet, EVENTS[0].event_id!)
+                    .then(function (tl) {
+                        expect(tl!.getEvents().length).toEqual(1);
+                        tl0 = tl!;
+                        return client.getEventTimeline(timelineSet, EVENTS[2].event_id!);
+                    })
+                    .then(function (tl) {
+                        expect(tl!.getEvents().length).toEqual(1);
+                        return client.getEventTimeline(timelineSet, EVENTS[3].event_id!);
+                    })
+                    .then(function (tl) {
+                        expect(tl!.getEvents().length).toEqual(1);
+                        tl3 = tl!;
+                        return client.getEventTimeline(timelineSet, EVENTS[1].event_id!);
+                    })
+                    .then(function (tl) {
+                        // we expect it to get merged in with event 2
+                        expect(tl!.getEvents().length).toEqual(2);
+                        expect(tl!.getEvents()[0].event).toEqual(EVENTS[1]);
+                        expect(tl!.getEvents()[1].event).toEqual(EVENTS[2]);
+                        expect(tl!.getNeighbouringTimeline(EventTimeline.BACKWARDS)).toBe(tl0);
+                        expect(tl!.getNeighbouringTimeline(EventTimeline.FORWARDS)).toBe(tl3);
+                        expect(tl0.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("start_token0");
+                        expect(tl0.getPaginationToken(EventTimeline.FORWARDS)).toBe(null);
+                        expect(tl3.getPaginationToken(EventTimeline.BACKWARDS)).toBe(null);
+                        expect(tl3.getPaginationToken(EventTimeline.FORWARDS)).toEqual("end_token3");
+                    }),
                 httpBackend.flushAllExpected(),
             ]);
         });
 
-        it("should fail gracefully if there is no event field", function() {
+        it("should fail gracefully if there is no event field", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
             // we fetch event 0, then 2, then 3, and finally 1. 1 is returned
             // with context which joins them all up.
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/event1")
-                .respond(200, function() {
-                    return {
-                        start: "start_token",
-                        events_before: [],
-                        events_after: [],
-                        end: "end_token",
-                        state: [],
-                    };
-                });
+            httpBackend.when("GET", "/rooms/!foo%3Abar/context/event1").respond(200, function () {
+                return {
+                    start: "start_token",
+                    events_before: [],
+                    events_after: [],
+                    end: "end_token",
+                    state: [],
+                };
+            });
 
             return Promise.all([
-                client.getEventTimeline(timelineSet, "event1",
-                ).then(function(tl) {
-                    // could do with a fail()
-                    expect(true).toBeFalsy();
-                }, function(e) {
-                    expect(String(e)).toMatch(/'event'/);
-                }),
+                client.getEventTimeline(timelineSet, "event1").then(
+                    function (tl) {
+                        // could do with a fail()
+                        expect(true).toBeFalsy();
+                    },
+                    function (e) {
+                        expect(String(e)).toMatch(/'event'/);
+                    },
+                ),
                 httpBackend.flushAllExpected(),
             ]);
         });
@@ -608,20 +584,28 @@ describe("MatrixClient event timelines", function() {
             await client.stopClient(); // we don't need the client to be syncing at this time
             const room = client.getRoom(roomId)!;
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return THREAD_ROOT;
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return THREAD_ROOT;
                 });
 
-            httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
-                encodeURIComponent(THREAD_ROOT.event_id!) + "/" +
-                encodeURIComponent(THREAD_RELATION_TYPE.name) + "?dir=b&limit=1")
-                .respond(200, function() {
+            httpBackend
+                .when(
+                    "GET",
+                    "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
+                        encodeURIComponent(THREAD_ROOT.event_id!) +
+                        "/" +
+                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
+                        "?dir=b&limit=1",
+                )
+                .respond(200, function () {
                     return {
                         original_event: THREAD_ROOT,
                         chunk: [THREAD_REPLY],
@@ -636,8 +620,8 @@ describe("MatrixClient event timelines", function() {
             const timelinePromise = client.getEventTimeline(timelineSet, THREAD_REPLY.event_id!);
             const timeline = await timelinePromise;
 
-            expect(timeline!.getEvents().find(e => e.getId() === THREAD_ROOT.event_id!)).toBeTruthy();
-            expect(timeline!.getEvents().find(e => e.getId() === THREAD_REPLY.event_id!)).toBeTruthy();
+            expect(timeline!.getEvents().find((e) => e.getId() === THREAD_ROOT.event_id!)).toBeTruthy();
+            expect(timeline!.getEvents().find((e) => e.getId() === THREAD_REPLY.event_id!)).toBeTruthy();
         });
 
         it("should handle thread replies with server support by fetching a contiguous thread timeline", async () => {
@@ -647,15 +631,22 @@ describe("MatrixClient event timelines", function() {
             await client.stopClient(); // we don't need the client to be syncing at this time
             const room = client.getRoom(roomId)!;
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return THREAD_ROOT;
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/relations/" +
-                encodeURIComponent(THREAD_ROOT.event_id!) + "/" +
-                encodeURIComponent(THREAD_RELATION_TYPE.name) + "?dir=b&limit=1")
-                .respond(200, function() {
+            httpBackend
+                .when(
+                    "GET",
+                    "/rooms/!foo%3Abar/relations/" +
+                        encodeURIComponent(THREAD_ROOT.event_id!) +
+                        "/" +
+                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
+                        "?dir=b&limit=1",
+                )
+                .respond(200, function () {
                     return {
                         chunk: [THREAD_REPLY],
                         // no next batch as this is the oldest end of the timeline
@@ -666,15 +657,16 @@ describe("MatrixClient event timelines", function() {
             await httpBackend.flushAllExpected();
             const timelineSet = thread.timelineSet;
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return THREAD_ROOT;
                 });
 
             const timelinePromise = client.getEventTimeline(timelineSet, THREAD_REPLY.event_id!);
             const [timeline] = await Promise.all([timelinePromise, httpBackend.flushAllExpected()]);
 
-            const eventIds = timeline!.getEvents().map(it => it.getId());
+            const eventIds = timeline!.getEvents().map((it) => it.getId());
             expect(eventIds).toContain(THREAD_ROOT.event_id);
             expect(eventIds).toContain(THREAD_REPLY.event_id);
         });
@@ -689,8 +681,9 @@ describe("MatrixClient event timelines", function() {
             const thread = room.createThread(THREAD_ROOT.event_id!, threadRoot, [threadRoot], false)!;
             const timelineSet = room.getTimelineSets()[0]!;
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token0",
                         events_before: [],
@@ -708,7 +701,7 @@ describe("MatrixClient event timelines", function() {
 
             expect(timeline!).not.toBe(thread.liveTimeline);
             expect(timelineSet.getTimelines()).toContain(timeline);
-            expect(timeline!.getEvents().find(e => e.getId() === THREAD_ROOT.event_id!)).toBeTruthy();
+            expect(timeline!.getEvents().find((e) => e.getId() === THREAD_ROOT.event_id!)).toBeTruthy();
         });
 
         it("should return undefined when event is not in the thread that the given timelineSet is representing", () => {
@@ -721,8 +714,9 @@ describe("MatrixClient event timelines", function() {
             const thread = room.createThread(THREAD_ROOT.event_id!, threadRoot, [threadRoot], false);
             const timelineSet = thread.timelineSet;
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token0",
                         events_before: [],
@@ -747,8 +741,9 @@ describe("MatrixClient event timelines", function() {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_REPLY.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_REPLY.event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token0",
                         events_before: [],
@@ -773,7 +768,7 @@ describe("MatrixClient event timelines", function() {
             const timelineSet = room.getTimelineSets()[0];
 
             const req = httpBackend.when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!));
-            req.respond(200, function() {
+            req.respond(200, function () {
                 return {
                     start: "start_token0",
                     events_before: [],
@@ -794,17 +789,11 @@ describe("MatrixClient event timelines", function() {
         });
     });
 
-    describe("getLatestTimeline", function() {
-        it("timeline support must be enabled to work", async function() {
+    describe("getLatestTimeline", function () {
+        it("timeline support must be enabled to work", async function () {
             await client.stopClient();
 
-            const testClient = new TestClient(
-                userId,
-                "DEVICE",
-                accessToken,
-                undefined,
-                { timelineSupport: false },
-            );
+            const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: false });
             client = testClient.client;
             httpBackend = testClient.httpBackend;
             await startClient(httpBackend, client);
@@ -814,16 +803,10 @@ describe("MatrixClient event timelines", function() {
             await expect(client.getLatestTimeline(timelineSet)).rejects.toBeTruthy();
         });
 
-        it("timeline support works when enabled", async function() {
+        it("timeline support works when enabled", async function () {
             await client.stopClient();
 
-            const testClient = new TestClient(
-                userId,
-                "DEVICE",
-                accessToken,
-                undefined,
-                { timelineSupport: true },
-            );
+            const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: true });
             client = testClient.client;
             httpBackend = testClient.httpBackend;
 
@@ -834,16 +817,10 @@ describe("MatrixClient event timelines", function() {
             });
         });
 
-        it("only works with room timelines", async function() {
+        it("only works with room timelines", async function () {
             await client.stopClient();
 
-            const testClient = new TestClient(
-                userId,
-                "DEVICE",
-                accessToken,
-                undefined,
-                { timelineSupport: true },
-            );
+            const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: true });
             client = testClient.client;
             httpBackend = testClient.httpBackend;
             await startClient(httpBackend, client);
@@ -852,38 +829,37 @@ describe("MatrixClient event timelines", function() {
             await expect(client.getLatestTimeline(timelineSet)).rejects.toBeTruthy();
         });
 
-        it("should create a new timeline for new events", function() {
+        it("should create a new timeline for new events", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
-            const latestMessageId = 'event1:bar';
+            const latestMessageId = "event1:bar";
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
-                .respond(200, function() {
-                    return {
-                        chunk: [{
+            httpBackend.when("GET", "/rooms/!foo%3Abar/messages").respond(200, function () {
+                return {
+                    chunk: [
+                        {
                             event_id: latestMessageId,
-                        }],
-                    };
-                });
+                        },
+                    ],
+                };
+            });
 
-            httpBackend.when("GET", `/rooms/!foo%3Abar/context/${encodeURIComponent(latestMessageId)}`)
-                .respond(200, function() {
+            httpBackend
+                .when("GET", `/rooms/!foo%3Abar/context/${encodeURIComponent(latestMessageId)}`)
+                .respond(200, function () {
                     return {
                         start: "start_token",
                         events_before: [EVENTS[1], EVENTS[0]],
                         event: EVENTS[2],
                         events_after: [EVENTS[3]],
-                        state: [
-                            ROOM_NAME_EVENT,
-                            USER_MEMBERSHIP_EVENT,
-                        ],
+                        state: [ROOM_NAME_EVENT, USER_MEMBERSHIP_EVENT],
                         end: "end_token",
                     };
                 });
 
             return Promise.all([
-                client.getLatestTimeline(timelineSet).then(function(tl) {
+                client.getLatestTimeline(timelineSet).then(function (tl) {
                     // Instead of this assertion logic, we could just add a spy
                     // for `getEventTimeline` and make sure it's called with the
                     // correct parameters. This doesn't feel too bad to make sure
@@ -893,10 +869,8 @@ describe("MatrixClient event timelines", function() {
                         expect(tl!.getEvents()[i].event).toEqual(EVENTS[i]);
                         expect(tl!.getEvents()[i]?.sender?.name).toEqual(userName);
                     }
-                    expect(tl!.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token");
-                    expect(tl!.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token");
+                    expect(tl!.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("start_token");
+                    expect(tl!.getPaginationToken(EventTimeline.FORWARDS)).toEqual("end_token");
                 }),
                 httpBackend.flushAllExpected(),
             ]);
@@ -906,14 +880,13 @@ describe("MatrixClient event timelines", function() {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
-                .respond(200, () => {
-                    return {
-                        chunk: [
-                            // No messages to return
-                        ],
-                    };
-                });
+            httpBackend.when("GET", "/rooms/!foo%3Abar/messages").respond(200, () => {
+                return {
+                    chunk: [
+                        // No messages to return
+                    ],
+                };
+            });
 
             return Promise.all([
                 expect(client.getLatestTimeline(timelineSet)).rejects.toThrow(),
@@ -922,14 +895,14 @@ describe("MatrixClient event timelines", function() {
         });
     });
 
-    describe("paginateEventTimeline", function() {
-        it("should allow you to paginate backwards", function() {
+    describe("paginateEventTimeline", function () {
+        it("should allow you to paginate backwards", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[0].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token0",
                         events_before: [],
@@ -940,13 +913,15 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
-                .check(function(req) {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/messages")
+                .check(function (req) {
                     const params = req.queryParams!;
                     expect(params.dir).toEqual("b");
                     expect(params.from).toEqual("start_token0");
                     expect(params.limit).toEqual("30");
-                }).respond(200, function() {
+                })
+                .respond(200, function () {
                     return {
                         chunk: [EVENTS[1], EVENTS[2]],
                         end: "start_token1",
@@ -955,21 +930,21 @@ describe("MatrixClient event timelines", function() {
 
             let tl: EventTimeline;
             return Promise.all([
-                client.getEventTimeline(timelineSet, EVENTS[0].event_id!,
-                ).then(function(tl0) {
-                    tl = tl0!;
-                    return client.paginateEventTimeline(tl, { backwards: true });
-                }).then(function(success) {
-                    expect(success).toBeTruthy();
-                    expect(tl!.getEvents().length).toEqual(3);
-                    expect(tl!.getEvents()[0].event).toEqual(EVENTS[2]);
-                    expect(tl!.getEvents()[1].event).toEqual(EVENTS[1]);
-                    expect(tl!.getEvents()[2].event).toEqual(EVENTS[0]);
-                    expect(tl!.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token1");
-                    expect(tl!.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token0");
-                }),
+                client
+                    .getEventTimeline(timelineSet, EVENTS[0].event_id!)
+                    .then(function (tl0) {
+                        tl = tl0!;
+                        return client.paginateEventTimeline(tl, { backwards: true });
+                    })
+                    .then(function (success) {
+                        expect(success).toBeTruthy();
+                        expect(tl!.getEvents().length).toEqual(3);
+                        expect(tl!.getEvents()[0].event).toEqual(EVENTS[2]);
+                        expect(tl!.getEvents()[1].event).toEqual(EVENTS[1]);
+                        expect(tl!.getEvents()[2].event).toEqual(EVENTS[0]);
+                        expect(tl!.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("start_token1");
+                        expect(tl!.getPaginationToken(EventTimeline.FORWARDS)).toEqual("end_token0");
+                    }),
                 httpBackend.flushAllExpected(),
             ]);
         });
@@ -978,8 +953,8 @@ describe("MatrixClient event timelines", function() {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                encodeURIComponent(EVENTS[0].event_id!))
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!))
                 .respond(200, () => ({
                     start: "start_token0",
                     events_before: [],
@@ -989,13 +964,15 @@ describe("MatrixClient event timelines", function() {
                     state: [],
                 }));
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
-                .check(function(req) {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/messages")
+                .check(function (req) {
                     const params = req.queryParams!;
                     expect(params.dir).toEqual("b");
                     expect(params.from).toEqual("start_token0");
                     expect(params.limit).toEqual("30");
-                }).respond(200, () => ({
+                })
+                .respond(200, () => ({
                     start: "start_token0",
                     chunk: [],
                 }));
@@ -1013,13 +990,13 @@ describe("MatrixClient event timelines", function() {
             ]);
         });
 
-        it("should allow you to paginate forwards", function() {
+        it("should allow you to paginate forwards", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" +
-                             encodeURIComponent(EVENTS[0].event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!))
+                .respond(200, function () {
                     return {
                         start: "start_token0",
                         events_before: [],
@@ -1030,13 +1007,15 @@ describe("MatrixClient event timelines", function() {
                     };
                 });
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/messages")
-                .check(function(req) {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/messages")
+                .check(function (req) {
                     const params = req.queryParams!;
                     expect(params.dir).toEqual("f");
                     expect(params.from).toEqual("end_token0");
                     expect(params.limit).toEqual("20");
-                }).respond(200, function() {
+                })
+                .respond(200, function () {
                     return {
                         chunk: [EVENTS[1], EVENTS[2]],
                         end: "end_token1",
@@ -1045,28 +1024,27 @@ describe("MatrixClient event timelines", function() {
 
             let tl: EventTimeline;
             return Promise.all([
-                client.getEventTimeline(timelineSet, EVENTS[0].event_id!,
-                ).then(function(tl0) {
-                    tl = tl0!;
-                    return client.paginateEventTimeline(
-                        tl, { backwards: false, limit: 20 });
-                }).then(function(success) {
-                    expect(success).toBeTruthy();
-                    expect(tl!.getEvents().length).toEqual(3);
-                    expect(tl!.getEvents()[0].event).toEqual(EVENTS[0]);
-                    expect(tl!.getEvents()[1].event).toEqual(EVENTS[1]);
-                    expect(tl!.getEvents()[2].event).toEqual(EVENTS[2]);
-                    expect(tl!.getPaginationToken(EventTimeline.BACKWARDS))
-                        .toEqual("start_token0");
-                    expect(tl!.getPaginationToken(EventTimeline.FORWARDS))
-                        .toEqual("end_token1");
-                }),
+                client
+                    .getEventTimeline(timelineSet, EVENTS[0].event_id!)
+                    .then(function (tl0) {
+                        tl = tl0!;
+                        return client.paginateEventTimeline(tl, { backwards: false, limit: 20 });
+                    })
+                    .then(function (success) {
+                        expect(success).toBeTruthy();
+                        expect(tl!.getEvents().length).toEqual(3);
+                        expect(tl!.getEvents()[0].event).toEqual(EVENTS[0]);
+                        expect(tl!.getEvents()[1].event).toEqual(EVENTS[1]);
+                        expect(tl!.getEvents()[2].event).toEqual(EVENTS[2]);
+                        expect(tl!.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("start_token0");
+                        expect(tl!.getPaginationToken(EventTimeline.FORWARDS)).toEqual("end_token1");
+                    }),
                 httpBackend.flushAllExpected(),
             ]);
         });
     });
 
-    describe("paginateEventTimeline for thread list timeline", function() {
+    describe("paginateEventTimeline for thread list timeline", function () {
         const RANDOM_TOKEN = "7280349c7bee430f91defe2a38a0a08c";
 
         function respondToFilter(): ExpectedHttpRequest {
@@ -1088,21 +1066,26 @@ describe("MatrixClient event timelines", function() {
                 next_batch: RANDOM_TOKEN as string | null,
             },
         ): ExpectedHttpRequest {
-            const request = httpBackend.when("GET", encodeUri("/_matrix/client/v1/rooms/$roomId/threads", {
-                $roomId: roomId,
-            }));
+            const request = httpBackend.when(
+                "GET",
+                encodeUri("/_matrix/client/v1/rooms/$roomId/threads", {
+                    $roomId: roomId,
+                }),
+            );
             request.respond(200, response);
             return request;
         }
 
-        function respondToThread(
-            root: Partial<IEvent>,
-            replies: Partial<IEvent>[],
-        ): ExpectedHttpRequest {
-            const request = httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
-                encodeURIComponent(root.event_id!) + "/" +
-                encodeURIComponent(THREAD_RELATION_TYPE.name) + "?dir=b&limit=1");
-            request.respond(200, function() {
+        function respondToThread(root: Partial<IEvent>, replies: Partial<IEvent>[]): ExpectedHttpRequest {
+            const request = httpBackend.when(
+                "GET",
+                "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
+                    encodeURIComponent(root.event_id!) +
+                    "/" +
+                    encodeURIComponent(THREAD_RELATION_TYPE.name) +
+                    "?dir=b&limit=1",
+            );
+            request.respond(200, function () {
                 return {
                     original_event: root,
                     chunk: [replies],
@@ -1113,10 +1096,13 @@ describe("MatrixClient event timelines", function() {
         }
 
         function respondToContext(event: Partial<IEvent> = THREAD_ROOT): ExpectedHttpRequest {
-            const request = httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/context/$eventId", {
-                $roomId: roomId,
-                $eventId: event.event_id!,
-            }));
+            const request = httpBackend.when(
+                "GET",
+                encodeUri("/_matrix/client/r0/rooms/$roomId/context/$eventId", {
+                    $roomId: roomId,
+                    $eventId: event.event_id!,
+                }),
+            );
             request.respond(200, {
                 end: `${Direction.Forward}${RANDOM_TOKEN}1`,
                 start: `${Direction.Backward}${RANDOM_TOKEN}1`,
@@ -1128,17 +1114,23 @@ describe("MatrixClient event timelines", function() {
             return request;
         }
         function respondToEvent(event: Partial<IEvent> = THREAD_ROOT): ExpectedHttpRequest {
-            const request = httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/event/$eventId", {
-                $roomId: roomId,
-                $eventId: event.event_id!,
-            }));
+            const request = httpBackend.when(
+                "GET",
+                encodeUri("/_matrix/client/r0/rooms/$roomId/event/$eventId", {
+                    $roomId: roomId,
+                    $eventId: event.event_id!,
+                }),
+            );
             request.respond(200, event);
             return request;
         }
         function respondToMessagesRequest(): ExpectedHttpRequest {
-            const request = httpBackend.when("GET", encodeUri("/_matrix/client/r0/rooms/$roomId/messages", {
-                $roomId: roomId,
-            }));
+            const request = httpBackend.when(
+                "GET",
+                encodeUri("/_matrix/client/r0/rooms/$roomId/messages", {
+                    $roomId: roomId,
+                }),
+            );
             request.respond(200, {
                 chunk: [THREAD_ROOT],
                 state: [],
@@ -1148,7 +1140,7 @@ describe("MatrixClient event timelines", function() {
             return request;
         }
 
-        describe("with server compatibility", function() {
+        describe("with server compatibility", function () {
             beforeEach(() => {
                 // @ts-ignore
                 client.clientOpts.experimentalThreadSupport = true;
@@ -1165,15 +1157,17 @@ describe("MatrixClient event timelines", function() {
                 expect(timeline).not.toBeNull();
 
                 respondToThreads();
-                const success = await flushHttp(client.paginateEventTimeline(timeline!, {
-                    backwards: direction === Direction.Backward,
-                }));
+                const success = await flushHttp(
+                    client.paginateEventTimeline(timeline!, {
+                        backwards: direction === Direction.Backward,
+                    }),
+                );
                 expect(success).toBeTruthy();
-                expect(timeline!.getEvents().map(it => it.event)).toEqual([THREAD_ROOT]);
+                expect(timeline!.getEvents().map((it) => it.event)).toEqual([THREAD_ROOT]);
                 expect(timeline!.getPaginationToken(direction)).toEqual(RANDOM_TOKEN);
             }
 
-            it("should allow you to paginate all threads backwards", async function() {
+            it("should allow you to paginate all threads backwards", async function () {
                 const room = client.getRoom(roomId);
                 const timelineSets = await room!.createThreadsTimelineSets();
                 expect(timelineSets).not.toBeNull();
@@ -1182,7 +1176,7 @@ describe("MatrixClient event timelines", function() {
                 await testPagination(myThreads, Direction.Backward);
             });
 
-            it("should allow you to paginate all threads forwards", async function() {
+            it("should allow you to paginate all threads forwards", async function () {
                 const room = client.getRoom(roomId);
                 const timelineSets = await room!.createThreadsTimelineSets();
                 expect(timelineSets).not.toBeNull();
@@ -1192,7 +1186,7 @@ describe("MatrixClient event timelines", function() {
                 await testPagination(myThreads, Direction.Forward);
             });
 
-            it("should allow fetching all threads", async function() {
+            it("should allow fetching all threads", async function () {
                 const room = client.getRoom(roomId)!;
                 const timelineSets = await room!.createThreadsTimelineSets();
                 expect(timelineSets).not.toBeNull();
@@ -1202,7 +1196,7 @@ describe("MatrixClient event timelines", function() {
                 await flushHttp(room.fetchRoomThreads());
             });
 
-            it("should prevent displaying pending events", async function() {
+            it("should prevent displaying pending events", async function () {
                 const room = new Room("room123", client, "john", {
                     pendingEventOrdering: PendingEventOrdering.Detached,
                 });
@@ -1210,7 +1204,10 @@ describe("MatrixClient event timelines", function() {
                 expect(timelineSets).not.toBeNull();
 
                 const event = utils.mkMessage({
-                    room: roomId, user: userId, msg: "a body", event: true,
+                    room: roomId,
+                    user: userId,
+                    msg: "a body",
+                    event: true,
                 });
                 event.status = EventStatus.SENDING;
                 room.addPendingEvent(event, "txn");
@@ -1228,15 +1225,15 @@ describe("MatrixClient event timelines", function() {
                     user: userId,
                     type: "m.room.message",
                     content: {
-                        "body": "thread root",
-                        "msgtype": "m.text",
+                        body: "thread root",
+                        msgtype: "m.text",
                     },
                     unsigned: {
                         "m.relations": {
                             "io.element.thread": {
                                 //"latest_event": undefined,
-                                "count": 1,
-                                "current_user_participated": true,
+                                count: 1,
+                                current_user_participated: true,
                             },
                         },
                     },
@@ -1326,8 +1323,10 @@ describe("MatrixClient event timelines", function() {
                 const [allThreads] = timelineSets!;
                 const timeline = allThreads.getLiveTimeline()!;
                 // Test threads are in chronological order
-                expect(timeline.getEvents().map(it => it.event.event_id))
-                    .toEqual([THREAD_ROOT.event_id, THREAD2_ROOT.event_id]);
+                expect(timeline.getEvents().map((it) => it.event.event_id)).toEqual([
+                    THREAD_ROOT.event_id,
+                    THREAD2_ROOT.event_id,
+                ]);
 
                 // Test adding a second event to the first thread
                 const thread = room.getThread(THREAD_ROOT.event_id!)!;
@@ -1338,12 +1337,14 @@ describe("MatrixClient event timelines", function() {
                 await httpBackend.flushAllExpected();
                 await prom;
                 // Test threads are in chronological order
-                expect(timeline!.getEvents().map(it => it.event.event_id))
-                    .toEqual([THREAD2_ROOT.event_id, THREAD_ROOT.event_id]);
+                expect(timeline!.getEvents().map((it) => it.event.event_id)).toEqual([
+                    THREAD2_ROOT.event_id,
+                    THREAD_ROOT.event_id,
+                ]);
             });
         });
 
-        describe("without server compatibility", function() {
+        describe("without server compatibility", function () {
             beforeEach(() => {
                 // @ts-ignore
                 client.clientOpts.experimentalThreadSupport = true;
@@ -1361,16 +1362,18 @@ describe("MatrixClient event timelines", function() {
                 expect(timeline).not.toBeNull();
 
                 respondToMessagesRequest();
-                const success = await flushHttp(client.paginateEventTimeline(timeline!, {
-                    backwards: direction === Direction.Backward,
-                }));
+                const success = await flushHttp(
+                    client.paginateEventTimeline(timeline!, {
+                        backwards: direction === Direction.Backward,
+                    }),
+                );
 
                 expect(success).toBeTruthy();
-                expect(timeline!.getEvents().map(it => it.event)).toEqual([THREAD_ROOT]);
+                expect(timeline!.getEvents().map((it) => it.event)).toEqual([THREAD_ROOT]);
                 expect(timeline!.getPaginationToken(direction)).toEqual(`${direction}${RANDOM_TOKEN}2`);
             }
 
-            it("should allow you to paginate all threads", async function() {
+            it("should allow you to paginate all threads", async function () {
                 const room = client.getRoom(roomId);
 
                 respondToFilter();
@@ -1388,7 +1391,7 @@ describe("MatrixClient event timelines", function() {
                 await testPagination(myThreads, Direction.Backward);
             });
 
-            it("should allow fetching all threads", async function() {
+            it("should allow fetching all threads", async function () {
                 const room = client.getRoom(roomId)!;
 
                 respondToFilter();
@@ -1422,14 +1425,18 @@ describe("MatrixClient event timelines", function() {
             const [allThreads] = timelineSets!;
 
             respondToThreads().check((request) => {
-                expect(request.queryParams?.filter).toEqual(JSON.stringify({
-                    "lazy_load_members": true,
-                }));
+                expect(request.queryParams?.filter).toEqual(
+                    JSON.stringify({
+                        lazy_load_members: true,
+                    }),
+                );
             });
 
-            await flushHttp(client.paginateEventTimeline(allThreads.getLiveTimeline(), {
-                backwards: true,
-            }));
+            await flushHttp(
+                client.paginateEventTimeline(allThreads.getLiveTimeline(), {
+                    backwards: true,
+                }),
+            );
         });
 
         it("should correctly pass pagination token", async () => {
@@ -1452,35 +1459,36 @@ describe("MatrixClient event timelines", function() {
             });
 
             allThreads.getLiveTimeline().setPaginationToken(RANDOM_TOKEN, Direction.Backward);
-            await flushHttp(client.paginateEventTimeline(allThreads.getLiveTimeline(), {
-                backwards: true,
-            }));
+            await flushHttp(
+                client.paginateEventTimeline(allThreads.getLiveTimeline(), {
+                    backwards: true,
+                }),
+            );
         });
     });
 
-    describe("event timeline for sent events", function() {
+    describe("event timeline for sent events", function () {
         const TXN_ID = "txn1";
         const event = utils.mkMessage({
-            room: roomId, user: userId, msg: "a body",
+            room: roomId,
+            user: userId,
+            msg: "a body",
         });
         event.unsigned = { transaction_id: TXN_ID };
 
-        beforeEach(function() {
+        beforeEach(function () {
             // set up handlers for both the message send, and the
             // /sync
-            httpBackend.when("PUT", "/send/m.room.message/" + TXN_ID)
-                .respond(200, {
-                    event_id: event.event_id,
-                });
+            httpBackend.when("PUT", "/send/m.room.message/" + TXN_ID).respond(200, {
+                event_id: event.event_id,
+            });
             httpBackend.when("GET", "/sync").respond(200, {
                 next_batch: "s_5_4",
                 rooms: {
                     join: {
                         "!foo:bar": {
                             timeline: {
-                                events: [
-                                    withoutRoomId(event),
-                                ],
+                                events: [withoutRoomId(event)],
                                 prev_batch: "f_1_1",
                             },
                         },
@@ -1489,75 +1497,80 @@ describe("MatrixClient event timelines", function() {
             });
         });
 
-        it("should work when /send returns before /sync", function() {
+        it("should work when /send returns before /sync", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0]!;
 
             return Promise.all([
-                client.sendTextMessage(roomId, "a body", TXN_ID).then(function(res) {
-                    expect(res.event_id).toEqual(event.event_id!);
-                    return client.getEventTimeline(timelineSet, event.event_id!);
-                }).then(function(tl) {
-                    // 2 because the initial sync contained an event
-                    expect(tl!.getEvents().length).toEqual(2);
-                    expect(tl!.getEvents()[1].getContent().body).toEqual("a body");
-
-                    // now let the sync complete, and check it again
-                    return Promise.all([
-                        httpBackend.flush("/sync", 1),
-                        utils.syncPromise(client),
-                    ]);
-                }).then(function() {
-                    return client.getEventTimeline(timelineSet, event.event_id!);
-                }).then(function(tl) {
-                    expect(tl!.getEvents().length).toEqual(2);
-                    expect(tl!.getEvents()[1].event).toEqual(event);
-                }),
+                client
+                    .sendTextMessage(roomId, "a body", TXN_ID)
+                    .then(function (res) {
+                        expect(res.event_id).toEqual(event.event_id!);
+                        return client.getEventTimeline(timelineSet, event.event_id!);
+                    })
+                    .then(function (tl) {
+                        // 2 because the initial sync contained an event
+                        expect(tl!.getEvents().length).toEqual(2);
+                        expect(tl!.getEvents()[1].getContent().body).toEqual("a body");
+
+                        // now let the sync complete, and check it again
+                        return Promise.all([httpBackend.flush("/sync", 1), utils.syncPromise(client)]);
+                    })
+                    .then(function () {
+                        return client.getEventTimeline(timelineSet, event.event_id!);
+                    })
+                    .then(function (tl) {
+                        expect(tl!.getEvents().length).toEqual(2);
+                        expect(tl!.getEvents()[1].event).toEqual(event);
+                    }),
 
                 httpBackend.flush("/send/m.room.message/" + TXN_ID, 1),
             ]);
         });
 
-        it("should work when /send returns after /sync", function() {
+        it("should work when /send returns after /sync", function () {
             const room = client.getRoom(roomId)!;
             const timelineSet = room.getTimelineSets()[0];
 
             return Promise.all([
                 // initiate the send, and set up checks to be done when it completes
                 // - but note that it won't complete until after the /sync does, below.
-                client.sendTextMessage(roomId, "a body", TXN_ID).then(function(res) {
-                    logger.log("sendTextMessage completed");
-                    expect(res.event_id).toEqual(event.event_id!);
-                    return client.getEventTimeline(timelineSet, event.event_id!);
-                }).then(function(tl) {
-                    logger.log("getEventTimeline completed (2)");
-                    expect(tl!.getEvents().length).toEqual(2);
-                    expect(tl!.getEvents()[1].getContent().body).toEqual("a body");
-                }),
-
-                Promise.all([
-                    httpBackend.flush("/sync", 1),
-                    utils.syncPromise(client),
-                ]).then(function() {
-                    return client.getEventTimeline(timelineSet, event.event_id!);
-                }).then(function(tl) {
-                    logger.log("getEventTimeline completed (1)");
-                    expect(tl!.getEvents().length).toEqual(2);
-                    expect(tl!.getEvents()[1].event).toEqual(event);
-
-                    // now let the send complete.
-                    return httpBackend.flush("/send/m.room.message/" + TXN_ID, 1);
-                }),
+                client
+                    .sendTextMessage(roomId, "a body", TXN_ID)
+                    .then(function (res) {
+                        logger.log("sendTextMessage completed");
+                        expect(res.event_id).toEqual(event.event_id!);
+                        return client.getEventTimeline(timelineSet, event.event_id!);
+                    })
+                    .then(function (tl) {
+                        logger.log("getEventTimeline completed (2)");
+                        expect(tl!.getEvents().length).toEqual(2);
+                        expect(tl!.getEvents()[1].getContent().body).toEqual("a body");
+                    }),
+
+                Promise.all([httpBackend.flush("/sync", 1), utils.syncPromise(client)])
+                    .then(function () {
+                        return client.getEventTimeline(timelineSet, event.event_id!);
+                    })
+                    .then(function (tl) {
+                        logger.log("getEventTimeline completed (1)");
+                        expect(tl!.getEvents().length).toEqual(2);
+                        expect(tl!.getEvents()[1].event).toEqual(event);
+
+                        // now let the send complete.
+                        return httpBackend.flush("/send/m.room.message/" + TXN_ID, 1);
+                    }),
             ]);
         });
     });
 
-    it("should handle gappy syncs after redactions", function() {
+    it("should handle gappy syncs after redactions", function () {
         // https://github.com/vector-im/vector-web/issues/1389
 
         // a state event, followed by a redaction thereof
         const event = utils.mkMembership({
-            mship: "join", user: otherUserId,
+            mship: "join",
+            user: otherUserId,
         });
         const redaction = utils.mkEvent({
             type: "m.room.redaction",
@@ -1572,10 +1585,7 @@ describe("MatrixClient event timelines", function() {
                 join: {
                     [roomId]: {
                         timeline: {
-                            events: [
-                                event,
-                                redaction,
-                            ],
+                            events: [event, redaction],
                             limited: false,
                         },
                     },
@@ -1584,44 +1594,41 @@ describe("MatrixClient event timelines", function() {
         };
         httpBackend.when("GET", "/sync").respond(200, syncData);
 
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            utils.syncPromise(client),
-        ]).then(function() {
-            const room = client.getRoom(roomId)!;
-            const tl = room.getLiveTimeline()!;
-            expect(tl!.getEvents().length).toEqual(3);
-            expect(tl!.getEvents()[1].isRedacted()).toBe(true);
-
-            const sync2 = {
-                next_batch: "batch2",
-                rooms: {
-                    join: {
-                        [roomId]: {
-                            timeline: {
-                                events: [
-                                    utils.mkMessage({
-                                        user: otherUserId, msg: "world",
-                                    }),
-                                ],
-                                limited: true,
-                                prev_batch: "newerTok",
+        return Promise.all([httpBackend.flushAllExpected(), utils.syncPromise(client)])
+            .then(function () {
+                const room = client.getRoom(roomId)!;
+                const tl = room.getLiveTimeline()!;
+                expect(tl!.getEvents().length).toEqual(3);
+                expect(tl!.getEvents()[1].isRedacted()).toBe(true);
+
+                const sync2 = {
+                    next_batch: "batch2",
+                    rooms: {
+                        join: {
+                            [roomId]: {
+                                timeline: {
+                                    events: [
+                                        utils.mkMessage({
+                                            user: otherUserId,
+                                            msg: "world",
+                                        }),
+                                    ],
+                                    limited: true,
+                                    prev_batch: "newerTok",
+                                },
                             },
                         },
                     },
-                },
-            };
-            httpBackend.when("GET", "/sync").respond(200, sync2);
+                };
+                httpBackend.when("GET", "/sync").respond(200, sync2);
 
-            return Promise.all([
-                httpBackend.flushAllExpected(),
-                utils.syncPromise(client),
-            ]);
-        }).then(function() {
-            const room = client.getRoom(roomId)!;
-            const tl = room.getLiveTimeline()!;
-            expect(tl.getEvents().length).toEqual(1);
-        });
+                return Promise.all([httpBackend.flushAllExpected(), utils.syncPromise(client)]);
+            })
+            .then(function () {
+                const room = client.getRoom(roomId)!;
+                const tl = room.getLiveTimeline()!;
+                expect(tl.getEvents().length).toEqual(1);
+            });
     });
 
     describe("should re-insert room IDs for bundled thread relation events", () => {
@@ -1632,9 +1639,7 @@ describe("MatrixClient event timelines", function() {
                     join: {
                         [roomId]: {
                             timeline: {
-                                events: [
-                                    SYNC_THREAD_ROOT,
-                                ],
+                                events: [SYNC_THREAD_ROOT],
                                 prev_batch: "f_1_1",
                             },
                         },
@@ -1655,7 +1660,8 @@ describe("MatrixClient event timelines", function() {
                 }
             };
 
-            httpBackend.when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_ROOT.event_id!))
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_ROOT.event_id!))
                 .respond(200, {
                     start: "start_token",
                     events_before: [],
@@ -1664,34 +1670,46 @@ describe("MatrixClient event timelines", function() {
                     state: [],
                     end: "end_token",
                 });
-            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" +
-                encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return THREAD_ROOT;
                 });
-            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" +
-                encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return THREAD_ROOT;
                 });
-            httpBackend.when("GET", "/rooms/!foo%3Abar/event/" +
-                encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, function() {
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
                     return THREAD_ROOT;
                 });
-            httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
-                encodeURIComponent(THREAD_ROOT.event_id!) + "/" +
-                encodeURIComponent(THREAD_RELATION_TYPE.name) + buildParams(Direction.Backward, "start_token"))
-                .respond(200, function() {
+            httpBackend
+                .when(
+                    "GET",
+                    "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
+                        encodeURIComponent(THREAD_ROOT.event_id!) +
+                        "/" +
+                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
+                        buildParams(Direction.Backward, "start_token"),
+                )
+                .respond(200, function () {
                     return {
                         original_event: THREAD_ROOT,
                         chunk: [],
                     };
                 });
-            httpBackend.when("GET", "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
-                encodeURIComponent(THREAD_ROOT.event_id!) + "/" +
-                encodeURIComponent(THREAD_RELATION_TYPE.name) + buildParams(Direction.Forward, "end_token"))
-                .respond(200, function() {
+            httpBackend
+                .when(
+                    "GET",
+                    "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
+                        encodeURIComponent(THREAD_ROOT.event_id!) +
+                        "/" +
+                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
+                        buildParams(Direction.Forward, "end_token"),
+                )
+                .respond(200, function () {
                     return {
                         original_event: THREAD_ROOT,
                         chunk: [THREAD_REPLY],
@@ -1705,9 +1723,7 @@ describe("MatrixClient event timelines", function() {
                     join: {
                         [roomId]: {
                             timeline: {
-                                events: [
-                                    SYNC_THREAD_REPLY,
-                                ],
+                                events: [SYNC_THREAD_REPLY],
                                 prev_batch: "f_1_2",
                             },
                         },
diff --git a/spec/integ/matrix-client-methods.spec.ts b/spec/integ/matrix-client-methods.spec.ts
index c585fb3c5fa..c83ada2d597 100644
--- a/spec/integ/matrix-client-methods.spec.ts
+++ b/spec/integ/matrix-client-methods.spec.ts
@@ -25,7 +25,7 @@ import { IFilterDefinition } from "../../src/filter";
 import { ISearchResults } from "../../src/@types/search";
 import { IStore } from "../../src/store";
 
-describe("MatrixClient", function() {
+describe("MatrixClient", function () {
     const userId = "@alice:localhost";
     const accessToken = "aseukfgwef";
     const idServerDomain = "identity.localhost"; // not a real server
@@ -35,9 +35,9 @@ describe("MatrixClient", function() {
     let store: MemoryStore | undefined;
 
     const defaultClientOpts: IStoredClientOpts = {
-        canResetEntireTimeline: roomId => false,
+        canResetEntireTimeline: (roomId) => false,
         experimentalThreadSupport: false,
-        crypto: {} as unknown as IStoredClientOpts['crypto'],
+        crypto: {} as unknown as IStoredClientOpts["crypto"],
     };
     const setupTests = (): [MatrixClient, HttpBackend, MemoryStore] => {
         const store = new MemoryStore();
@@ -53,36 +53,37 @@ describe("MatrixClient", function() {
         return [testClient.client, testClient.httpBackend, store];
     };
 
-    beforeEach(function() {
+    beforeEach(function () {
         [client, httpBackend, store] = setupTests();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         httpBackend!.verifyNoOutstandingExpectation();
         return httpBackend!.stop();
     });
 
-    describe("uploadContent", function() {
-        const buf = Buffer.from('hello world');
+    describe("uploadContent", function () {
+        const buf = Buffer.from("hello world");
         const file = buf;
         const opts = {
             type: "text/plain",
             name: "hi.txt",
         };
 
-        it("should upload the file", function() {
-            httpBackend!.when(
-                "POST", "/_matrix/media/r0/upload",
-            ).check(function(req) {
-                expect(req.rawData).toEqual(buf);
-                expect(req.queryParams?.filename).toEqual("hi.txt");
-                expect(req.headers["Authorization"]).toBe("Bearer " + accessToken);
-                expect(req.headers["Content-Type"]).toEqual("text/plain");
-                // @ts-ignore private property
-                expect(req.opts.json).toBeFalsy();
-                // @ts-ignore private property
-                expect(req.opts.timeout).toBe(undefined);
-            }).respond(200, '{"content_uri": "content"}', true);
+        it("should upload the file", function () {
+            httpBackend!
+                .when("POST", "/_matrix/media/r0/upload")
+                .check(function (req) {
+                    expect(req.rawData).toEqual(buf);
+                    expect(req.queryParams?.filename).toEqual("hi.txt");
+                    expect(req.headers["Authorization"]).toBe("Bearer " + accessToken);
+                    expect(req.headers["Content-Type"]).toEqual("text/plain");
+                    // @ts-ignore private property
+                    expect(req.opts.json).toBeFalsy();
+                    // @ts-ignore private property
+                    expect(req.opts.timeout).toBe(undefined);
+                })
+                .respond(200, '{"content_uri": "content"}', true);
 
             const prom = client!.uploadContent(file, opts);
 
@@ -93,38 +94,42 @@ describe("MatrixClient", function() {
             expect(uploads[0].promise).toBe(prom);
             expect(uploads[0].loaded).toEqual(0);
 
-            const prom2 = prom.then(function(response) {
+            const prom2 = prom.then(function (response) {
                 expect(response.content_uri).toEqual("content");
 
                 const uploads = client!.getCurrentUploads();
                 expect(uploads.length).toEqual(0);
             });
 
-            httpBackend!.flush('');
+            httpBackend!.flush("");
             return prom2;
         });
 
-        it("should parse errors into a MatrixError", function() {
-            httpBackend!.when(
-                "POST", "/_matrix/media/r0/upload",
-            ).check(function(req) {
-                expect(req.rawData).toEqual(buf);
-                // @ts-ignore private property
-                expect(req.opts.json).toBeFalsy();
-            }).respond(400, {
-                "errcode": "M_SNAFU",
-                "error": "broken",
-            });
+        it("should parse errors into a MatrixError", function () {
+            httpBackend!
+                .when("POST", "/_matrix/media/r0/upload")
+                .check(function (req) {
+                    expect(req.rawData).toEqual(buf);
+                    // @ts-ignore private property
+                    expect(req.opts.json).toBeFalsy();
+                })
+                .respond(400, {
+                    errcode: "M_SNAFU",
+                    error: "broken",
+                });
 
-            const prom = client!.uploadContent(file, opts).then(function(response) {
-                throw Error("request not failed");
-            }, function(error) {
-                expect(error.httpStatus).toEqual(400);
-                expect(error.errcode).toEqual("M_SNAFU");
-                expect(error.message).toEqual("MatrixError: [400] broken");
-            });
+            const prom = client!.uploadContent(file, opts).then(
+                function (response) {
+                    throw Error("request not failed");
+                },
+                function (error) {
+                    expect(error.httpStatus).toEqual(400);
+                    expect(error.errcode).toEqual("M_SNAFU");
+                    expect(error.message).toEqual("MatrixError: [400] broken");
+                },
+            );
 
-            httpBackend!.flush('');
+            httpBackend!.flush("");
             return prom;
         });
 
@@ -143,17 +148,21 @@ describe("MatrixClient", function() {
         });
     });
 
-    describe("joinRoom", function() {
-        it("should no-op if you've already joined a room", function() {
+    describe("joinRoom", function () {
+        it("should no-op if you've already joined a room", function () {
             const roomId = "!foo:bar";
             const room = new Room(roomId, client!, userId);
-            client!.fetchRoomEvent = () => Promise.resolve({
-                type: 'test',
-                content: {},
-            });
+            client!.fetchRoomEvent = () =>
+                Promise.resolve({
+                    type: "test",
+                    content: {},
+                });
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userId, room: roomId, mship: "join", event: true,
+                    user: userId,
+                    room: roomId,
+                    mship: "join",
+                    event: true,
                 }),
             ]);
             httpBackend!.verifyNoOutstandingRequests();
@@ -173,12 +182,18 @@ describe("MatrixClient", function() {
                 signatures: {},
             };
 
-            httpBackend!.when("POST", inviteSignUrl).check(request => {
-                expect(request.queryParams?.mxid).toEqual(client!.getUserId());
-            }).respond(200, signature);
-            httpBackend!.when("POST", "/join/" + encodeURIComponent(roomId)).check(request => {
-                expect(request.data.third_party_signed).toEqual(signature);
-            }).respond(200, { room_id: roomId });
+            httpBackend!
+                .when("POST", inviteSignUrl)
+                .check((request) => {
+                    expect(request.queryParams?.mxid).toEqual(client!.getUserId());
+                })
+                .respond(200, signature);
+            httpBackend!
+                .when("POST", "/join/" + encodeURIComponent(roomId))
+                .check((request) => {
+                    expect(request.data.third_party_signed).toEqual(signature);
+                })
+                .respond(200, { room_id: roomId });
 
             const prom = client!.joinRoom(roomId, {
                 inviteSignUrl,
@@ -189,110 +204,111 @@ describe("MatrixClient", function() {
         });
     });
 
-    describe("getFilter", function() {
+    describe("getFilter", function () {
         const filterId = "f1lt3r1d";
 
-        it("should return a filter from the store if allowCached", function(done) {
+        it("should return a filter from the store if allowCached", function (done) {
             const filter = Filter.fromJson(userId, filterId, {
                 event_format: "client",
             });
             store!.storeFilter(filter);
-            client!.getFilter(userId, filterId, true).then(function(gotFilter) {
+            client!.getFilter(userId, filterId, true).then(function (gotFilter) {
                 expect(gotFilter).toEqual(filter);
                 done();
             });
             httpBackend!.verifyNoOutstandingRequests();
         });
 
-        it("should do an HTTP request if !allowCached even if one exists",
-            function(done) {
-                const httpFilterDefinition = {
-                    event_format: "federation",
-                };
-
-                httpBackend!.when(
-                    "GET", "/user/" + encodeURIComponent(userId) + "/filter/" + filterId,
-                ).respond(200, httpFilterDefinition);
+        it("should do an HTTP request if !allowCached even if one exists", function (done) {
+            const httpFilterDefinition = {
+                event_format: "federation",
+            };
 
-                const storeFilter = Filter.fromJson(userId, filterId, {
-                    event_format: "client",
-                });
-                store!.storeFilter(storeFilter);
-                client!.getFilter(userId, filterId, false).then(function(gotFilter) {
-                    expect(gotFilter.getDefinition()).toEqual(httpFilterDefinition);
-                    done();
-                });
+            httpBackend!
+                .when("GET", "/user/" + encodeURIComponent(userId) + "/filter/" + filterId)
+                .respond(200, httpFilterDefinition);
 
-                httpBackend!.flush('');
+            const storeFilter = Filter.fromJson(userId, filterId, {
+                event_format: "client",
+            });
+            store!.storeFilter(storeFilter);
+            client!.getFilter(userId, filterId, false).then(function (gotFilter) {
+                expect(gotFilter.getDefinition()).toEqual(httpFilterDefinition);
+                done();
             });
 
-        it("should do an HTTP request if nothing is in the cache and then store it",
-            function(done) {
-                const httpFilterDefinition = {
-                    event_format: "federation",
-                };
-                expect(store!.getFilter(userId, filterId)).toBe(null);
-
-                httpBackend!.when(
-                    "GET", "/user/" + encodeURIComponent(userId) + "/filter/" + filterId,
-                ).respond(200, httpFilterDefinition);
-                client!.getFilter(userId, filterId, true).then(function(gotFilter) {
-                    expect(gotFilter.getDefinition()).toEqual(httpFilterDefinition);
-                    expect(store!.getFilter(userId, filterId)).toBeTruthy();
-                    done();
-                });
+            httpBackend!.flush("");
+        });
+
+        it("should do an HTTP request if nothing is in the cache and then store it", function (done) {
+            const httpFilterDefinition = {
+                event_format: "federation",
+            };
+            expect(store!.getFilter(userId, filterId)).toBe(null);
 
-                httpBackend!.flush('');
+            httpBackend!
+                .when("GET", "/user/" + encodeURIComponent(userId) + "/filter/" + filterId)
+                .respond(200, httpFilterDefinition);
+            client!.getFilter(userId, filterId, true).then(function (gotFilter) {
+                expect(gotFilter.getDefinition()).toEqual(httpFilterDefinition);
+                expect(store!.getFilter(userId, filterId)).toBeTruthy();
+                done();
             });
+
+            httpBackend!.flush("");
+        });
     });
 
-    describe("createFilter", function() {
+    describe("createFilter", function () {
         const filterId = "f1llllllerid";
 
-        it("should do an HTTP request and then store the filter", function(done) {
+        it("should do an HTTP request and then store the filter", function (done) {
             expect(store!.getFilter(userId, filterId)).toBe(null);
 
             const filterDefinition = {
-                event_format: "client" as IFilterDefinition['event_format'],
+                event_format: "client" as IFilterDefinition["event_format"],
             };
 
-            httpBackend!.when(
-                "POST", "/user/" + encodeURIComponent(userId) + "/filter",
-            ).check(function(req) {
-                expect(req.data).toEqual(filterDefinition);
-            }).respond(200, {
-                filter_id: filterId,
-            });
+            httpBackend!
+                .when("POST", "/user/" + encodeURIComponent(userId) + "/filter")
+                .check(function (req) {
+                    expect(req.data).toEqual(filterDefinition);
+                })
+                .respond(200, {
+                    filter_id: filterId,
+                });
 
-            client!.createFilter(filterDefinition).then(function(gotFilter) {
+            client!.createFilter(filterDefinition).then(function (gotFilter) {
                 expect(gotFilter.getDefinition()).toEqual(filterDefinition);
                 expect(store!.getFilter(userId, filterId)).toEqual(gotFilter);
                 done();
             });
 
-            httpBackend!.flush('');
+            httpBackend!.flush("");
         });
     });
 
-    describe("searching", function() {
-        it("searchMessageText should perform a /search for room_events", function() {
+    describe("searching", function () {
+        it("searchMessageText should perform a /search for room_events", function () {
             const response = {
                 search_categories: {
                     room_events: {
                         count: 24,
-                        results: [{
-                            rank: 0.1,
-                            result: {
-                                event_id: "$flibble:localhost",
-                                type: "m.room.message",
-                                user_id: "@alice:localhost",
-                                room_id: "!feuiwhf:localhost",
-                                content: {
-                                    body: "a result",
-                                    msgtype: "m.text",
+                        results: [
+                            {
+                                rank: 0.1,
+                                result: {
+                                    event_id: "$flibble:localhost",
+                                    type: "m.room.message",
+                                    user_id: "@alice:localhost",
+                                    room_id: "!feuiwhf:localhost",
+                                    content: {
+                                        body: "a result",
+                                        msgtype: "m.text",
+                                    },
                                 },
                             },
-                        }],
+                        ],
                     },
                 },
             };
@@ -300,17 +316,20 @@ describe("MatrixClient", function() {
             client!.searchMessageText({
                 query: "monkeys",
             });
-            httpBackend!.when("POST", "/search").check(function(req) {
-                expect(req.data).toEqual({
-                    search_categories: {
-                        room_events: {
-                            search_term: "monkeys",
+            httpBackend!
+                .when("POST", "/search")
+                .check(function (req) {
+                    expect(req.data).toEqual({
+                        search_categories: {
+                            room_events: {
+                                search_term: "monkeys",
+                            },
                         },
-                    },
-                });
-            }).respond(200, response);
+                    });
+                })
+                .respond(200, response);
 
-            return httpBackend!.flush('');
+            return httpBackend!.flush("");
         });
 
         describe("should filter out context from different timelines (threads)", () => {
@@ -320,52 +339,58 @@ describe("MatrixClient", function() {
                         room_events: {
                             count: 24,
                             highlights: [],
-                            results: [{
-                                rank: 0.1,
-                                result: {
-                                    event_id: "$flibble:localhost",
-                                    type: "m.room.message",
-                                    sender: '@test:locahost',
-                                    origin_server_ts: 123,
-                                    user_id: "@alice:localhost",
-                                    room_id: "!feuiwhf:localhost",
-                                    content: {
-                                        body: "main timeline",
-                                        msgtype: "m.text",
-                                    },
-                                },
-                                context: {
-                                    profile_info: {},
-                                    events_after: [{
-                                        event_id: "$ev-after:server",
+                            results: [
+                                {
+                                    rank: 0.1,
+                                    result: {
+                                        event_id: "$flibble:localhost",
                                         type: "m.room.message",
-                                        sender: '@test:locahost',
+                                        sender: "@test:locahost",
                                         origin_server_ts: 123,
                                         user_id: "@alice:localhost",
                                         room_id: "!feuiwhf:localhost",
                                         content: {
-                                            "body": "thread reply",
-                                            "msgtype": "m.text",
-                                            "m.relates_to": {
-                                                "event_id": "$some-thread:server",
-                                                "rel_type": THREAD_RELATION_TYPE.name,
-                                            },
-                                        },
-                                    }],
-                                    events_before: [{
-                                        event_id: "$ev-before:server",
-                                        type: "m.room.message",
-                                        sender: '@test:locahost',
-                                        origin_server_ts: 123,
-                                        user_id: "@alice:localhost",
-                                        room_id: "!feuiwhf:localhost",
-                                        content: {
-                                            body: "main timeline again",
+                                            body: "main timeline",
                                             msgtype: "m.text",
                                         },
-                                    }],
+                                    },
+                                    context: {
+                                        profile_info: {},
+                                        events_after: [
+                                            {
+                                                event_id: "$ev-after:server",
+                                                type: "m.room.message",
+                                                sender: "@test:locahost",
+                                                origin_server_ts: 123,
+                                                user_id: "@alice:localhost",
+                                                room_id: "!feuiwhf:localhost",
+                                                content: {
+                                                    "body": "thread reply",
+                                                    "msgtype": "m.text",
+                                                    "m.relates_to": {
+                                                        event_id: "$some-thread:server",
+                                                        rel_type: THREAD_RELATION_TYPE.name,
+                                                    },
+                                                },
+                                            },
+                                        ],
+                                        events_before: [
+                                            {
+                                                event_id: "$ev-before:server",
+                                                type: "m.room.message",
+                                                sender: "@test:locahost",
+                                                origin_server_ts: 123,
+                                                user_id: "@alice:localhost",
+                                                room_id: "!feuiwhf:localhost",
+                                                content: {
+                                                    body: "main timeline again",
+                                                    msgtype: "m.text",
+                                                },
+                                            },
+                                        ],
+                                    },
                                 },
-                            }],
+                            ],
                         },
                     },
                 };
@@ -378,9 +403,7 @@ describe("MatrixClient", function() {
 
                 expect(data.results).toHaveLength(1);
                 expect(data.results[0].context.getTimeline()).toHaveLength(2);
-                expect(
-                    data.results[0].context.getTimeline().find(e => e.getId() === "$ev-after:server"),
-                ).toBeFalsy();
+                expect(data.results[0].context.getTimeline().find((e) => e.getId() === "$ev-after:server")).toBeFalsy();
             });
 
             it("filters out thread replies from threads other than the thread the result replied to", () => {
@@ -389,45 +412,49 @@ describe("MatrixClient", function() {
                         room_events: {
                             count: 24,
                             highlights: [],
-                            results: [{
-                                rank: 0.1,
-                                result: {
-                                    event_id: "$flibble:localhost",
-                                    type: "m.room.message",
-                                    sender: '@test:locahost',
-                                    origin_server_ts: 123,
-                                    user_id: "@alice:localhost",
-                                    room_id: "!feuiwhf:localhost",
-                                    content: {
-                                        "body": "thread 1 reply 1",
-                                        "msgtype": "m.text",
-                                        "m.relates_to": {
-                                            "event_id": "$thread1:server",
-                                            "rel_type": THREAD_RELATION_TYPE.name,
-                                        },
-                                    },
-                                },
-                                context: {
-                                    profile_info: {},
-                                    events_after: [{
-                                        event_id: "$ev-after:server",
+                            results: [
+                                {
+                                    rank: 0.1,
+                                    result: {
+                                        event_id: "$flibble:localhost",
                                         type: "m.room.message",
-                                        sender: '@test:locahost',
+                                        sender: "@test:locahost",
                                         origin_server_ts: 123,
                                         user_id: "@alice:localhost",
                                         room_id: "!feuiwhf:localhost",
                                         content: {
-                                            "body": "thread 2 reply 2",
+                                            "body": "thread 1 reply 1",
                                             "msgtype": "m.text",
                                             "m.relates_to": {
-                                                "event_id": "$thread2:server",
-                                                "rel_type": THREAD_RELATION_TYPE.name,
+                                                event_id: "$thread1:server",
+                                                rel_type: THREAD_RELATION_TYPE.name,
                                             },
                                         },
-                                    }],
-                                    events_before: [],
+                                    },
+                                    context: {
+                                        profile_info: {},
+                                        events_after: [
+                                            {
+                                                event_id: "$ev-after:server",
+                                                type: "m.room.message",
+                                                sender: "@test:locahost",
+                                                origin_server_ts: 123,
+                                                user_id: "@alice:localhost",
+                                                room_id: "!feuiwhf:localhost",
+                                                content: {
+                                                    "body": "thread 2 reply 2",
+                                                    "msgtype": "m.text",
+                                                    "m.relates_to": {
+                                                        event_id: "$thread2:server",
+                                                        rel_type: THREAD_RELATION_TYPE.name,
+                                                    },
+                                                },
+                                            },
+                                        ],
+                                        events_before: [],
+                                    },
                                 },
-                            }],
+                            ],
                         },
                     },
                 };
@@ -441,7 +468,7 @@ describe("MatrixClient", function() {
                 expect(data.results).toHaveLength(1);
                 expect(data.results[0].context.getTimeline()).toHaveLength(1);
                 expect(
-                    data.results[0].context.getTimeline().find(e => e.getId() === "$flibble:localhost"),
+                    data.results[0].context.getTimeline().find((e) => e.getId() === "$flibble:localhost"),
                 ).toBeTruthy();
             });
 
@@ -451,41 +478,45 @@ describe("MatrixClient", function() {
                         room_events: {
                             count: 24,
                             highlights: [],
-                            results: [{
-                                rank: 0.1,
-                                result: {
-                                    event_id: "$flibble:localhost",
-                                    sender: '@test:locahost',
-                                    origin_server_ts: 123,
-                                    type: "m.room.message",
-                                    user_id: "@alice:localhost",
-                                    room_id: "!feuiwhf:localhost",
-                                    content: {
-                                        "body": "thread 1 reply 1",
-                                        "msgtype": "m.text",
-                                        "m.relates_to": {
-                                            "event_id": "$thread1:server",
-                                            "rel_type": THREAD_RELATION_TYPE.name,
-                                        },
-                                    },
-                                },
-                                context: {
-                                    events_after: [{
-                                        event_id: "$ev-after:server",
-                                        sender: '@test:locahost',
+                            results: [
+                                {
+                                    rank: 0.1,
+                                    result: {
+                                        event_id: "$flibble:localhost",
+                                        sender: "@test:locahost",
                                         origin_server_ts: 123,
                                         type: "m.room.message",
                                         user_id: "@alice:localhost",
                                         room_id: "!feuiwhf:localhost",
                                         content: {
-                                            "body": "main timeline",
+                                            "body": "thread 1 reply 1",
                                             "msgtype": "m.text",
+                                            "m.relates_to": {
+                                                event_id: "$thread1:server",
+                                                rel_type: THREAD_RELATION_TYPE.name,
+                                            },
                                         },
-                                    }],
-                                    events_before: [],
-                                    profile_info: {},
+                                    },
+                                    context: {
+                                        events_after: [
+                                            {
+                                                event_id: "$ev-after:server",
+                                                sender: "@test:locahost",
+                                                origin_server_ts: 123,
+                                                type: "m.room.message",
+                                                user_id: "@alice:localhost",
+                                                room_id: "!feuiwhf:localhost",
+                                                content: {
+                                                    body: "main timeline",
+                                                    msgtype: "m.text",
+                                                },
+                                            },
+                                        ],
+                                        events_before: [],
+                                        profile_info: {},
+                                    },
                                 },
-                            }],
+                            ],
                         },
                     },
                 };
@@ -499,31 +530,28 @@ describe("MatrixClient", function() {
                 expect(data.results).toHaveLength(1);
                 expect(data.results[0].context.getTimeline()).toHaveLength(1);
                 expect(
-                    data.results[0].context.getTimeline().find(e => e.getId() === "$flibble:localhost"),
+                    data.results[0].context.getTimeline().find((e) => e.getId() === "$flibble:localhost"),
                 ).toBeTruthy();
             });
         });
     });
 
-    describe("downloadKeys", function() {
+    describe("downloadKeys", function () {
         if (!CRYPTO_ENABLED) {
             return;
         }
 
-        beforeEach(function() {
+        beforeEach(function () {
             // running initCrypto should trigger a key upload
             httpBackend!.when("POST", "/keys/upload").respond(200, {});
-            return Promise.all([
-                client!.initCrypto(),
-                httpBackend!.flush("/keys/upload", 1),
-            ]);
+            return Promise.all([client!.initCrypto(), httpBackend!.flush("/keys/upload", 1)]);
         });
 
         afterEach(() => {
             client!.stopClient();
         });
 
-        it("should do an HTTP request and then store the keys", function() {
+        it("should do an HTTP request and then store the keys", function () {
             const ed25519key = "7wG2lzAqbjcyEkOP7O4gU7ItYcn+chKzh5sT/5r2l78";
             // ed25519key = client!.getDeviceEd25519Key();
             const borisKeys = {
@@ -538,7 +566,7 @@ describe("MatrixClient", function() {
                                 "JVwLdP032mg5QsKt/pBDUGtggBcnk43n3nBWlA88WAw",
                         },
                     },
-                    unsigned: { "abc": "def" },
+                    unsigned: { abc: "def" },
                     user_id: "boris",
                 },
             };
@@ -554,7 +582,7 @@ describe("MatrixClient", function() {
                                 "EkrK9/XVN8jl4h7thGuRITQ01siBQnNmMK9t45QfcCQ",
                         },
                     },
-                    unsigned: { "ghi": "def" },
+                    unsigned: { ghi: "def" },
                     user_id: "chaz",
                 },
             };
@@ -573,69 +601,75 @@ describe("MatrixClient", function() {
             logger.log("chaz:", sign(chazKeys.dev2));
             */
 
-            httpBackend!.when("POST", "/keys/query").check(function(req) {
-                expect(req.data).toEqual({ device_keys: {
-                    'boris': [],
-                    'chaz': [],
-                } });
-            }).respond(200, {
-                device_keys: {
-                    boris: borisKeys,
-                    chaz: chazKeys,
-                },
-            });
+            httpBackend!
+                .when("POST", "/keys/query")
+                .check(function (req) {
+                    expect(req.data).toEqual({
+                        device_keys: {
+                            boris: [],
+                            chaz: [],
+                        },
+                    });
+                })
+                .respond(200, {
+                    device_keys: {
+                        boris: borisKeys,
+                        chaz: chazKeys,
+                    },
+                });
 
-            const prom = client!.downloadKeys(["boris", "chaz"]).then(function(res) {
+            const prom = client!.downloadKeys(["boris", "chaz"]).then(function (res) {
                 assertObjectContains(res.boris.dev1, {
                     verified: 0, // DeviceVerification.UNVERIFIED
                     keys: { "ed25519:dev1": ed25519key },
                     algorithms: ["1"],
-                    unsigned: { "abc": "def" },
+                    unsigned: { abc: "def" },
                 });
 
                 assertObjectContains(res.chaz.dev2, {
                     verified: 0, // DeviceVerification.UNVERIFIED
                     keys: { "ed25519:dev2": ed25519key },
                     algorithms: ["2"],
-                    unsigned: { "ghi": "def" },
+                    unsigned: { ghi: "def" },
                 });
             });
 
-            httpBackend!.flush('');
+            httpBackend!.flush("");
             return prom;
         });
     });
 
-    describe("deleteDevice", function() {
+    describe("deleteDevice", function () {
         const auth = { identifier: 1 };
-        it("should pass through an auth dict", function() {
-            httpBackend!.when(
-                "DELETE", "/_matrix/client/r0/devices/my_device",
-            ).check(function(req) {
-                expect(req.data).toEqual({ auth: auth });
-            }).respond(200);
+        it("should pass through an auth dict", function () {
+            httpBackend!
+                .when("DELETE", "/_matrix/client/r0/devices/my_device")
+                .check(function (req) {
+                    expect(req.data).toEqual({ auth: auth });
+                })
+                .respond(200);
 
             const prom = client!.deleteDevice("my_device", auth);
 
-            httpBackend!.flush('');
+            httpBackend!.flush("");
             return prom;
         });
     });
 
-    describe("partitionThreadedEvents", function() {
+    describe("partitionThreadedEvents", function () {
         let room: Room;
         beforeEach(() => {
             room = new Room("!STrMRsukXHtqQdSeHa:matrix.org", client!, userId);
         });
 
-        it("returns empty arrays when given an empty arrays", function() {
+        it("returns empty arrays when given an empty arrays", function () {
             const events: MatrixEvent[] = [];
             const [timeline, threaded] = room.partitionThreadedEvents(events);
             expect(timeline).toEqual([]);
             expect(threaded).toEqual([]);
         });
 
-        it("copies pre-thread in-timeline vote events onto both timelines", function() {
+        it("copies pre-thread in-timeline vote events onto both timelines", function () {
             // @ts-ignore setting private property
             client!.clientOpts = {
                 ...defaultClientOpts,
@@ -646,11 +680,7 @@ describe("MatrixClient", function() {
             const eventPollStartThreadRoot = buildEventPollStartThreadRoot();
             const eventMessageInThread = buildEventMessageInThread(eventPollStartThreadRoot);
 
-            const events = [
-                eventPollStartThreadRoot,
-                eventMessageInThread,
-                eventPollResponseReference,
-            ];
+            const events = [eventPollStartThreadRoot, eventMessageInThread, eventPollResponseReference];
             // Vote has no threadId yet
             // @ts-ignore private property
             expect(eventPollResponseReference.threadId).toBeFalsy();
@@ -664,18 +694,13 @@ describe("MatrixClient", function() {
             ]);
 
             // The vote event has been copied into the thread
-            const eventRefWithThreadId = withThreadId(
-                eventPollResponseReference, eventPollStartThreadRoot.getId()!);
+            const eventRefWithThreadId = withThreadId(eventPollResponseReference, eventPollStartThreadRoot.getId()!);
             expect(eventRefWithThreadId.threadRootId).toBeTruthy();
 
-            expect(threaded).toEqual([
-                eventPollStartThreadRoot,
-                eventMessageInThread,
-                eventRefWithThreadId,
-            ]);
+            expect(threaded).toEqual([eventPollStartThreadRoot, eventMessageInThread, eventRefWithThreadId]);
         });
 
-        it("copies pre-thread in-timeline reactions onto both timelines", function() {
+        it("copies pre-thread in-timeline reactions onto both timelines", function () {
             // @ts-ignore setting private property
             client!.clientOpts = {
                 ...defaultClientOpts,
@@ -686,18 +711,11 @@ describe("MatrixClient", function() {
             const eventMessageInThread = buildEventMessageInThread(eventPollStartThreadRoot);
             const eventReaction = buildEventReaction(eventPollStartThreadRoot);
 
-            const events = [
-                eventPollStartThreadRoot,
-                eventMessageInThread,
-                eventReaction,
-            ];
+            const events = [eventPollStartThreadRoot, eventMessageInThread, eventReaction];
 
             const [timeline, threaded] = room.partitionThreadedEvents(events);
 
-            expect(timeline).toEqual([
-                eventPollStartThreadRoot,
-                eventReaction,
-            ]);
+            expect(timeline).toEqual([eventPollStartThreadRoot, eventReaction]);
 
             expect(threaded).toEqual([
                 eventPollStartThreadRoot,
@@ -706,7 +724,7 @@ describe("MatrixClient", function() {
             ]);
         });
 
-        it("copies post-thread in-timeline vote events onto both timelines", function() {
+        it("copies post-thread in-timeline vote events onto both timelines", function () {
             // @ts-ignore setting private property
             client!.clientOpts = {
                 ...defaultClientOpts,
@@ -717,18 +735,11 @@ describe("MatrixClient", function() {
             const eventPollStartThreadRoot = buildEventPollStartThreadRoot();
             const eventMessageInThread = buildEventMessageInThread(eventPollStartThreadRoot);
 
-            const events = [
-                eventPollStartThreadRoot,
-                eventPollResponseReference,
-                eventMessageInThread,
-            ];
+            const events = [eventPollStartThreadRoot, eventPollResponseReference, eventMessageInThread];
 
             const [timeline, threaded] = room.partitionThreadedEvents(events);
 
-            expect(timeline).toEqual([
-                eventPollStartThreadRoot,
-                eventPollResponseReference,
-            ]);
+            expect(timeline).toEqual([eventPollStartThreadRoot, eventPollResponseReference]);
 
             expect(threaded).toEqual([
                 eventPollStartThreadRoot,
@@ -737,7 +748,7 @@ describe("MatrixClient", function() {
             ]);
         });
 
-        it("copies post-thread in-timeline reactions onto both timelines", function() {
+        it("copies post-thread in-timeline reactions onto both timelines", function () {
             // @ts-ignore setting private property
             client!.clientOpts = {
                 ...defaultClientOpts,
@@ -748,18 +759,11 @@ describe("MatrixClient", function() {
             const eventMessageInThread = buildEventMessageInThread(eventPollStartThreadRoot);
             const eventReaction = buildEventReaction(eventPollStartThreadRoot);
 
-            const events = [
-                eventPollStartThreadRoot,
-                eventMessageInThread,
-                eventReaction,
-            ];
+            const events = [eventPollStartThreadRoot, eventMessageInThread, eventReaction];
 
             const [timeline, threaded] = room.partitionThreadedEvents(events);
 
-            expect(timeline).toEqual([
-                eventPollStartThreadRoot,
-                eventReaction,
-            ]);
+            expect(timeline).toEqual([eventPollStartThreadRoot, eventReaction]);
 
             expect(threaded).toEqual([
                 eventPollStartThreadRoot,
@@ -768,7 +772,7 @@ describe("MatrixClient", function() {
             ]);
         });
 
-        it("sends room state events to the main timeline only", function() {
+        it("sends room state events to the main timeline only", function () {
             // @ts-ignore setting private property
             client!.clientOpts = {
                 ...defaultClientOpts,
@@ -837,18 +841,11 @@ describe("MatrixClient", function() {
             const threadedReaction = buildEventReaction(eventMessageInThread);
             const threadedReactionRedaction = buildEventRedaction(threadedReaction);
 
-            const events = [
-                threadRootEvent,
-                eventMessageInThread,
-                threadedReaction,
-                threadedReactionRedaction,
-            ];
+            const events = [threadRootEvent, eventMessageInThread, threadedReaction, threadedReactionRedaction];
 
             const [timeline, threaded] = room.partitionThreadedEvents(events);
 
-            expect(timeline).toEqual([
-                threadRootEvent,
-            ]);
+            expect(timeline).toEqual([threadRootEvent]);
 
             expect(threaded).toEqual([
                 threadRootEvent,
@@ -870,25 +867,13 @@ describe("MatrixClient", function() {
             const directReplyToThreadRoot = buildEventReply(threadRootEvent);
             const replyToReply = buildEventReply(directReplyToThreadRoot);
 
-            const events = [
-                threadRootEvent,
-                eventMessageInThread,
-                directReplyToThreadRoot,
-                replyToReply,
-            ];
+            const events = [threadRootEvent, eventMessageInThread, directReplyToThreadRoot, replyToReply];
 
             const [timeline, threaded] = room.partitionThreadedEvents(events);
 
-            expect(timeline).toEqual([
-                threadRootEvent,
-                directReplyToThreadRoot,
-                replyToReply,
-            ]);
+            expect(timeline).toEqual([threadRootEvent, directReplyToThreadRoot, replyToReply]);
 
-            expect(threaded).toEqual([
-                threadRootEvent,
-                eventMessageInThread,
-            ]);
+            expect(threaded).toEqual([threadRootEvent, eventMessageInThread]);
         });
 
         it("sends reply to thread responses to main timeline only", () => {
@@ -902,52 +887,46 @@ describe("MatrixClient", function() {
             const eventMessageInThread = buildEventMessageInThread(threadRootEvent);
             const replyToThreadResponse = buildEventReply(eventMessageInThread);
 
-            const events = [
-                threadRootEvent,
-                eventMessageInThread,
-                replyToThreadResponse,
-            ];
+            const events = [threadRootEvent, eventMessageInThread, replyToThreadResponse];
 
             const [timeline, threaded] = room.partitionThreadedEvents(events);
 
-            expect(timeline).toEqual([
-                threadRootEvent,
-                replyToThreadResponse,
-            ]);
+            expect(timeline).toEqual([threadRootEvent, replyToThreadResponse]);
 
-            expect(threaded).toEqual([
-                threadRootEvent,
-                eventMessageInThread,
-            ]);
+            expect(threaded).toEqual([threadRootEvent, eventMessageInThread]);
         });
     });
 
     describe("getThirdpartyUser", () => {
         it("should hit the expected API endpoint", async () => {
-            const response = [{
-                userid: "@Bob",
-                protocol: "irc",
-                fields: {},
-            }];
+            const response = [
+                {
+                    userid: "@Bob",
+                    protocol: "irc",
+                    fields: {},
+                },
+            ];
 
             const prom = client!.getThirdpartyUser("irc", {});
             httpBackend!.when("GET", "/thirdparty/user/irc").respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
 
     describe("getThirdpartyLocation", () => {
         it("should hit the expected API endpoint", async () => {
-            const response = [{
-                alias: "#alias",
-                protocol: "irc",
-                fields: {},
-            }];
+            const response = [
+                {
+                    alias: "#alias",
+                    protocol: "irc",
+                    fields: {},
+                },
+            ];
 
             const prom = client!.getThirdpartyLocation("irc", {});
             httpBackend!.when("GET", "/thirdparty/location/irc").respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -961,7 +940,7 @@ describe("MatrixClient", function() {
             const prom = client!.getPushers();
             httpBackend!.when("GET", "/_matrix/client/versions").respond(200, {});
             httpBackend!.when("GET", "/pushers").respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -974,11 +953,14 @@ describe("MatrixClient", function() {
             };
 
             const prom = client!.getKeyChanges("old", "new");
-            httpBackend!.when("GET", "/keys/changes").check((req) => {
-                expect(req.queryParams?.from).toEqual("old");
-                expect(req.queryParams?.to).toEqual("new");
-            }).respond(200, response);
-            await httpBackend!.flush('');
+            httpBackend!
+                .when("GET", "/keys/changes")
+                .check((req) => {
+                    expect(req.queryParams?.from).toEqual("old");
+                    expect(req.queryParams?.to).toEqual("new");
+                })
+                .respond(200, response);
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -991,7 +973,7 @@ describe("MatrixClient", function() {
 
             const prom = client!.getDevices();
             httpBackend!.when("GET", "/devices").respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1007,7 +989,7 @@ describe("MatrixClient", function() {
 
             const prom = client!.getDevice("DEADBEEF");
             httpBackend!.when("GET", "/devices/DEADBEEF").respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1020,7 +1002,7 @@ describe("MatrixClient", function() {
 
             const prom = client!.getThreePids();
             httpBackend!.when("GET", "/account/3pid").respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1030,7 +1012,7 @@ describe("MatrixClient", function() {
             const response = {};
             const prom = client!.deleteAlias("#foo:bar");
             httpBackend!.when("DELETE", "/directory/room/" + encodeURIComponent("#foo:bar")).respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1041,7 +1023,7 @@ describe("MatrixClient", function() {
             const prom = client!.deleteRoomTag("!roomId:server", "u.tag");
             const url = `/user/${encodeURIComponent(userId)}/rooms/${encodeURIComponent("!roomId:server")}/tags/u.tag`;
             httpBackend!.when("DELETE", url).respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1059,7 +1041,7 @@ describe("MatrixClient", function() {
             const prom = client!.getRoomTags("!roomId:server");
             const url = `/user/${encodeURIComponent(userId)}/rooms/${encodeURIComponent("!roomId:server")}/tags`;
             httpBackend!.when("GET", url).respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1076,14 +1058,17 @@ describe("MatrixClient", function() {
             });
 
             const prom = client!.requestRegisterEmailToken("bob@email", "secret", 1);
-            httpBackend!.when("POST", "/register/email/requestToken").check(req => {
-                expect(req.data).toStrictEqual({
-                    email: "bob@email",
-                    client_secret: "secret",
-                    send_attempt: 1,
-                });
-            }).respond(200, response);
-            await httpBackend!.flush('');
+            httpBackend!
+                .when("POST", "/register/email/requestToken")
+                .check((req) => {
+                    expect(req.data).toStrictEqual({
+                        email: "bob@email",
+                        client_secret: "secret",
+                        send_attempt: 1,
+                    });
+                })
+                .respond(200, response);
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1096,17 +1081,20 @@ describe("MatrixClient", function() {
                 versions: ["r0.6.0"],
             });
 
-            httpBackend!.when("POST", "/invite").check(req => {
-                expect(req.data).toStrictEqual({
-                    id_server: idServerDomain,
-                    id_access_token: identityAccessToken,
-                    medium: "email",
-                    address: targetEmail,
-                });
-            }).respond(200, {});
+            httpBackend!
+                .when("POST", "/invite")
+                .check((req) => {
+                    expect(req.data).toStrictEqual({
+                        id_server: idServerDomain,
+                        id_access_token: identityAccessToken,
+                        medium: "email",
+                        address: targetEmail,
+                    });
+                })
+                .respond(200, {});
 
             const prom = client!.inviteByThreePid("!room:example.org", "email", targetEmail);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             await prom; // returns empty object, so no validation needed
         });
     });
@@ -1118,30 +1106,37 @@ describe("MatrixClient", function() {
                 room_id: "!room:localhost",
             };
             const input = {
-                invite_3pid: [{
-                    // we intentionally exclude the access token here, so it can be populated for us
-                    id_server: idServerDomain,
-                    medium: "email",
-                    address: targetEmail,
-                }],
+                invite_3pid: [
+                    {
+                        // we intentionally exclude the access token here, so it can be populated for us
+                        id_server: idServerDomain,
+                        medium: "email",
+                        address: targetEmail,
+                    },
+                ],
             };
 
             httpBackend!.when("GET", "/_matrix/client/versions").respond(200, {
                 versions: ["r0.6.0"],
             });
 
-            httpBackend!.when("POST", "/createRoom").check(req => {
-                expect(req.data).toMatchObject({
-                    invite_3pid: expect.arrayContaining([{
-                        ...input.invite_3pid[0],
-                        id_access_token: identityAccessToken,
-                    }]),
-                });
-                expect(req.data.invite_3pid.length).toBe(1);
-            }).respond(200, response);
+            httpBackend!
+                .when("POST", "/createRoom")
+                .check((req) => {
+                    expect(req.data).toMatchObject({
+                        invite_3pid: expect.arrayContaining([
+                            {
+                                ...input.invite_3pid[0],
+                                id_access_token: identityAccessToken,
+                            },
+                        ]),
+                    });
+                    expect(req.data.invite_3pid.length).toBe(1);
+                })
+                .respond(200, response);
 
             const prom = client!.createRoom(input);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1154,17 +1149,15 @@ describe("MatrixClient", function() {
             httpBackend!
                 .when("POST", "/unstable/org.matrix.msc3882/login/token", { auth: uiaData })
                 .respond(200, response);
-            await httpBackend!.flush('');
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
 
         it("should hit the expected API endpoint without UIA", async () => {
             const response = {};
             const prom = client!.requestLoginToken();
-            httpBackend!
-                .when("POST", "/unstable/org.matrix.msc3882/login/token", {})
-                .respond(200, response);
-            await httpBackend!.flush('');
+            httpBackend!.when("POST", "/unstable/org.matrix.msc3882/login/token", {}).respond(200, response);
+            await httpBackend!.flush("");
             expect(await prom).toStrictEqual(response);
         });
     });
@@ -1182,15 +1175,18 @@ describe("MatrixClient", function() {
 
     describe("sendHtmlEmote", () => {
         it("should send valid html emote", async () => {
-            httpBackend!.when("PUT", "/send").check(req => {
-                expect(req.data).toStrictEqual({
-                    "msgtype": "m.emote",
-                    "body": "Body",
-                    "formatted_body": "<h1>Body</h1>",
-                    "format": "org.matrix.custom.html",
-                    "org.matrix.msc1767.message": expect.anything(),
-                });
-            }).respond(200, { event_id: "$foobar" });
+            httpBackend!
+                .when("PUT", "/send")
+                .check((req) => {
+                    expect(req.data).toStrictEqual({
+                        "msgtype": "m.emote",
+                        "body": "Body",
+                        "formatted_body": "<h1>Body</h1>",
+                        "format": "org.matrix.custom.html",
+                        "org.matrix.msc1767.message": expect.anything(),
+                    });
+                })
+                .respond(200, { event_id: "$foobar" });
             const prom = client!.sendHtmlEmote("!room:server", "Body", "<h1>Body</h1>");
             await httpBackend!.flush(undefined);
             await expect(prom).resolves.toStrictEqual({ event_id: "$foobar" });
@@ -1199,15 +1195,18 @@ describe("MatrixClient", function() {
 
     describe("sendHtmlMessage", () => {
         it("should send valid html message", async () => {
-            httpBackend!.when("PUT", "/send").check(req => {
-                expect(req.data).toStrictEqual({
-                    "msgtype": "m.text",
-                    "body": "Body",
-                    "formatted_body": "<h1>Body</h1>",
-                    "format": "org.matrix.custom.html",
-                    "org.matrix.msc1767.message": expect.anything(),
-                });
-            }).respond(200, { event_id: "$foobar" });
+            httpBackend!
+                .when("PUT", "/send")
+                .check((req) => {
+                    expect(req.data).toStrictEqual({
+                        "msgtype": "m.text",
+                        "body": "Body",
+                        "formatted_body": "<h1>Body</h1>",
+                        "format": "org.matrix.custom.html",
+                        "org.matrix.msc1767.message": expect.anything(),
+                    });
+                })
+                .respond(200, { event_id: "$foobar" });
             const prom = client!.sendHtmlMessage("!room:server", "Body", "<h1>Body</h1>");
             await httpBackend!.flush(undefined);
             await expect(prom).resolves.toStrictEqual({ event_id: "$foobar" });
@@ -1221,10 +1220,7 @@ describe("MatrixClient", function() {
             expect(client!.store.getRooms()).toContain(room);
 
             httpBackend!.when("POST", "/forget").respond(200, {});
-            await Promise.all([
-                client!.forget(room.roomId),
-                httpBackend!.flushAllExpected(),
-            ]);
+            await Promise.all([client!.forget(room.roomId), httpBackend!.flushAllExpected()]);
             expect(client!.store.getRooms()).not.toContain(room);
         });
     });
@@ -1265,9 +1261,12 @@ describe("MatrixClient", function() {
         it("should send `user_accepts` via body of POST request", async () => {
             const terms = ["https://vector.im/notice-1"];
 
-            httpBackend!.when("POST", "/terms").check(req => {
-                expect(req.data.user_accepts).toStrictEqual(terms);
-            }).respond(200, {});
+            httpBackend!
+                .when("POST", "/terms")
+                .check((req) => {
+                    expect(req.data.user_accepts).toStrictEqual(terms);
+                })
+                .respond(200, {});
 
             const prom = client!.agreeToTerms(SERVICE_TYPES.IS, "https://vector.im", "at", terms);
             await httpBackend!.flushAllExpected();
@@ -1283,17 +1282,23 @@ describe("MatrixClient", function() {
         });
 
         it("should use GET request if only server is specified", () => {
-            httpBackend!.when("GET", "/publicRooms").check(request => {
-                expect(request.queryParams?.server).toBe("server1");
-            }).respond(200, {});
+            httpBackend!
+                .when("GET", "/publicRooms")
+                .check((request) => {
+                    expect(request.queryParams?.server).toBe("server1");
+                })
+                .respond(200, {});
             client!.publicRooms({ server: "server1" });
             return httpBackend!.flushAllExpected();
         });
 
         it("should use POST request if filter is specified", () => {
-            httpBackend!.when("POST", "/publicRooms").check(request => {
-                expect(request.data.filter.generic_search_term).toBe("foobar");
-            }).respond(200, {});
+            httpBackend!
+                .when("POST", "/publicRooms")
+                .check((request) => {
+                    expect(request.data.filter.generic_search_term).toBe("foobar");
+                })
+                .respond(200, {});
             client!.publicRooms({ filter: { generic_search_term: "foobar" } });
             return httpBackend!.flushAllExpected();
         });
@@ -1327,12 +1332,15 @@ describe("MatrixClient", function() {
                 expires_in: 12345,
             };
 
-            httpBackend!.when("POST", "/account/register").check(req => {
-                expect(req.data).toStrictEqual(token);
-            }).respond(200, {
-                access_token: "at",
-                token: "tt",
-            });
+            httpBackend!
+                .when("POST", "/account/register")
+                .check((req) => {
+                    expect(req.data).toStrictEqual(token);
+                })
+                .respond(200, {
+                    access_token: "at",
+                    token: "tt",
+                });
 
             const prom = client!.registerWithIdentityServer(token);
             await httpBackend!.flushAllExpected();
@@ -1367,9 +1375,12 @@ describe("MatrixClient", function() {
                 }),
             } as MatrixEvent;
 
-            httpBackend!.when("PUT", "/state/m.room.power_levels").check(req => {
-                expect(req.data.users).toStrictEqual(expectation);
-            }).respond(200, {});
+            httpBackend!
+                .when("PUT", "/state/m.room.power_levels")
+                .check((req) => {
+                    expect(req.data.users).toStrictEqual(expectation);
+                })
+                .respond(200, {});
 
             const prom = client!.setPowerLevel("!room_id:server", userId, 100, event);
             await httpBackend!.flushAllExpected();
@@ -1391,271 +1402,283 @@ function withThreadId(event: MatrixEvent, newThreadId: string): MatrixEvent {
     return ret;
 }
 
-const buildEventMessageInThread = (root: MatrixEvent) => new MatrixEvent({
-    "age": 80098509,
-    "content": {
-        "algorithm": "m.megolm.v1.aes-sha2",
-        "ciphertext": "ENCRYPTEDSTUFF",
-        "device_id": "XISFUZSKHH",
-        "m.relates_to": {
-            "event_id": root.getId(),
-            "m.in_reply_to": {
-                "event_id": root.getId()!,
+const buildEventMessageInThread = (root: MatrixEvent) =>
+    new MatrixEvent({
+        age: 80098509,
+        content: {
+            "algorithm": "m.megolm.v1.aes-sha2",
+            "ciphertext": "ENCRYPTEDSTUFF",
+            "device_id": "XISFUZSKHH",
+            "m.relates_to": {
+                "event_id": root.getId(),
+                "m.in_reply_to": {
+                    event_id: root.getId()!,
+                },
+                "rel_type": "m.thread",
             },
-            "rel_type": "m.thread",
+            "sender_key": "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
+            "session_id": "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
         },
-        "sender_key": "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
-        "session_id": "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
-    },
-    "event_id": "$W4chKIGYowtBblVLkRimeIg8TcdjETnxhDPGfi6NpDg",
-    "origin_server_ts": 1643815466378,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "type": "m.room.encrypted",
-    "unsigned": { "age": 80098509 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+        event_id: "$W4chKIGYowtBblVLkRimeIg8TcdjETnxhDPGfi6NpDg",
+        origin_server_ts: 1643815466378,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        type: "m.room.encrypted",
+        unsigned: { age: 80098509 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventPollResponseReference = () => new MatrixEvent({
-    "age": 80098509,
-    "content": {
-        "algorithm": "m.megolm.v1.aes-sha2",
-        "ciphertext": "ENCRYPTEDSTUFF",
-        "device_id": "XISFUZSKHH",
-        "m.relates_to": {
-            "event_id": "$VLS2ojbPmxb6x8ECetn45hmND6cRDcjgv-j-to9m7Vo",
-            "rel_type": "m.reference",
+const buildEventPollResponseReference = () =>
+    new MatrixEvent({
+        age: 80098509,
+        content: {
+            "algorithm": "m.megolm.v1.aes-sha2",
+            "ciphertext": "ENCRYPTEDSTUFF",
+            "device_id": "XISFUZSKHH",
+            "m.relates_to": {
+                event_id: "$VLS2ojbPmxb6x8ECetn45hmND6cRDcjgv-j-to9m7Vo",
+                rel_type: "m.reference",
+            },
+            "sender_key": "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
+            "session_id": "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
         },
-        "sender_key": "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
-        "session_id": "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
-    },
-    "event_id": "$91JvpezvsF0cKgav3g8W-uEVS4WkDHgxbJZvL3uMR1g",
-    "origin_server_ts": 1643815458650,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "type": "m.room.encrypted",
-    "unsigned": { "age": 80106237 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+        event_id: "$91JvpezvsF0cKgav3g8W-uEVS4WkDHgxbJZvL3uMR1g",
+        origin_server_ts: 1643815458650,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        type: "m.room.encrypted",
+        unsigned: { age: 80106237 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventReaction = (event: MatrixEvent) => new MatrixEvent({
-    "content": {
-        "m.relates_to": {
-            "event_id": event.getId(),
-            "key": "🤗",
-            "rel_type": "m.annotation",
+const buildEventReaction = (event: MatrixEvent) =>
+    new MatrixEvent({
+        content: {
+            "m.relates_to": {
+                event_id: event.getId(),
+                key: "🤗",
+                rel_type: "m.annotation",
+            },
         },
-    },
-    "origin_server_ts": 1643977249238,
-    "sender": "@andybalaam-test1:matrix.org",
-    "type": "m.reaction",
-    "unsigned": {
-        "age": 22598,
-        "transaction_id": "m1643977249073.16",
-    },
-    "event_id": "$86B2b-x3LgE4DlV4y24b7UHnt72LIA3rzjvMysTtAfA",
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-});
+        origin_server_ts: 1643977249238,
+        sender: "@andybalaam-test1:matrix.org",
+        type: "m.reaction",
+        unsigned: {
+            age: 22598,
+            transaction_id: "m1643977249073.16",
+        },
+        event_id: "$86B2b-x3LgE4DlV4y24b7UHnt72LIA3rzjvMysTtAfA",
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+    });
 
-const buildEventRedaction = (event: MatrixEvent) => new MatrixEvent({
-    "content": {
-
-    },
-    "origin_server_ts": 1643977249239,
-    "sender": "@andybalaam-test1:matrix.org",
-    "redacts": event.getId(),
-    "type": "m.room.redaction",
-    "unsigned": {
-        "age": 22597,
-        "transaction_id": "m1643977249073.17",
-    },
-    "event_id": "$86B2b-x3LgE4DlV4y24b7UHnt72LIA3rzjvMysTtAfB",
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-});
+const buildEventRedaction = (event: MatrixEvent) =>
+    new MatrixEvent({
+        content: {},
+        origin_server_ts: 1643977249239,
+        sender: "@andybalaam-test1:matrix.org",
+        redacts: event.getId(),
+        type: "m.room.redaction",
+        unsigned: {
+            age: 22597,
+            transaction_id: "m1643977249073.17",
+        },
+        event_id: "$86B2b-x3LgE4DlV4y24b7UHnt72LIA3rzjvMysTtAfB",
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+    });
 
-const buildEventPollStartThreadRoot = () => new MatrixEvent({
-    "age": 80108647,
-    "content": {
-        "algorithm": "m.megolm.v1.aes-sha2",
-        "ciphertext": "ENCRYPTEDSTUFF",
-        "device_id": "XISFUZSKHH",
-        "sender_key": "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
-        "session_id": "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
-    },
-    "event_id": "$VLS2ojbPmxb6x8ECetn45hmND6cRDcjgv-j-to9m7Vo",
-    "origin_server_ts": 1643815456240,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "type": "m.room.encrypted",
-    "unsigned": { "age": 80108647 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+const buildEventPollStartThreadRoot = () =>
+    new MatrixEvent({
+        age: 80108647,
+        content: {
+            algorithm: "m.megolm.v1.aes-sha2",
+            ciphertext: "ENCRYPTEDSTUFF",
+            device_id: "XISFUZSKHH",
+            sender_key: "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
+            session_id: "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
+        },
+        event_id: "$VLS2ojbPmxb6x8ECetn45hmND6cRDcjgv-j-to9m7Vo",
+        origin_server_ts: 1643815456240,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        type: "m.room.encrypted",
+        unsigned: { age: 80108647 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventReply = (target: MatrixEvent) => new MatrixEvent({
-    "age": 80098509,
-    "content": {
-        "algorithm": "m.megolm.v1.aes-sha2",
-        "ciphertext": "ENCRYPTEDSTUFF",
-        "device_id": "XISFUZSKHH",
-        "m.relates_to": {
-            "m.in_reply_to": {
-                "event_id": target.getId()!,
+const buildEventReply = (target: MatrixEvent) =>
+    new MatrixEvent({
+        age: 80098509,
+        content: {
+            "algorithm": "m.megolm.v1.aes-sha2",
+            "ciphertext": "ENCRYPTEDSTUFF",
+            "device_id": "XISFUZSKHH",
+            "m.relates_to": {
+                "m.in_reply_to": {
+                    event_id: target.getId()!,
+                },
             },
+            "sender_key": "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
+            "session_id": "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
         },
-        "sender_key": "i3N3CtG/CD2bGB8rA9fW6adLYSDvlUhf2iuU73L65Vg",
-        "session_id": "Ja11R/KG6ua0wdk8zAzognrxjio1Gm/RK2Gn6lFL804",
-    },
-    "event_id": target.getId()! + Math.random(),
-    "origin_server_ts": 1643815466378,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "type": "m.room.encrypted",
-    "unsigned": { "age": 80098509 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
-
-const buildEventRoomName = () => new MatrixEvent({
-    "age": 80123249,
-    "content": {
-        "name": "1 poll, 1 vote, 1 thread",
-    },
-    "event_id": "$QAdyNJtKnl1j7or2yMycbOCvb6bCgvHs5lg3ZMd5xWk",
-    "origin_server_ts": 1643815441638,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "",
-    "type": "m.room.name",
-    "unsigned": { "age": 80123249 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+        event_id: target.getId()! + Math.random(),
+        origin_server_ts: 1643815466378,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        type: "m.room.encrypted",
+        unsigned: { age: 80098509 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventEncryption = () => new MatrixEvent({
-    "age": 80123383,
-    "content": {
-        "algorithm": "m.megolm.v1.aes-sha2",
-    },
-    "event_id": "$1hGykogKQkXbHw8bVuyE3BjHnFBEJBcUWnakd0ck2K0",
-    "origin_server_ts": 1643815441504,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "",
-    "type": "m.room.encryption",
-    "unsigned": { "age": 80123383 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+const buildEventRoomName = () =>
+    new MatrixEvent({
+        age: 80123249,
+        content: {
+            name: "1 poll, 1 vote, 1 thread",
+        },
+        event_id: "$QAdyNJtKnl1j7or2yMycbOCvb6bCgvHs5lg3ZMd5xWk",
+        origin_server_ts: 1643815441638,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "",
+        type: "m.room.name",
+        unsigned: { age: 80123249 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventGuestAccess = () => new MatrixEvent({
-    "age": 80123473,
-    "content": {
-        "guest_access": "can_join",
-    },
-    "event_id": "$4_2n-H6K9-0nPbnjjtIue2SU44tGJsnuTmi6UuSrh-U",
-    "origin_server_ts": 1643815441414,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "",
-    "type": "m.room.guest_access",
-    "unsigned": { "age": 80123473 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+const buildEventEncryption = () =>
+    new MatrixEvent({
+        age: 80123383,
+        content: {
+            algorithm: "m.megolm.v1.aes-sha2",
+        },
+        event_id: "$1hGykogKQkXbHw8bVuyE3BjHnFBEJBcUWnakd0ck2K0",
+        origin_server_ts: 1643815441504,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "",
+        type: "m.room.encryption",
+        unsigned: { age: 80123383 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventHistoryVisibility = () => new MatrixEvent({
-    "age": 80123556,
-    "content": {
-        "history_visibility": "shared",
-    },
-    "event_id": "$W6kp44CTnvciOiHSPyhp8dh4n2v1_9kclUPddeaQj0E",
-    "origin_server_ts": 1643815441331,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "",
-    "type": "m.room.history_visibility",
-    "unsigned": { "age": 80123556 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+const buildEventGuestAccess = () =>
+    new MatrixEvent({
+        age: 80123473,
+        content: {
+            guest_access: "can_join",
+        },
+        event_id: "$4_2n-H6K9-0nPbnjjtIue2SU44tGJsnuTmi6UuSrh-U",
+        origin_server_ts: 1643815441414,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "",
+        type: "m.room.guest_access",
+        unsigned: { age: 80123473 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventJoinRules = () => new MatrixEvent({
-    "age": 80123696,
-    "content": {
-        "join_rule": "invite",
-    },
-    "event_id": "$6JDDeDp7fEc0F6YnTWMruNcKWFltR3e9wk7wWDDJrAU",
-    "origin_server_ts": 1643815441191,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "",
-    "type": "m.room.join_rules",
-    "unsigned": { "age": 80123696 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+const buildEventHistoryVisibility = () =>
+    new MatrixEvent({
+        age: 80123556,
+        content: {
+            history_visibility: "shared",
+        },
+        event_id: "$W6kp44CTnvciOiHSPyhp8dh4n2v1_9kclUPddeaQj0E",
+        origin_server_ts: 1643815441331,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "",
+        type: "m.room.history_visibility",
+        unsigned: { age: 80123556 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventPowerLevels = () => new MatrixEvent({
-    "age": 80124105,
-    "content": {
-        "ban": 50,
-        "events": {
-            "m.room.avatar": 50,
-            "m.room.canonical_alias": 50,
-            "m.room.encryption": 100,
-            "m.room.history_visibility": 100,
-            "m.room.name": 50,
-            "m.room.power_levels": 100,
-            "m.room.server_acl": 100,
-            "m.room.tombstone": 100,
+const buildEventJoinRules = () =>
+    new MatrixEvent({
+        age: 80123696,
+        content: {
+            join_rule: "invite",
         },
-        "events_default": 0,
-        "historical": 100,
-        "invite": 0,
-        "kick": 50,
-        "redact": 50,
-        "state_default": 50,
-        "users": {
-            "@andybalaam-test1:matrix.org": 100,
+        event_id: "$6JDDeDp7fEc0F6YnTWMruNcKWFltR3e9wk7wWDDJrAU",
+        origin_server_ts: 1643815441191,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "",
+        type: "m.room.join_rules",
+        unsigned: { age: 80123696 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
+
+const buildEventPowerLevels = () =>
+    new MatrixEvent({
+        age: 80124105,
+        content: {
+            ban: 50,
+            events: {
+                "m.room.avatar": 50,
+                "m.room.canonical_alias": 50,
+                "m.room.encryption": 100,
+                "m.room.history_visibility": 100,
+                "m.room.name": 50,
+                "m.room.power_levels": 100,
+                "m.room.server_acl": 100,
+                "m.room.tombstone": 100,
+            },
+            events_default: 0,
+            historical: 100,
+            invite: 0,
+            kick: 50,
+            redact: 50,
+            state_default: 50,
+            users: {
+                "@andybalaam-test1:matrix.org": 100,
+            },
+            users_default: 0,
         },
-        "users_default": 0,
-    },
-    "event_id": "$XZY2YgQhXskpc7gmJJG3S0VmS9_QjjCUVeeFTfgfC2E",
-    "origin_server_ts": 1643815440782,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "",
-    "type": "m.room.power_levels",
-    "unsigned": { "age": 80124105 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+        event_id: "$XZY2YgQhXskpc7gmJJG3S0VmS9_QjjCUVeeFTfgfC2E",
+        origin_server_ts: 1643815440782,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "",
+        type: "m.room.power_levels",
+        unsigned: { age: 80124105 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventMember = () => new MatrixEvent({
-    "age": 80125279,
-    "content": {
-        "avatar_url": "mxc://matrix.org/aNtbVcFfwotudypZcHsIcPOc",
-        "displayname": "andybalaam-test1",
-        "membership": "join",
-    },
-    "event_id": "$Ex5eVmMs_ti784mo8bgddynbwLvy6231lCycJr7Cl9M",
-    "origin_server_ts": 1643815439608,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "@andybalaam-test1:matrix.org",
-    "type": "m.room.member",
-    "unsigned": { "age": 80125279 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+const buildEventMember = () =>
+    new MatrixEvent({
+        age: 80125279,
+        content: {
+            avatar_url: "mxc://matrix.org/aNtbVcFfwotudypZcHsIcPOc",
+            displayname: "andybalaam-test1",
+            membership: "join",
+        },
+        event_id: "$Ex5eVmMs_ti784mo8bgddynbwLvy6231lCycJr7Cl9M",
+        origin_server_ts: 1643815439608,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "@andybalaam-test1:matrix.org",
+        type: "m.room.member",
+        unsigned: { age: 80125279 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
-const buildEventCreate = () => new MatrixEvent({
-    "age": 80126105,
-    "content": {
-        "creator": "@andybalaam-test1:matrix.org",
-        "room_version": "6",
-    },
-    "event_id": "$e7j2Gt37k5NPwB6lz2N3V9lO5pUdNK8Ai7i2FPEK-oI",
-    "origin_server_ts": 1643815438782,
-    "room_id": "!STrMRsukXHtqQdSeHa:matrix.org",
-    "sender": "@andybalaam-test1:matrix.org",
-    "state_key": "",
-    "type": "m.room.create",
-    "unsigned": { "age": 80126105 },
-    "user_id": "@andybalaam-test1:matrix.org",
-});
+const buildEventCreate = () =>
+    new MatrixEvent({
+        age: 80126105,
+        content: {
+            creator: "@andybalaam-test1:matrix.org",
+            room_version: "6",
+        },
+        event_id: "$e7j2Gt37k5NPwB6lz2N3V9lO5pUdNK8Ai7i2FPEK-oI",
+        origin_server_ts: 1643815438782,
+        room_id: "!STrMRsukXHtqQdSeHa:matrix.org",
+        sender: "@andybalaam-test1:matrix.org",
+        state_key: "",
+        type: "m.room.create",
+        unsigned: { age: 80126105 },
+        user_id: "@andybalaam-test1:matrix.org",
+    });
 
 function assertObjectContains(obj: Record<string, any>, expected: any): void {
     for (const k in expected) {
diff --git a/spec/integ/matrix-client-opts.spec.ts b/spec/integ/matrix-client-opts.spec.ts
index 41532ea526b..328152a208e 100644
--- a/spec/integ/matrix-client-opts.spec.ts
+++ b/spec/integ/matrix-client-opts.spec.ts
@@ -7,7 +7,7 @@ import { MemoryStore } from "../../src/store/memory";
 import { MatrixError } from "../../src/http-api";
 import { IStore } from "../../src/store";
 
-describe("MatrixClient opts", function() {
+describe("MatrixClient opts", function () {
     const baseUrl = "http://localhost.or.something";
     let httpBackend = new HttpBackend();
     const userId = "@alice:localhost";
@@ -19,11 +19,14 @@ describe("MatrixClient opts", function() {
         presence: {},
         rooms: {
             join: {
-                "!foo:bar": { // roomId
+                "!foo:bar": {
+                    // roomId
                     timeline: {
                         events: [
                             utils.mkMessage({
-                                room: roomId, user: userB, msg: "hello",
+                                room: roomId,
+                                user: userB,
+                                msg: "hello",
                             }),
                         ],
                         prev_batch: "f_1_1",
@@ -31,19 +34,29 @@ describe("MatrixClient opts", function() {
                     state: {
                         events: [
                             utils.mkEvent({
-                                type: "m.room.name", room: roomId, user: userB,
+                                type: "m.room.name",
+                                room: roomId,
+                                user: userB,
                                 content: {
                                     name: "Old room name",
                                 },
                             }),
                             utils.mkMembership({
-                                room: roomId, mship: "join", user: userB, name: "Bob",
+                                room: roomId,
+                                mship: "join",
+                                user: userB,
+                                name: "Bob",
                             }),
                             utils.mkMembership({
-                                room: roomId, mship: "join", user: userId, name: "Alice",
+                                room: roomId,
+                                mship: "join",
+                                user: userId,
+                                name: "Alice",
                             }),
                             utils.mkEvent({
-                                type: "m.room.create", room: roomId, user: userId,
+                                type: "m.room.create",
+                                room: roomId,
+                                user: userId,
                                 content: {
                                     creator: userId,
                                 },
@@ -55,18 +68,18 @@ describe("MatrixClient opts", function() {
         },
     };
 
-    beforeEach(function() {
+    beforeEach(function () {
         httpBackend = new HttpBackend();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         httpBackend.verifyNoOutstandingExpectation();
         return httpBackend.stop();
     });
 
-    describe("without opts.store", function() {
+    describe("without opts.store", function () {
         let client: MatrixClient;
-        beforeEach(function() {
+        beforeEach(function () {
             client = new MatrixClient({
                 fetchFn: httpBackend.fetchFn as typeof global.fetch,
                 store: undefined,
@@ -77,34 +90,34 @@ describe("MatrixClient opts", function() {
             });
         });
 
-        afterEach(function() {
+        afterEach(function () {
             client.stopClient();
         });
 
-        it("should be able to send messages", function(done) {
+        it("should be able to send messages", function (done) {
             const eventId = "$flibble:wibble";
             httpBackend.when("PUT", "/txn1").respond(200, {
                 event_id: eventId,
             });
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function (res) {
                 expect(res.event_id).toEqual(eventId);
                 done();
             });
             httpBackend.flush("/txn1", 1);
         });
 
-        it("should be able to sync / get new events", async function() {
-            const expectedEventTypes = [ // from /initialSync
-                "m.room.message", "m.room.name", "m.room.member", "m.room.member",
+        it("should be able to sync / get new events", async function () {
+            const expectedEventTypes = [
+                // from /initialSync
+                "m.room.message",
+                "m.room.name",
+                "m.room.member",
+                "m.room.member",
                 "m.room.create",
             ];
-            client.on(ClientEvent.Event, function(event) {
-                expect(expectedEventTypes.indexOf(event.getType())).not.toEqual(
-                    -1,
-                );
-                expectedEventTypes.splice(
-                    expectedEventTypes.indexOf(event.getType()), 1,
-                );
+            client.on(ClientEvent.Event, function (event) {
+                expect(expectedEventTypes.indexOf(event.getType())).not.toEqual(-1);
+                expectedEventTypes.splice(expectedEventTypes.indexOf(event.getType()), 1);
             });
             httpBackend.when("GET", "/versions").respond(200, {});
             httpBackend.when("GET", "/pushrules").respond(200, {});
@@ -114,19 +127,14 @@ describe("MatrixClient opts", function() {
             await httpBackend.flush("/versions", 1);
             await httpBackend.flush("/pushrules", 1);
             await httpBackend.flush("/filter", 1);
-            await Promise.all([
-                httpBackend.flush("/sync", 1),
-                utils.syncPromise(client),
-            ]);
-            expect(expectedEventTypes.length).toEqual(
-                0,
-            );
+            await Promise.all([httpBackend.flush("/sync", 1), utils.syncPromise(client)]);
+            expect(expectedEventTypes.length).toEqual(0);
         });
     });
 
-    describe("without opts.scheduler", function() {
+    describe("without opts.scheduler", function () {
         let client: MatrixClient;
-        beforeEach(function() {
+        beforeEach(function () {
             client = new MatrixClient({
                 fetchFn: httpBackend.fetchFn as typeof global.fetch,
                 store: new MemoryStore() as IStore,
@@ -137,25 +145,31 @@ describe("MatrixClient opts", function() {
             });
         });
 
-        afterEach(function() {
+        afterEach(function () {
             client.stopClient();
         });
 
-        it("shouldn't retry sending events", function(done) {
-            httpBackend.when("PUT", "/txn1").respond(500, new MatrixError({
-                errcode: "M_SOMETHING",
-                error: "Ruh roh",
-            }));
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
-                expect(false).toBe(true);
-            }, function(err) {
-                expect(err.errcode).toEqual("M_SOMETHING");
-                done();
-            });
+        it("shouldn't retry sending events", function (done) {
+            httpBackend.when("PUT", "/txn1").respond(
+                500,
+                new MatrixError({
+                    errcode: "M_SOMETHING",
+                    error: "Ruh roh",
+                }),
+            );
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(
+                function (res) {
+                    expect(false).toBe(true);
+                },
+                function (err) {
+                    expect(err.errcode).toEqual("M_SOMETHING");
+                    done();
+                },
+            );
             httpBackend.flush("/txn1", 1);
         });
 
-        it("shouldn't queue events", function(done) {
+        it("shouldn't queue events", function (done) {
             httpBackend.when("PUT", "/txn1").respond(200, {
                 event_id: "AAA",
             });
@@ -164,26 +178,26 @@ describe("MatrixClient opts", function() {
             });
             let sentA = false;
             let sentB = false;
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function (res) {
                 sentA = true;
                 expect(sentB).toBe(true);
             });
-            client.sendTextMessage("!foo:bar", "b body", "txn2").then(function(res) {
+            client.sendTextMessage("!foo:bar", "b body", "txn2").then(function (res) {
                 sentB = true;
                 expect(sentA).toBe(false);
             });
-            httpBackend.flush("/txn2", 1).then(function() {
-                httpBackend.flush("/txn1", 1).then(function() {
+            httpBackend.flush("/txn2", 1).then(function () {
+                httpBackend.flush("/txn1", 1).then(function () {
                     done();
                 });
             });
         });
 
-        it("should be able to send messages", function(done) {
+        it("should be able to send messages", function (done) {
             httpBackend.when("PUT", "/txn1").respond(200, {
                 event_id: "foo",
             });
-            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function(res) {
+            client.sendTextMessage("!foo:bar", "a body", "txn1").then(function (res) {
                 expect(res.event_id).toEqual("foo");
                 done();
             });
diff --git a/spec/integ/matrix-client-relations.spec.ts b/spec/integ/matrix-client-relations.spec.ts
index 5a4fa2bd0dc..1a7f370c22a 100644
--- a/spec/integ/matrix-client-relations.spec.ts
+++ b/spec/integ/matrix-client-relations.spec.ts
@@ -29,13 +29,7 @@ describe("MatrixClient relations", () => {
 
     const setupTests = (): [MatrixClient, HttpBackend] => {
         const scheduler = new MatrixScheduler();
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { scheduler },
-        );
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { scheduler });
         const httpBackend = testClient.httpBackend;
         const client = testClient.client;
 
@@ -52,88 +46,71 @@ describe("MatrixClient relations", () => {
     });
 
     it("should read related events with the default options", async () => {
-        const response = client!.relations(roomId, '$event-0', null, null);
+        const response = client!.relations(roomId, "$event-0", null, null);
 
-        httpBackend!
-            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
-            .respond(200, null);
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
         httpBackend!
             .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0?dir=b")
-            .respond(200, { chunk: [], next_batch: 'NEXT' });
+            .respond(200, { chunk: [], next_batch: "NEXT" });
 
         await httpBackend!.flushAllExpected();
 
-        expect(await response).toEqual({ "events": [], "nextBatch": "NEXT", "originalEvent": null, "prevBatch": null });
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
     });
 
     it("should read related events with relation type", async () => {
-        const response = client!.relations(roomId, '$event-0', 'm.reference', null);
+        const response = client!.relations(roomId, "$event-0", "m.reference", null);
 
-        httpBackend!
-            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
-            .respond(200, null);
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
         httpBackend!
             .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0/m.reference?dir=b")
-            .respond(200, { chunk: [], next_batch: 'NEXT' });
+            .respond(200, { chunk: [], next_batch: "NEXT" });
 
         await httpBackend!.flushAllExpected();
 
-        expect(await response).toEqual({ "events": [], "nextBatch": "NEXT", "originalEvent": null, "prevBatch": null });
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
     });
 
     it("should read related events with relation type and event type", async () => {
-        const response = client!.relations(roomId, '$event-0', 'm.reference', 'm.room.message');
+        const response = client!.relations(roomId, "$event-0", "m.reference", "m.room.message");
 
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
         httpBackend!
-            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
-            .respond(200, null);
-        httpBackend!
-            .when(
-                "GET",
-                "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0/m.reference/m.room.message?dir=b",
-            )
-            .respond(200, { chunk: [], next_batch: 'NEXT' });
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0/m.reference/m.room.message?dir=b")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
 
         await httpBackend!.flushAllExpected();
 
-        expect(await response).toEqual({ "events": [], "nextBatch": "NEXT", "originalEvent": null, "prevBatch": null });
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
     });
 
     it("should read related events with custom options", async () => {
-        const response = client!.relations(roomId, '$event-0', null, null, {
+        const response = client!.relations(roomId, "$event-0", null, null, {
             dir: Direction.Forward,
-            from: 'FROM',
+            from: "FROM",
             limit: 10,
-            to: 'TO',
+            to: "TO",
         });
 
+        httpBackend!.when("GET", "/rooms/!room%3Ahere/event/%24event-0").respond(200, null);
         httpBackend!
-            .when("GET", "/rooms/!room%3Ahere/event/%24event-0")
-            .respond(200, null);
-        httpBackend!
-            .when(
-                "GET",
-                "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0?dir=f&from=FROM&limit=10&to=TO",
-            )
-            .respond(200, { chunk: [], next_batch: 'NEXT' });
+            .when("GET", "/_matrix/client/v1/rooms/!room%3Ahere/relations/%24event-0?dir=f&from=FROM&limit=10&to=TO")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
 
         await httpBackend!.flushAllExpected();
 
-        expect(await response).toEqual({ "events": [], "nextBatch": "NEXT", "originalEvent": null, "prevBatch": null });
+        expect(await response).toEqual({ events: [], nextBatch: "NEXT", originalEvent: null, prevBatch: null });
     });
 
-    it('should use default direction in the fetchRelations endpoint', async () => {
-        const response = client!.fetchRelations(roomId, '$event-0', null, null);
+    it("should use default direction in the fetchRelations endpoint", async () => {
+        const response = client!.fetchRelations(roomId, "$event-0", null, null);
 
         httpBackend!
-            .when(
-                "GET",
-                "/rooms/!room%3Ahere/relations/%24event-0?dir=b",
-            )
-            .respond(200, { chunk: [], next_batch: 'NEXT' });
+            .when("GET", "/rooms/!room%3Ahere/relations/%24event-0?dir=b")
+            .respond(200, { chunk: [], next_batch: "NEXT" });
 
         await httpBackend!.flushAllExpected();
 
-        expect(await response).toEqual({ "chunk": [], "next_batch": "NEXT" });
+        expect(await response).toEqual({ chunk: [], next_batch: "NEXT" });
     });
 });
diff --git a/spec/integ/matrix-client-retrying.spec.ts b/spec/integ/matrix-client-retrying.spec.ts
index 877e80ac97c..c890230b816 100644
--- a/spec/integ/matrix-client-retrying.spec.ts
+++ b/spec/integ/matrix-client-retrying.spec.ts
@@ -20,7 +20,7 @@ import { EventStatus, RoomEvent, MatrixClient, MatrixScheduler } from "../../src
 import { Room } from "../../src/models/room";
 import { TestClient } from "../TestClient";
 
-describe("MatrixClient retrying", function() {
+describe("MatrixClient retrying", function () {
     const userId = "@alice:localhost";
     const accessToken = "aseukfgwef";
     const roomId = "!room:here";
@@ -30,13 +30,7 @@ describe("MatrixClient retrying", function() {
 
     const setupTests = (): [MatrixClient, HttpBackend, Room] => {
         const scheduler = new MatrixScheduler();
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { scheduler },
-        );
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { scheduler });
         const httpBackend = testClient.httpBackend;
         const client = testClient.client;
         const room = new Room(roomId, client, userId);
@@ -45,49 +39,46 @@ describe("MatrixClient retrying", function() {
         return [client, httpBackend, room];
     };
 
-    beforeEach(function() {
+    beforeEach(function () {
         [client, httpBackend, room] = setupTests();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         httpBackend!.verifyNoOutstandingExpectation();
         return httpBackend!.stop();
     });
 
-    xit("should retry according to MatrixScheduler.retryFn", function() {
+    xit("should retry according to MatrixScheduler.retryFn", function () {});
 
-    });
-
-    xit("should queue according to MatrixScheduler.queueFn", function() {
-
-    });
+    xit("should queue according to MatrixScheduler.queueFn", function () {});
 
-    xit("should mark events as EventStatus.NOT_SENT when giving up", function() {
+    xit("should mark events as EventStatus.NOT_SENT when giving up", function () {});
 
-    });
-
-    xit("should mark events as EventStatus.QUEUED when queued", function() {
-
-    });
+    xit("should mark events as EventStatus.QUEUED when queued", function () {});
 
-    it("should mark events as EventStatus.CANCELLED when cancelled", function() {
+    it("should mark events as EventStatus.CANCELLED when cancelled", function () {
         // send a couple of events; the second will be queued
-        const p1 = client!.sendMessage(roomId, {
-            "msgtype": "m.text",
-            "body": "m1",
-        }).then(function() {
-            // we expect the first message to fail
-            throw new Error('Message 1 unexpectedly sent successfully');
-        }, () => {
-            // this is expected
-        });
+        const p1 = client!
+            .sendMessage(roomId, {
+                msgtype: "m.text",
+                body: "m1",
+            })
+            .then(
+                function () {
+                    // we expect the first message to fail
+                    throw new Error("Message 1 unexpectedly sent successfully");
+                },
+                () => {
+                    // this is expected
+                },
+            );
 
         // XXX: it turns out that the promise returned by this message
         // never gets resolved.
         // https://github.com/matrix-org/matrix-js-sdk/issues/496
         client!.sendMessage(roomId, {
-            "msgtype": "m.text",
-            "body": "m2",
+            msgtype: "m.text",
+            body: "m2",
         });
 
         // both events should be in the timeline at this point
@@ -100,20 +91,23 @@ describe("MatrixClient retrying", function() {
         expect(ev2.status).toEqual(EventStatus.SENDING);
 
         // the first message should get sent, and the second should get queued
-        httpBackend!.when("PUT", "/send/m.room.message/").check(function() {
-            // ev2 should now have been queued
-            expect(ev2.status).toEqual(EventStatus.QUEUED);
-
-            // now we can cancel the second and check everything looks sane
-            client!.cancelPendingEvent(ev2);
-            expect(ev2.status).toEqual(EventStatus.CANCELLED);
-            expect(tl.length).toEqual(1);
-
-            // shouldn't be able to cancel the first message yet
-            expect(function() {
-                client!.cancelPendingEvent(ev1);
-            }).toThrow();
-        }).respond(400); // fail the first message
+        httpBackend!
+            .when("PUT", "/send/m.room.message/")
+            .check(function () {
+                // ev2 should now have been queued
+                expect(ev2.status).toEqual(EventStatus.QUEUED);
+
+                // now we can cancel the second and check everything looks sane
+                client!.cancelPendingEvent(ev2);
+                expect(ev2.status).toEqual(EventStatus.CANCELLED);
+                expect(tl.length).toEqual(1);
+
+                // shouldn't be able to cancel the first message yet
+                expect(function () {
+                    client!.cancelPendingEvent(ev1);
+                }).toThrow();
+            })
+            .respond(400); // fail the first message
 
         // wait for the localecho of ev1 to be updated
         const p3 = new Promise<void>((resolve, reject) => {
@@ -122,7 +116,7 @@ describe("MatrixClient retrying", function() {
                     resolve();
                 }
             });
-        }).then(function() {
+        }).then(function () {
             expect(ev1.status).toEqual(EventStatus.NOT_SENT);
             expect(tl.length).toEqual(1);
 
@@ -132,19 +126,11 @@ describe("MatrixClient retrying", function() {
             expect(tl.length).toEqual(0);
         });
 
-        return Promise.all([
-            p1,
-            p3,
-            httpBackend!.flushAllExpected(),
-        ]);
+        return Promise.all([p1, p3, httpBackend!.flushAllExpected()]);
     });
 
-    describe("resending", function() {
-        xit("should be able to resend a NOT_SENT event", function() {
-
-        });
-        xit("should be able to resend a sent event", function() {
-
-        });
+    describe("resending", function () {
+        xit("should be able to resend a NOT_SENT event", function () {});
+        xit("should be able to resend a sent event", function () {});
     });
 });
diff --git a/spec/integ/matrix-client-room-timeline.spec.ts b/spec/integ/matrix-client-room-timeline.spec.ts
index 3c2aa77a6e3..8d7bcba2e23 100644
--- a/spec/integ/matrix-client-room-timeline.spec.ts
+++ b/spec/integ/matrix-client-room-timeline.spec.ts
@@ -26,11 +26,12 @@ import {
     RoomEvent,
     ISyncResponse,
     IMinimalEvent,
-    IRoomEvent, Room,
+    IRoomEvent,
+    Room,
 } from "../../src";
 import { TestClient } from "../TestClient";
 
-describe("MatrixClient room timelines", function() {
+describe("MatrixClient room timelines", function () {
     const userId = "@alice:localhost";
     const userName = "Alice";
     const accessToken = "aseukfgwef";
@@ -40,10 +41,15 @@ describe("MatrixClient room timelines", function() {
     let httpBackend: HttpBackend | undefined;
 
     const USER_MEMBERSHIP_EVENT = utils.mkMembership({
-        room: roomId, mship: "join", user: userId, name: userName,
+        room: roomId,
+        mship: "join",
+        user: userId,
+        name: userName,
     });
     const ROOM_NAME_EVENT = utils.mkEvent({
-        type: "m.room.name", room: roomId, user: otherUserId,
+        type: "m.room.name",
+        room: roomId,
+        user: otherUserId,
         content: {
             name: "Old room name",
         },
@@ -53,11 +59,14 @@ describe("MatrixClient room timelines", function() {
         next_batch: "s_5_3",
         rooms: {
             join: {
-                "!foo:bar": { // roomId
+                "!foo:bar": {
+                    // roomId
                     timeline: {
                         events: [
                             utils.mkMessage({
-                                room: roomId, user: otherUserId, msg: "hello",
+                                room: roomId,
+                                user: otherUserId,
+                                msg: "hello",
                             }),
                         ],
                         prev_batch: "f_1_1",
@@ -66,12 +75,16 @@ describe("MatrixClient room timelines", function() {
                         events: [
                             ROOM_NAME_EVENT,
                             utils.mkMembership({
-                                room: roomId, mship: "join",
-                                user: otherUserId, name: "Bob",
+                                room: roomId,
+                                mship: "join",
+                                user: otherUserId,
+                                name: "Bob",
                             }),
                             USER_MEMBERSHIP_EVENT,
                             utils.mkEvent({
-                                type: "m.room.create", room: roomId, user: userId,
+                                type: "m.room.create",
+                                room: roomId,
+                                user: userId,
                                 content: {
                                     creator: userId,
                                 },
@@ -99,7 +112,7 @@ describe("MatrixClient room timelines", function() {
                 leave: {},
             } as unknown as ISyncResponse["rooms"],
         };
-        events.forEach(function(e) {
+        events.forEach(function (e) {
             if (e.room_id !== roomId) {
                 throw new Error("setNextSyncData only works with one room id");
             }
@@ -116,13 +129,7 @@ describe("MatrixClient room timelines", function() {
 
     const setupTestClient = (): [MatrixClient, HttpBackend] => {
         // these tests should work with or without timelineSupport
-        const testClient = new TestClient(
-            userId,
-            "DEVICE",
-            accessToken,
-            undefined,
-            { timelineSupport: true },
-        );
+        const testClient = new TestClient(userId, "DEVICE", accessToken, undefined, { timelineSupport: true });
         const httpBackend = testClient.httpBackend;
         const client = testClient.client;
 
@@ -131,7 +138,7 @@ describe("MatrixClient room timelines", function() {
         httpBackend!.when("GET", "/pushrules").respond(200, {});
         httpBackend!.when("POST", "/filter").respond(200, { filter_id: "fid" });
         httpBackend!.when("GET", "/sync").respond(200, SYNC_DATA);
-        httpBackend!.when("GET", "/sync").respond(200, function() {
+        httpBackend!.when("GET", "/sync").respond(200, function () {
             return NEXT_SYNC_DATA;
         });
         client!.startClient();
@@ -139,119 +146,131 @@ describe("MatrixClient room timelines", function() {
         return [client!, httpBackend];
     };
 
-    beforeEach(async function() {
+    beforeEach(async function () {
         [client!, httpBackend] = setupTestClient();
         await httpBackend.flush("/versions");
         await httpBackend.flush("/pushrules");
         await httpBackend.flush("/filter");
     });
 
-    afterEach(function() {
+    afterEach(function () {
         httpBackend!.verifyNoOutstandingExpectation();
         client!.stopClient();
         return httpBackend!.stop();
     });
 
-    describe("local echo events", function() {
-        it("should be added immediately after calling MatrixClient.sendEvent " +
-        "with EventStatus.SENDING and the right event.sender", function(done) {
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                expect(room.timeline.length).toEqual(1);
+    describe("local echo events", function () {
+        it(
+            "should be added immediately after calling MatrixClient.sendEvent " +
+                "with EventStatus.SENDING and the right event.sender",
+            function (done) {
+                client!.on(ClientEvent.Sync, function (state) {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    expect(room.timeline.length).toEqual(1);
 
-                client!.sendTextMessage(roomId, "I am a fish", "txn1");
-                // check it was added
-                expect(room.timeline.length).toEqual(2);
-                // check status
-                expect(room.timeline[1].status).toEqual(EventStatus.SENDING);
-                // check member
-                const member = room.timeline[1].sender;
-                expect(member?.userId).toEqual(userId);
-                expect(member?.name).toEqual(userName);
-
-                httpBackend!.flush("/sync", 1).then(function() {
-                    done();
+                    client!.sendTextMessage(roomId, "I am a fish", "txn1");
+                    // check it was added
+                    expect(room.timeline.length).toEqual(2);
+                    // check status
+                    expect(room.timeline[1].status).toEqual(EventStatus.SENDING);
+                    // check member
+                    const member = room.timeline[1].sender;
+                    expect(member?.userId).toEqual(userId);
+                    expect(member?.name).toEqual(userName);
+
+                    httpBackend!.flush("/sync", 1).then(function () {
+                        done();
+                    });
                 });
-            });
-            httpBackend!.flush("/sync", 1);
-        });
+                httpBackend!.flush("/sync", 1);
+            },
+        );
 
-        it("should be updated correctly when the send request finishes " +
-        "BEFORE the event comes down the event stream", function(done) {
-            const eventId = "$foo:bar";
-            httpBackend!.when("PUT", "/txn1").respond(200, {
-                event_id: eventId,
-            });
+        it(
+            "should be updated correctly when the send request finishes " +
+                "BEFORE the event comes down the event stream",
+            function (done) {
+                const eventId = "$foo:bar";
+                httpBackend!.when("PUT", "/txn1").respond(200, {
+                    event_id: eventId,
+                });
 
-            const ev = utils.mkMessage({
-                msg: "I am a fish", user: userId, room: roomId,
-            });
-            ev.event_id = eventId;
-            ev.unsigned = { transaction_id: "txn1" };
-            setNextSyncData([ev]);
+                const ev = utils.mkMessage({
+                    msg: "I am a fish",
+                    user: userId,
+                    room: roomId,
+                });
+                ev.event_id = eventId;
+                ev.unsigned = { transaction_id: "txn1" };
+                setNextSyncData([ev]);
 
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                client!.sendTextMessage(roomId, "I am a fish", "txn1").then(
-                    function() {
+                client!.on(ClientEvent.Sync, function (state) {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    client!.sendTextMessage(roomId, "I am a fish", "txn1").then(function () {
                         expect(room.timeline[1].getId()).toEqual(eventId);
-                        httpBackend!.flush("/sync", 1).then(function() {
+                        httpBackend!.flush("/sync", 1).then(function () {
                             expect(room.timeline[1].getId()).toEqual(eventId);
                             done();
                         });
                     });
-                httpBackend!.flush("/txn1", 1);
-            });
-            httpBackend!.flush("/sync", 1);
-        });
+                    httpBackend!.flush("/txn1", 1);
+                });
+                httpBackend!.flush("/sync", 1);
+            },
+        );
 
-        it("should be updated correctly when the send request finishes " +
-        "AFTER the event comes down the event stream", function(done) {
-            const eventId = "$foo:bar";
-            httpBackend!.when("PUT", "/txn1").respond(200, {
-                event_id: eventId,
-            });
+        it(
+            "should be updated correctly when the send request finishes " +
+                "AFTER the event comes down the event stream",
+            function (done) {
+                const eventId = "$foo:bar";
+                httpBackend!.when("PUT", "/txn1").respond(200, {
+                    event_id: eventId,
+                });
 
-            const ev = utils.mkMessage({
-                msg: "I am a fish", user: userId, room: roomId,
-            });
-            ev.event_id = eventId;
-            ev.unsigned = { transaction_id: "txn1" };
-            setNextSyncData([ev]);
+                const ev = utils.mkMessage({
+                    msg: "I am a fish",
+                    user: userId,
+                    room: roomId,
+                });
+                ev.event_id = eventId;
+                ev.unsigned = { transaction_id: "txn1" };
+                setNextSyncData([ev]);
 
-            client!.on(ClientEvent.Sync, function(state) {
-                if (state !== "PREPARED") {
-                    return;
-                }
-                const room = client!.getRoom(roomId)!;
-                const promise = client!.sendTextMessage(roomId, "I am a fish", "txn1");
-                httpBackend!.flush("/sync", 1).then(function() {
-                    expect(room.timeline.length).toEqual(2);
-                    httpBackend!.flush("/txn1", 1);
-                    promise.then(function() {
+                client!.on(ClientEvent.Sync, function (state) {
+                    if (state !== "PREPARED") {
+                        return;
+                    }
+                    const room = client!.getRoom(roomId)!;
+                    const promise = client!.sendTextMessage(roomId, "I am a fish", "txn1");
+                    httpBackend!.flush("/sync", 1).then(function () {
                         expect(room.timeline.length).toEqual(2);
-                        expect(room.timeline[1].getId()).toEqual(eventId);
-                        done();
+                        httpBackend!.flush("/txn1", 1);
+                        promise.then(function () {
+                            expect(room.timeline.length).toEqual(2);
+                            expect(room.timeline[1].getId()).toEqual(eventId);
+                            done();
+                        });
                     });
                 });
-            });
-            httpBackend!.flush("/sync", 1);
-        });
+                httpBackend!.flush("/sync", 1);
+            },
+        );
     });
 
-    describe("paginated events", function() {
+    describe("paginated events", function () {
         let sbEvents: Partial<IEvent>[];
         const sbEndTok = "pagin_end";
 
-        beforeEach(function() {
+        beforeEach(function () {
             sbEvents = [];
-            httpBackend!.when("GET", "/messages").respond(200, function() {
+            httpBackend!.when("GET", "/messages").respond(200, function () {
                 return {
                     chunk: sbEvents,
                     start: "pagin_start",
@@ -260,16 +279,15 @@ describe("MatrixClient room timelines", function() {
             });
         });
 
-        it("should set Room.oldState.paginationToken to null at the start" +
-        " of the timeline.", function(done) {
-            client!.on(ClientEvent.Sync, function(state) {
+        it("should set Room.oldState.paginationToken to null at the start" + " of the timeline.", function (done) {
+            client!.on(ClientEvent.Sync, function (state) {
                 if (state !== "PREPARED") {
                     return;
                 }
                 const room = client!.getRoom(roomId)!;
                 expect(room.timeline.length).toEqual(1);
 
-                client!.scrollback(room).then(function() {
+                client!.scrollback(room).then(function () {
                     expect(room.timeline.length).toEqual(1);
                     expect(room.oldState.paginationToken).toBe(null);
 
@@ -284,7 +302,7 @@ describe("MatrixClient room timelines", function() {
             httpBackend!.flush("/sync", 1);
         });
 
-        it("should set the right event.sender values", function(done) {
+        it("should set the right event.sender values", function (done) {
             // We're aiming for an eventual timeline of:
             //
             // 'Old Alice' joined the room
@@ -296,14 +314,20 @@ describe("MatrixClient room timelines", function() {
 
             // make an m.room.member event for alice's join
             const joinMshipEvent = utils.mkMembership({
-                mship: "join", user: userId, room: roomId, name: "Old Alice",
+                mship: "join",
+                user: userId,
+                room: roomId,
+                name: "Old Alice",
                 url: undefined,
             });
 
             // make an m.room.member event with prev_content for alice's nick
             // change
             const oldMshipEvent = utils.mkMembership({
-                mship: "join", user: userId, room: roomId, name: userName,
+                mship: "join",
+                user: userId,
+                room: roomId,
+                name: userName,
                 url: "mxc://some/url",
             });
             oldMshipEvent.prev_content = {
@@ -316,16 +340,20 @@ describe("MatrixClient room timelines", function() {
             // N.B. synapse returns /messages in reverse chronological order
             sbEvents = [
                 utils.mkMessage({
-                    user: userId, room: roomId, msg: "I'm alice",
+                    user: userId,
+                    room: roomId,
+                    msg: "I'm alice",
                 }),
                 oldMshipEvent,
                 utils.mkMessage({
-                    user: userId, room: roomId, msg: "I'm old alice",
+                    user: userId,
+                    room: roomId,
+                    msg: "I'm old alice",
                 }),
                 joinMshipEvent,
             ];
 
-            client!.on(ClientEvent.Sync, function(state) {
+            client!.on(ClientEvent.Sync, function (state) {
                 if (state !== "PREPARED") {
                     return;
                 }
@@ -333,7 +361,7 @@ describe("MatrixClient room timelines", function() {
                 // sync response
                 expect(room.timeline.length).toEqual(1);
 
-                client!.scrollback(room).then(function() {
+                client!.scrollback(room).then(function () {
                     expect(room.timeline.length).toEqual(5);
                     const joinMsg = room.timeline[0];
                     expect(joinMsg.sender?.name).toEqual("Old Alice");
@@ -353,25 +381,29 @@ describe("MatrixClient room timelines", function() {
             httpBackend!.flush("/sync", 1);
         });
 
-        it("should add it them to the right place in the timeline", function(done) {
+        it("should add it them to the right place in the timeline", function (done) {
             // set the list of events to return on scrollback
             sbEvents = [
                 utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am new",
+                    user: userId,
+                    room: roomId,
+                    msg: "I am new",
                 }),
                 utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am old",
+                    user: userId,
+                    room: roomId,
+                    msg: "I am old",
                 }),
             ];
 
-            client!.on(ClientEvent.Sync, function(state) {
+            client!.on(ClientEvent.Sync, function (state) {
                 if (state !== "PREPARED") {
                     return;
                 }
                 const room = client!.getRoom(roomId)!;
                 expect(room.timeline.length).toEqual(1);
 
-                client!.scrollback(room).then(function() {
+                client!.scrollback(room).then(function () {
                     expect(room.timeline.length).toEqual(3);
                     expect(room.timeline[0].event).toEqual(sbEvents[1]);
                     expect(room.timeline[1].event).toEqual(sbEvents[0]);
@@ -387,26 +419,28 @@ describe("MatrixClient room timelines", function() {
             httpBackend!.flush("/sync", 1);
         });
 
-        it("should use 'end' as the next pagination token", function(done) {
+        it("should use 'end' as the next pagination token", function (done) {
             // set the list of events to return on scrollback
             sbEvents = [
                 utils.mkMessage({
-                    user: userId, room: roomId, msg: "I am new",
+                    user: userId,
+                    room: roomId,
+                    msg: "I am new",
                 }),
             ];
 
-            client!.on(ClientEvent.Sync, function(state) {
+            client!.on(ClientEvent.Sync, function (state) {
                 if (state !== "PREPARED") {
                     return;
                 }
                 const room = client!.getRoom(roomId)!;
                 expect(room.oldState.paginationToken).toBeTruthy();
 
-                client!.scrollback(room, 1).then(function() {
+                client!.scrollback(room, 1).then(function () {
                     expect(room.oldState.paginationToken).toEqual(sbEndTok);
                 });
 
-                httpBackend!.flush("/messages", 1).then(function() {
+                httpBackend!.flush("/messages", 1).then(function () {
                     // still have a sync to flush
                     httpBackend!.flush("/sync", 1).then(() => {
                         done();
@@ -417,22 +451,19 @@ describe("MatrixClient room timelines", function() {
         });
     });
 
-    describe("new events", function() {
-        it("should be added to the right place in the timeline", function() {
+    describe("new events", function () {
+        it("should be added to the right place in the timeline", function () {
             const eventData = [
                 utils.mkMessage({ user: userId, room: roomId }),
                 utils.mkMessage({ user: userId, room: roomId }),
             ];
             setNextSyncData(eventData);
 
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
                 const room = client!.getRoom(roomId)!;
 
                 let index = 0;
-                client!.on(RoomEvent.Timeline, function(event, rm, toStart) {
+                client!.on(RoomEvent.Timeline, function (event, rm, toStart) {
                     expect(toStart).toBe(false);
                     expect(rm).toEqual(room);
                     expect(event.event).toEqual(eventData[index]);
@@ -440,41 +471,31 @@ describe("MatrixClient room timelines", function() {
                 });
 
                 httpBackend!.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
                     expect(index).toEqual(2);
                     expect(room.timeline.length).toEqual(3);
-                    expect(room.timeline[2].event).toEqual(
-                        eventData[1],
-                    );
-                    expect(room.timeline[1].event).toEqual(
-                        eventData[0],
-                    );
+                    expect(room.timeline[2].event).toEqual(eventData[1]);
+                    expect(room.timeline[1].event).toEqual(eventData[0]);
                 });
             });
         });
 
-        it("should set the right event.sender values", function() {
+        it("should set the right event.sender values", function () {
             const eventData = [
                 utils.mkMessage({ user: userId, room: roomId }),
                 utils.mkMembership({
-                    user: userId, room: roomId, mship: "join", name: "New Name",
+                    user: userId,
+                    room: roomId,
+                    mship: "join",
+                    name: "New Name",
                 }),
                 utils.mkMessage({ user: userId, room: roomId }),
             ];
             setNextSyncData(eventData);
 
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
                 const room = client!.getRoom(roomId)!;
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
                     const preNameEvent = room.timeline[room.timeline.length - 3];
                     const postNameEvent = room.timeline[room.timeline.length - 1];
                     expect(preNameEvent.sender?.name).toEqual(userName);
@@ -483,90 +504,83 @@ describe("MatrixClient room timelines", function() {
             });
         });
 
-        it("should set the right room.name", function() {
+        it("should set the right room.name", function () {
             const secondRoomNameEvent = utils.mkEvent({
-                user: userId, room: roomId, type: "m.room.name", content: {
+                user: userId,
+                room: roomId,
+                type: "m.room.name",
+                content: {
                     name: "Room 2",
                 },
             });
             setNextSyncData([secondRoomNameEvent]);
 
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
                 const room = client!.getRoom(roomId)!;
                 let nameEmitCount = 0;
-                client!.on(RoomEvent.Name, function(rm) {
+                client!.on(RoomEvent.Name, function (rm) {
                     nameEmitCount += 1;
                 });
 
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
-                    expect(nameEmitCount).toEqual(1);
-                    expect(room.name).toEqual("Room 2");
-                    // do another round
-                    const thirdRoomNameEvent = utils.mkEvent({
-                        user: userId, room: roomId, type: "m.room.name", content: {
-                            name: "Room 3",
-                        },
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)])
+                    .then(function () {
+                        expect(nameEmitCount).toEqual(1);
+                        expect(room.name).toEqual("Room 2");
+                        // do another round
+                        const thirdRoomNameEvent = utils.mkEvent({
+                            user: userId,
+                            room: roomId,
+                            type: "m.room.name",
+                            content: {
+                                name: "Room 3",
+                            },
+                        });
+                        setNextSyncData([thirdRoomNameEvent]);
+                        httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
+                        return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]);
+                    })
+                    .then(function () {
+                        expect(nameEmitCount).toEqual(2);
+                        expect(room.name).toEqual("Room 3");
                     });
-                    setNextSyncData([thirdRoomNameEvent]);
-                    httpBackend!.when("GET", "/sync").respond(200, NEXT_SYNC_DATA);
-                    return Promise.all([
-                        httpBackend!.flush("/sync", 1),
-                        utils.syncPromise(client!),
-                    ]);
-                }).then(function() {
-                    expect(nameEmitCount).toEqual(2);
-                    expect(room.name).toEqual("Room 3");
-                });
             });
         });
 
-        it("should set the right room members", function() {
+        it("should set the right room members", function () {
             const userC = "@cee:bar";
             const userD = "@dee:bar";
             const eventData = [
                 utils.mkMembership({
-                    user: userC, room: roomId, mship: "join", name: "C",
+                    user: userC,
+                    room: roomId,
+                    mship: "join",
+                    name: "C",
                 }),
                 utils.mkMembership({
-                    user: userC, room: roomId, mship: "invite", skey: userD,
+                    user: userC,
+                    room: roomId,
+                    mship: "invite",
+                    skey: userD,
                 }),
             ];
             setNextSyncData(eventData);
 
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
                 const room = client!.getRoom(roomId)!;
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
                     expect(room.currentState.getMembers().length).toEqual(4);
                     expect(room.currentState.getMember(userC)!.name).toEqual("C");
-                    expect(room.currentState.getMember(userC)!.membership).toEqual(
-                        "join",
-                    );
+                    expect(room.currentState.getMember(userC)!.membership).toEqual("join");
                     expect(room.currentState.getMember(userD)!.name).toEqual(userD);
-                    expect(room.currentState.getMember(userD)!.membership).toEqual(
-                        "invite",
-                    );
+                    expect(room.currentState.getMember(userD)!.membership).toEqual("invite");
                 });
             });
         });
     });
 
-    describe("gappy sync", function() {
-        it("should copy the last known state to the new timeline", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
+    describe("gappy sync", function () {
+        it("should copy the last known state to the new timeline", function () {
+            const eventData = [utils.mkMessage({ user: userId, room: roomId })];
             setNextSyncData(eventData);
             NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
 
@@ -578,72 +592,56 @@ describe("MatrixClient room timelines", function() {
                 const room = client!.getRoom(roomId)!;
 
                 httpBackend!.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
                     expect(room.timeline.length).toEqual(1);
                     expect(room.timeline[0].event).toEqual(eventData[0]);
                     expect(room.currentState.getMembers().length).toEqual(2);
                     expect(room.currentState.getMember(userId)!.name).toEqual(userName);
-                    expect(room.currentState.getMember(userId)!.membership).toEqual(
-                        "join",
-                    );
+                    expect(room.currentState.getMember(userId)!.membership).toEqual("join");
                     expect(room.currentState.getMember(otherUserId)!.name).toEqual("Bob");
-                    expect(room.currentState.getMember(otherUserId)!.membership).toEqual(
-                        "join",
-                    );
+                    expect(room.currentState.getMember(otherUserId)!.membership).toEqual("join");
                 });
             });
         });
 
-        it("should emit a `RoomEvent.TimelineReset` event when the sync response is `limited`", function() {
-            const eventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
+        it("should emit a `RoomEvent.TimelineReset` event when the sync response is `limited`", function () {
+            const eventData = [utils.mkMessage({ user: userId, room: roomId })];
             setNextSyncData(eventData);
             NEXT_SYNC_DATA.rooms!.join[roomId].timeline.limited = true;
 
-            return Promise.all([
-                httpBackend!.flush("/sync", 1),
-                utils.syncPromise(client!),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(() => {
                 const room = client!.getRoom(roomId)!;
 
                 let emitCount = 0;
-                client!.on(RoomEvent.TimelineReset, function(emitRoom) {
+                client!.on(RoomEvent.TimelineReset, function (emitRoom) {
                     expect(emitRoom).toEqual(room);
                     emitCount++;
                 });
 
                 httpBackend!.flush("/messages", 1);
-                return Promise.all([
-                    httpBackend!.flush("/sync", 1),
-                    utils.syncPromise(client!),
-                ]).then(function() {
+                return Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!)]).then(function () {
                     expect(emitCount).toEqual(1);
                 });
             });
         });
     });
 
-    describe('Refresh live timeline', () => {
+    describe("Refresh live timeline", () => {
         const initialSyncEventData = [
             utils.mkMessage({ user: userId, room: roomId }),
             utils.mkMessage({ user: userId, room: roomId }),
             utils.mkMessage({ user: userId, room: roomId }),
         ];
 
-        const contextUrl = `/rooms/${encodeURIComponent(roomId)}/context/` +
-        `${encodeURIComponent(initialSyncEventData[2].event_id!)}`;
+        const contextUrl =
+            `/rooms/${encodeURIComponent(roomId)}/context/` +
+            `${encodeURIComponent(initialSyncEventData[2].event_id!)}`;
         const contextResponse = {
             start: "start_token",
             events_before: [initialSyncEventData[1], initialSyncEventData[0]],
             event: initialSyncEventData[2],
             events_after: [],
-            state: [
-                USER_MEMBERSHIP_EVENT,
-            ],
+            state: [USER_MEMBERSHIP_EVENT],
             end: "end_token",
         };
 
@@ -652,32 +650,25 @@ describe("MatrixClient room timelines", function() {
             setNextSyncData(initialSyncEventData);
 
             // Create a room from the sync
-            await Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 1),
-            ]);
+            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
 
             // Get the room after the first sync so the room is created
             room = client!.getRoom(roomId)!;
             expect(room).toBeTruthy();
         });
 
-        it('should clear and refresh messages in timeline', async () => {
+        it("should clear and refresh messages in timeline", async () => {
             // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
             // to construct a new timeline from.
-            httpBackend!.when("GET", contextUrl)
-                .respond(200, function() {
-                    // The timeline should be cleared at this point in the refresh
-                    expect(room.timeline.length).toEqual(0);
+            httpBackend!.when("GET", contextUrl).respond(200, function () {
+                // The timeline should be cleared at this point in the refresh
+                expect(room.timeline.length).toEqual(0);
 
-                    return contextResponse;
-                });
+                return contextResponse;
+            });
 
             // Refresh the timeline.
-            await Promise.all([
-                room.refreshLiveTimeline(),
-                httpBackend!.flushAllExpected(),
-            ]);
+            await Promise.all([room.refreshLiveTimeline(), httpBackend!.flushAllExpected()]);
 
             // Make sure the message are visible
             const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
@@ -689,7 +680,7 @@ describe("MatrixClient room timelines", function() {
             ]);
         });
 
-        it('Perfectly merges timelines if a sync finishes while refreshing the timeline', async () => {
+        it("Perfectly merges timelines if a sync finishes while refreshing the timeline", async () => {
             // `/context` request for `refreshLiveTimeline()` ->
             // `getEventTimeline()` to construct a new timeline from.
             //
@@ -698,11 +689,10 @@ describe("MatrixClient room timelines", function() {
             // middle of all of this refresh timeline logic. We want to make
             // sure the sync pagination still works as expected after messing
             // the refresh timline logic messes with the pagination tokens.
-            httpBackend!.when("GET", contextUrl)
-                .respond(200, () => {
-                    // Now finally return and make the `/context` request respond
-                    return contextResponse;
-                });
+            httpBackend!.when("GET", contextUrl).respond(200, () => {
+                // Now finally return and make the `/context` request respond
+                return contextResponse;
+            });
 
             // Wait for the timeline to reset(when it goes blank) which means
             // it's in the middle of the refrsh logic right before the
@@ -714,22 +704,20 @@ describe("MatrixClient room timelines", function() {
             //
             // We define this here so the event listener is in place before we
             // call `room.refreshLiveTimeline()`.
-            const racingSyncEventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
+            const racingSyncEventData = [utils.mkMessage({ user: userId, room: roomId })];
             const waitForRaceySyncAfterResetPromise = new Promise<void>((resolve, reject) => {
                 let eventFired = false;
                 // Throw a more descriptive error if this part of the test times out.
                 const failTimeout = setTimeout(() => {
                     if (eventFired) {
-                        reject(new Error(
-                            'TestError: `RoomEvent.TimelineReset` fired but we timed out trying to make' +
-                            'a `/sync` happen in time.',
-                        ));
+                        reject(
+                            new Error(
+                                "TestError: `RoomEvent.TimelineReset` fired but we timed out trying to make" +
+                                    "a `/sync` happen in time.",
+                            ),
+                        );
                     } else {
-                        reject(new Error(
-                            'TestError: Timed out while waiting for `RoomEvent.TimelineReset` to fire.',
-                        ));
+                        reject(new Error("TestError: Timed out while waiting for `RoomEvent.TimelineReset` to fire."));
                     }
                 }, 4000 /* FIXME: Is there a way to reference the current timeout of this test in Jest? */);
 
@@ -743,23 +731,19 @@ describe("MatrixClient room timelines", function() {
                         // Then make a `/sync` happen by sending a message and seeing that it
                         // shows up (simulate a /sync naturally racing with us).
                         setNextSyncData(racingSyncEventData);
-                        httpBackend!.when("GET", "/sync").respond(200, function() {
+                        httpBackend!.when("GET", "/sync").respond(200, function () {
                             return NEXT_SYNC_DATA;
                         });
-                        await Promise.all([
-                            httpBackend!.flush("/sync", 1),
-                            utils.syncPromise(client!, 1),
-                        ]);
+                        await Promise.all([httpBackend!.flush("/sync", 1), utils.syncPromise(client!, 1)]);
                         // Make sure the timeline has the racey sync data
                         const afterRaceySyncTimelineEvents = room
                             .getUnfilteredTimelineSet()
                             .getLiveTimeline()
                             .getEvents();
-                        const afterRaceySyncTimelineEventIds = afterRaceySyncTimelineEvents
-                            .map((event) => event.getId());
-                        expect(afterRaceySyncTimelineEventIds).toEqual([
-                            racingSyncEventData[0].event_id,
-                        ]);
+                        const afterRaceySyncTimelineEventIds = afterRaceySyncTimelineEvents.map((event) =>
+                            event.getId(),
+                        );
+                        expect(afterRaceySyncTimelineEventIds).toEqual([racingSyncEventData[0].event_id]);
 
                         clearTimeout(failTimeout);
                         resolve();
@@ -783,17 +767,12 @@ describe("MatrixClient room timelines", function() {
 
             // Make sure sync pagination still works by seeing a new message show up
             // after refreshing the timeline.
-            const afterRefreshEventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
+            const afterRefreshEventData = [utils.mkMessage({ user: userId, room: roomId })];
             setNextSyncData(afterRefreshEventData);
-            httpBackend!.when("GET", "/sync").respond(200, function() {
+            httpBackend!.when("GET", "/sync").respond(200, function () {
                 return NEXT_SYNC_DATA;
             });
-            await Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 1),
-            ]);
+            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
 
             // Make sure the timeline includes the the events from the `/sync`
             // that raced and beat us in the middle of everything and the
@@ -808,17 +787,24 @@ describe("MatrixClient room timelines", function() {
             ]);
         });
 
-        it('Timeline recovers after `/context` request to generate new timeline fails', async () => {
+        it("Timeline recovers after `/context` request to generate new timeline fails", async () => {
             // `/context` request for `refreshLiveTimeline()` -> `getEventTimeline()`
             // to construct a new timeline from.
-            httpBackend!.when("GET", contextUrl).check(() => {
-                // The timeline should be cleared at this point in the refresh
-                expect(room.timeline.length).toEqual(0);
-            }).respond(500, new MatrixError({
-                errcode: 'TEST_FAKE_ERROR',
-                error: 'We purposely intercepted this /context request to make it fail ' +
-                    'in order to test whether the refresh timeline code is resilient',
-            }));
+            httpBackend!
+                .when("GET", contextUrl)
+                .check(() => {
+                    // The timeline should be cleared at this point in the refresh
+                    expect(room.timeline.length).toEqual(0);
+                })
+                .respond(
+                    500,
+                    new MatrixError({
+                        errcode: "TEST_FAKE_ERROR",
+                        error:
+                            "We purposely intercepted this /context request to make it fail " +
+                            "in order to test whether the refresh timeline code is resilient",
+                    }),
+                );
 
             // Refresh the timeline and expect it to fail
             const settledFailedRefreshPromises = await Promise.allSettled([
@@ -827,9 +813,9 @@ describe("MatrixClient room timelines", function() {
             ]);
             // We only expect `TEST_FAKE_ERROR` here. Anything else is
             // unexpected and should fail the test.
-            if (settledFailedRefreshPromises[0].status === 'fulfilled') {
-                throw new Error('Expected the /context request to fail with a 500');
-            } else if (settledFailedRefreshPromises[0].reason.errcode !== 'TEST_FAKE_ERROR') {
+            if (settledFailedRefreshPromises[0].status === "fulfilled") {
+                throw new Error("Expected the /context request to fail with a 500");
+            } else if (settledFailedRefreshPromises[0].reason.errcode !== "TEST_FAKE_ERROR") {
                 throw settledFailedRefreshPromises[0].reason;
             }
 
@@ -839,45 +825,37 @@ describe("MatrixClient room timelines", function() {
 
             // `/messages` request for `refreshLiveTimeline()` ->
             // `getLatestTimeline()` to construct a new timeline from.
-            httpBackend!.when("GET", `/rooms/${encodeURIComponent(roomId)}/messages`)
-                .respond(200, function() {
-                    return {
-                        chunk: [{
+            httpBackend!.when("GET", `/rooms/${encodeURIComponent(roomId)}/messages`).respond(200, function () {
+                return {
+                    chunk: [
+                        {
                             // The latest message in the room
                             event_id: initialSyncEventData[2].event_id,
-                        }],
-                    };
-                });
+                        },
+                    ],
+                };
+            });
             // `/context` request for `refreshLiveTimeline()` ->
             // `getLatestTimeline()` -> `getEventTimeline()` to construct a new
             // timeline from.
-            httpBackend!.when("GET", contextUrl)
-                .respond(200, function() {
-                    // The timeline should be cleared at this point in the refresh
-                    expect(room.timeline.length).toEqual(0);
+            httpBackend!.when("GET", contextUrl).respond(200, function () {
+                // The timeline should be cleared at this point in the refresh
+                expect(room.timeline.length).toEqual(0);
 
-                    return contextResponse;
-                });
+                return contextResponse;
+            });
 
             // Refresh the timeline again but this time it should pass
-            await Promise.all([
-                room.refreshLiveTimeline(),
-                httpBackend!.flushAllExpected(),
-            ]);
+            await Promise.all([room.refreshLiveTimeline(), httpBackend!.flushAllExpected()]);
 
             // Make sure sync pagination still works by seeing a new message show up
             // after refreshing the timeline.
-            const afterRefreshEventData = [
-                utils.mkMessage({ user: userId, room: roomId }),
-            ];
+            const afterRefreshEventData = [utils.mkMessage({ user: userId, room: roomId })];
             setNextSyncData(afterRefreshEventData);
-            httpBackend!.when("GET", "/sync").respond(200, function() {
+            httpBackend!.when("GET", "/sync").respond(200, function () {
                 return NEXT_SYNC_DATA;
             });
-            await Promise.all([
-                httpBackend!.flushAllExpected(),
-                utils.syncPromise(client!, 1),
-            ]);
+            await Promise.all([httpBackend!.flushAllExpected(), utils.syncPromise(client!, 1)]);
 
             // Make sure the message are visible
             const resultantEventsInTimeline = room.getUnfilteredTimelineSet().getLiveTimeline().getEvents();
diff --git a/spec/integ/matrix-client-syncing.spec.ts b/spec/integ/matrix-client-syncing.spec.ts
index 94e2361d7fe..0f92dc60d95 100644
--- a/spec/integ/matrix-client-syncing.spec.ts
+++ b/spec/integ/matrix-client-syncing.spec.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import 'fake-indexeddb/auto';
+import "fake-indexeddb/auto";
 
 import HttpBackend from "matrix-mock-request";
 
@@ -33,10 +33,12 @@ import {
     IJoinedRoom,
     IStateEvent,
     IMinimalEvent,
-    NotificationCountType, IEphemeral, Room,
+    NotificationCountType,
+    IEphemeral,
+    Room,
 } from "../../src";
-import { ReceiptType } from '../../src/@types/read_receipts';
-import { UNREAD_THREAD_NOTIFICATIONS } from '../../src/@types/sync';
+import { ReceiptType } from "../../src/@types/read_receipts";
+import { UNREAD_THREAD_NOTIFICATIONS } from "../../src/@types/sync";
 import * as utils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
 
@@ -91,9 +93,12 @@ describe("MatrixClient syncing", () => {
 
         it("should pass the 'next_batch' token from /sync to the since= param  of the next /sync", (done) => {
             httpBackend!.when("GET", "/sync").respond(200, syncData);
-            httpBackend!.when("GET", "/sync").check((req) => {
-                expect(req.queryParams!.since).toEqual(syncData.next_batch);
-            }).respond(200, syncData);
+            httpBackend!
+                .when("GET", "/sync")
+                .check((req) => {
+                    expect(req.queryParams!.since).toEqual(syncData.next_batch);
+                })
+                .respond(200, syncData);
 
             client!.startClient();
 
@@ -112,13 +117,15 @@ describe("MatrixClient syncing", () => {
                 invite: {
                     [roomId]: {
                         invite_state: {
-                            events: [{
-                                type: "m.room.member",
-                                state_key: selfUserId,
-                                content: {
-                                    membership: "invite",
+                            events: [
+                                {
+                                    type: "m.room.member",
+                                    state_key: selfUserId,
+                                    content: {
+                                        membership: "invite",
+                                    },
                                 },
-                            }],
+                            ],
                         },
                     },
                 },
@@ -138,31 +145,35 @@ describe("MatrixClient syncing", () => {
                             account_data: { events: [] },
                             ephemeral: { events: [] },
                             state: {
-                                events: [{
-                                    type: "m.room.member",
-                                    state_key: selfUserId,
-                                    content: {
-                                        membership: "leave",
-                                    },
-                                    prev_content: {
-                                        membership: "invite",
+                                events: [
+                                    {
+                                        type: "m.room.member",
+                                        state_key: selfUserId,
+                                        content: {
+                                            membership: "leave",
+                                        },
+                                        prev_content: {
+                                            membership: "invite",
+                                        },
+                                        // XXX: And other fields required on an event
                                     },
-                                    // XXX: And other fields required on an event
-                                }],
+                                ],
                             },
                             timeline: {
                                 limited: false,
-                                events: [{
-                                    type: "m.room.member",
-                                    state_key: selfUserId,
-                                    content: {
-                                        membership: "leave",
-                                    },
-                                    prev_content: {
-                                        membership: "invite",
+                                events: [
+                                    {
+                                        type: "m.room.member",
+                                        state_key: selfUserId,
+                                        content: {
+                                            membership: "leave",
+                                        },
+                                        prev_content: {
+                                            membership: "invite",
+                                        },
+                                        // XXX: And other fields required on an event
                                     },
-                                    // XXX: And other fields required on an event
-                                }],
+                                ],
                             },
                         },
                     },
@@ -177,7 +188,8 @@ describe("MatrixClient syncing", () => {
 
             // First fire: an initial invite
             let fires = 0;
-            client!.once(RoomEvent.MyMembership, (room, membership, oldMembership) => { // Room, string, string
+            client!.once(RoomEvent.MyMembership, (room, membership, oldMembership) => {
+                // Room, string, string
                 fires++;
                 expect(room.roomId).toBe(roomId);
                 expect(membership).toBe("invite");
@@ -213,9 +225,12 @@ describe("MatrixClient syncing", () => {
         it("should honour lazyLoadMembers if user is not a guest", () => {
             client!.doesServerSupportLazyLoading = jest.fn().mockResolvedValue(true);
 
-            httpBackend!.when("GET", "/sync").check((req) => {
-                expect(JSON.parse(req.queryParams!.filter).room.state.lazy_load_members).toBeTruthy();
-            }).respond(200, syncData);
+            httpBackend!
+                .when("GET", "/sync")
+                .check((req) => {
+                    expect(JSON.parse(req.queryParams!.filter).room.state.lazy_load_members).toBeTruthy();
+                })
+                .respond(200, syncData);
 
             client!.setGuest(false);
             client!.startClient({ lazyLoadMembers: true });
@@ -228,9 +243,12 @@ describe("MatrixClient syncing", () => {
             httpBackend!.when("GET", "/versions").respond(200, {});
             client!.doesServerSupportLazyLoading = jest.fn().mockResolvedValue(true);
 
-            httpBackend!.when("GET", "/sync").check((req) => {
-                expect(JSON.parse(req.queryParams!.filter).room?.state?.lazy_load_members).toBeFalsy();
-            }).respond(200, syncData);
+            httpBackend!
+                .when("GET", "/sync")
+                .check((req) => {
+                    expect(JSON.parse(req.queryParams!.filter).room?.state?.lazy_load_members).toBeFalsy();
+                })
+                .respond(200, syncData);
 
             client!.setGuest(true);
             client!.startClient({ lazyLoadMembers: true });
@@ -246,13 +264,15 @@ describe("MatrixClient syncing", () => {
                 invite: {
                     [roomId]: {
                         invite_state: {
-                            events: [{
-                                type: "m.room.member",
-                                state_key: selfUserId,
-                                content: {
-                                    membership: "invite",
+                            events: [
+                                {
+                                    type: "m.room.member",
+                                    state_key: selfUserId,
+                                    content: {
+                                        membership: "invite",
+                                    },
                                 },
-                            }],
+                            ],
                         },
                     },
                 },
@@ -280,10 +300,7 @@ describe("MatrixClient syncing", () => {
             httpBackend!.expectedRequests = [];
             httpBackend!.when("GET", "").fail(0, new Error("CORS or something"));
             const prom = client!.startClient();
-            await Promise.all([
-                expect(prom).resolves.toBeUndefined(),
-            httpBackend!.flushAllExpected(),
-            ]);
+            await Promise.all([expect(prom).resolves.toBeUndefined(), httpBackend!.flushAllExpected()]);
         });
     });
 
@@ -296,13 +313,19 @@ describe("MatrixClient syncing", () => {
 
         it("should only apply initialSyncLimit to the initial sync", () => {
             // 1st request
-            httpBackend!.when("GET", "/sync").check((req) => {
-                expect(JSON.parse(req.queryParams!.filter).room.timeline.limit).toEqual(1);
-            }).respond(200, syncData);
+            httpBackend!
+                .when("GET", "/sync")
+                .check((req) => {
+                    expect(JSON.parse(req.queryParams!.filter).room.timeline.limit).toEqual(1);
+                })
+                .respond(200, syncData);
             // 2nd request
-            httpBackend!.when("GET", "/sync").check((req) => {
-                expect(req.queryParams!.filter).toEqual("a filter id");
-            }).respond(200, syncData);
+            httpBackend!
+                .when("GET", "/sync")
+                .check((req) => {
+                    expect(req.queryParams!.filter).toEqual("a filter id");
+                })
+                .respond(200, syncData);
 
             client!.startClient({ initialSyncLimit: 1 });
 
@@ -311,9 +334,12 @@ describe("MatrixClient syncing", () => {
         });
 
         it("should not apply initialSyncLimit to a first sync if we have a stored token", () => {
-            httpBackend!.when("GET", "/sync").check((req) => {
-                expect(req.queryParams!.filter).toEqual("a filter id");
-            }).respond(200, syncData);
+            httpBackend!
+                .when("GET", "/sync")
+                .check((req) => {
+                    expect(req.queryParams!.filter).toEqual("a filter id");
+                })
+                .respond(200, syncData);
 
             client!.store.getSavedSyncToken = jest.fn().mockResolvedValue("this-is-a-token");
             client!.startClient({ initialSyncLimit: 1 });
@@ -344,20 +370,28 @@ describe("MatrixClient syncing", () => {
                 timeline: {
                     events: [
                         utils.mkMessage({
-                            room: roomOne, user: otherUserId, msg: "hello",
+                            room: roomOne,
+                            user: otherUserId,
+                            msg: "hello",
                         }) as IRoomEvent,
                     ],
                 },
                 state: {
                     events: [
                         utils.mkMembership({
-                            room: roomOne, mship: "join", user: otherUserId,
+                            room: roomOne,
+                            mship: "join",
+                            user: otherUserId,
                         }),
                         utils.mkMembership({
-                            room: roomOne, mship: "join", user: selfUserId,
+                            room: roomOne,
+                            mship: "join",
+                            user: selfUserId,
                         }),
                         utils.mkEvent({
-                            type: "m.room.create", room: roomOne, user: selfUserId,
+                            type: "m.room.create",
+                            room: roomOne,
+                            user: selfUserId,
                             content: {
                                 creator: selfUserId,
                             },
@@ -370,31 +404,26 @@ describe("MatrixClient syncing", () => {
         it("should resolve incoming invites from /sync", () => {
             syncData.rooms.join[roomOne].state.events.push(
                 utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
+                    room: roomOne,
+                    mship: "invite",
+                    user: userC,
                 }) as IStateEvent,
             );
 
             httpBackend!.when("GET", "/sync").respond(200, syncData);
-            httpBackend!.when("GET", "/profile/" + encodeURIComponent(userC)).respond(
-                200, {
-                    avatar_url: "mxc://flibble/wibble",
-                    displayname: "The Boss",
-                },
-            );
+            httpBackend!.when("GET", "/profile/" + encodeURIComponent(userC)).respond(200, {
+                avatar_url: "mxc://flibble/wibble",
+                displayname: "The Boss",
+            });
 
             client!.startClient({
                 resolveInvitesToProfiles: true,
             });
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const member = client!.getRoom(roomOne)!.getMember(userC)!;
                 expect(member.name).toEqual("The Boss");
-                expect(
-                    member.getAvatarUrl("home.server.url", 1, 1, '', false, false),
-                ).toBeTruthy();
+                expect(member.getAvatarUrl("home.server.url", 1, 1, "", false, false)).toBeTruthy();
             });
         });
 
@@ -408,7 +437,9 @@ describe("MatrixClient syncing", () => {
             ];
             syncData.rooms.join[roomOne].state.events.push(
                 utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
+                    room: roomOne,
+                    mship: "invite",
+                    user: userC,
                 }) as IStateEvent,
             );
 
@@ -418,10 +449,7 @@ describe("MatrixClient syncing", () => {
                 resolveInvitesToProfiles: true,
             });
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const member = client!.getRoom(roomOne)!.getMember(userC)!;
                 expect(member.name).toEqual("The Ghost");
             });
@@ -437,7 +465,9 @@ describe("MatrixClient syncing", () => {
             ];
             syncData.rooms.join[roomOne].state.events.push(
                 utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
+                    room: roomOne,
+                    mship: "invite",
+                    user: userC,
                 }) as IStateEvent,
             );
 
@@ -454,10 +484,7 @@ describe("MatrixClient syncing", () => {
                 resolveInvitesToProfiles: true,
             });
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 expect(latestFiredName).toEqual("The Ghost");
             });
         });
@@ -465,7 +492,9 @@ describe("MatrixClient syncing", () => {
         it("should no-op if resolveInvitesToProfiles is not set", () => {
             syncData.rooms.join[roomOne].state.events.push(
                 utils.mkMembership({
-                    room: roomOne, mship: "invite", user: userC,
+                    room: roomOne,
+                    mship: "invite",
+                    user: userC,
                 }) as IStateEvent,
             );
 
@@ -473,15 +502,10 @@ describe("MatrixClient syncing", () => {
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const member = client!.getRoom(roomOne)!.getMember(userC)!;
                 expect(member.name).toEqual(userC);
-                expect(
-                    member.getAvatarUrl("home.server.url", 1, 1, '', false, false),
-                ).toBe(null);
+                expect(member.getAvatarUrl("home.server.url", 1, 1, "", false, false)).toBe(null);
             });
         });
     });
@@ -508,10 +532,7 @@ describe("MatrixClient syncing", () => {
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 expect(client!.getUser(userA)!.presence).toEqual("online");
                 expect(client!.getUser(userB)!.presence).toEqual("unavailable");
             });
@@ -529,26 +550,36 @@ describe("MatrixClient syncing", () => {
                         timeline: {
                             events: [
                                 utils.mkMessage({
-                                    room: roomOne, user: otherUserId, msg: "hello",
+                                    room: roomOne,
+                                    user: otherUserId,
+                                    msg: "hello",
                                 }),
                             ],
                         },
                         state: {
                             events: [
                                 utils.mkEvent({
-                                    type: "m.room.name", room: roomOne, user: otherUserId,
+                                    type: "m.room.name",
+                                    room: roomOne,
+                                    user: otherUserId,
                                     content: {
                                         name: "Old room name",
                                     },
                                 }),
                                 utils.mkMembership({
-                                    room: roomOne, mship: "join", user: otherUserId,
+                                    room: roomOne,
+                                    mship: "join",
+                                    user: otherUserId,
                                 }),
                                 utils.mkMembership({
-                                    room: roomOne, mship: "join", user: selfUserId,
+                                    room: roomOne,
+                                    mship: "join",
+                                    user: selfUserId,
                                 }),
                                 utils.mkEvent({
-                                    type: "m.room.create", room: roomOne, user: selfUserId,
+                                    type: "m.room.create",
+                                    room: roomOne,
+                                    user: selfUserId,
                                     content: {
                                         creator: selfUserId,
                                     },
@@ -560,21 +591,29 @@ describe("MatrixClient syncing", () => {
                         timeline: {
                             events: [
                                 utils.mkMessage({
-                                    room: roomTwo, user: otherUserId, msg: "hiii",
+                                    room: roomTwo,
+                                    user: otherUserId,
+                                    msg: "hiii",
                                 }),
                             ],
                         },
                         state: {
                             events: [
                                 utils.mkMembership({
-                                    room: roomTwo, mship: "join", user: otherUserId,
+                                    room: roomTwo,
+                                    mship: "join",
+                                    user: otherUserId,
                                     name: otherDisplayName,
                                 }),
                                 utils.mkMembership({
-                                    room: roomTwo, mship: "join", user: selfUserId,
+                                    room: roomTwo,
+                                    mship: "join",
+                                    user: selfUserId,
                                 }),
                                 utils.mkEvent({
-                                    type: "m.room.create", room: roomTwo, user: selfUserId,
+                                    type: "m.room.create",
+                                    room: roomTwo,
+                                    user: selfUserId,
                                     content: {
                                         creator: selfUserId,
                                     },
@@ -593,7 +632,9 @@ describe("MatrixClient syncing", () => {
                         state: {
                             events: [
                                 utils.mkEvent({
-                                    type: "m.room.name", room: roomOne, user: selfUserId,
+                                    type: "m.room.name",
+                                    room: roomOne,
+                                    user: selfUserId,
                                     content: { name: "A new room name" },
                                 }),
                             ],
@@ -603,14 +644,17 @@ describe("MatrixClient syncing", () => {
                         timeline: {
                             events: [
                                 utils.mkMessage({
-                                    room: roomTwo, user: otherUserId, msg: msgText,
+                                    room: roomTwo,
+                                    user: otherUserId,
+                                    msg: msgText,
                                 }),
                             ],
                         },
                         ephemeral: {
                             events: [
                                 utils.mkEvent({
-                                    type: "m.typing", room: roomTwo,
+                                    type: "m.typing",
+                                    room: roomTwo,
                                     content: { user_ids: [otherUserId] },
                                 }),
                             ],
@@ -626,10 +670,7 @@ describe("MatrixClient syncing", () => {
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent(2)]).then(() => {
                 const room = client!.getRoom(roomOne)!;
                 // should have clobbered the name to the one from /events
                 expect(room.name).toEqual(nextSyncData.rooms.join[roomOne].state.events[0].content?.name);
@@ -642,10 +683,7 @@ describe("MatrixClient syncing", () => {
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent(2)]).then(() => {
                 const room = client!.getRoom(roomTwo)!;
                 // should have added the message from /events
                 expect(room.timeline.length).toEqual(2);
@@ -658,10 +696,7 @@ describe("MatrixClient syncing", () => {
             httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
 
             client!.startClient();
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent(2)]).then(() => {
                 const room = client!.getRoom(roomTwo)!;
                 // should use the display name of the other person.
                 expect(room.name).toEqual(otherDisplayName);
@@ -674,10 +709,7 @@ describe("MatrixClient syncing", () => {
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent(2)]).then(() => {
                 const room = client!.getRoom(roomTwo)!;
                 let member = room.getMember(otherUserId)!;
                 expect(member).toBeTruthy();
@@ -697,120 +729,122 @@ describe("MatrixClient syncing", () => {
             httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
 
             client!.startClient();
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(2),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent(2)]).then(() => {
                 const room = client!.getRoom(roomOne)!;
                 const stateAtStart = room.getLiveTimeline().getState(EventTimeline.BACKWARDS)!;
-                const startRoomNameEvent = stateAtStart.getStateEvents('m.room.name', '');
-                expect(startRoomNameEvent!.getContent().name).toEqual('Old room name');
+                const startRoomNameEvent = stateAtStart.getStateEvents("m.room.name", "");
+                expect(startRoomNameEvent!.getContent().name).toEqual("Old room name");
 
                 const stateAtEnd = room.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
-                const endRoomNameEvent = stateAtEnd.getStateEvents('m.room.name', '');
-                expect(endRoomNameEvent!.getContent().name).toEqual('A new room name');
+                const endRoomNameEvent = stateAtEnd.getStateEvents("m.room.name", "");
+                expect(endRoomNameEvent!.getContent().name).toEqual("A new room name");
             });
         });
 
-        xit("should update power levels for users in a room", () => {
-
-        });
-
-        xit("should update the room topic", () => {
+        xit("should update power levels for users in a room", () => {});
 
-        });
+        xit("should update the room topic", () => {});
 
         describe("onMarkerStateEvent", () => {
             const normalMessageEvent = utils.mkMessage({
-                room: roomOne, user: otherUserId, msg: "hello",
+                room: roomOne,
+                user: otherUserId,
+                msg: "hello",
             });
 
-            it('new marker event *NOT* from the room creator in a subsequent syncs ' +
-                'should *NOT* mark the timeline as needing a refresh', async () => {
-                const roomCreateEvent = utils.mkEvent({
-                    type: "m.room.create", room: roomOne, user: otherUserId,
-                    content: {
-                        creator: otherUserId,
-                        room_version: '9',
-                    },
-                });
-                const normalFirstSync = {
-                    next_batch: "batch_token",
-                    rooms: {
-                        join: {
-                            [roomOne]: {
-                                timeline: {
-                                    events: [normalMessageEvent],
-                                    prev_batch: "pagTok",
-                                },
-                                state: {
-                                    events: [roomCreateEvent],
+            it(
+                "new marker event *NOT* from the room creator in a subsequent syncs " +
+                    "should *NOT* mark the timeline as needing a refresh",
+                async () => {
+                    const roomCreateEvent = utils.mkEvent({
+                        type: "m.room.create",
+                        room: roomOne,
+                        user: otherUserId,
+                        content: {
+                            creator: otherUserId,
+                            room_version: "9",
+                        },
+                    });
+                    const normalFirstSync = {
+                        next_batch: "batch_token",
+                        rooms: {
+                            join: {
+                                [roomOne]: {
+                                    timeline: {
+                                        events: [normalMessageEvent],
+                                        prev_batch: "pagTok",
+                                    },
+                                    state: {
+                                        events: [roomCreateEvent],
+                                    },
                                 },
                             },
                         },
-                    },
-                };
-
-                const nextSyncData = {
-                    next_batch: "batch_token",
-                    rooms: {
-                        join: {
-                            [roomOne]: {
-                                timeline: {
-                                    events: [
-                                        // In subsequent syncs, a marker event in timeline
-                                        // range should normally trigger
-                                        // `timelineNeedsRefresh=true` but this marker isn't
-                                        // being sent by the room creator so it has no
-                                        // special meaning in existing room versions.
-                                        utils.mkEvent({
-                                            type: UNSTABLE_MSC2716_MARKER.name,
-                                            room: roomOne,
-                                            // The important part we're testing is here!
-                                            // `userC` is not the room creator.
-                                            user: userC,
-                                            skey: "",
-                                            content: {
-                                                "m.insertion_id": "$abc",
-                                            },
-                                        }),
-                                    ],
-                                    prev_batch: "pagTok",
+                    };
+
+                    const nextSyncData = {
+                        next_batch: "batch_token",
+                        rooms: {
+                            join: {
+                                [roomOne]: {
+                                    timeline: {
+                                        events: [
+                                            // In subsequent syncs, a marker event in timeline
+                                            // range should normally trigger
+                                            // `timelineNeedsRefresh=true` but this marker isn't
+                                            // being sent by the room creator so it has no
+                                            // special meaning in existing room versions.
+                                            utils.mkEvent({
+                                                type: UNSTABLE_MSC2716_MARKER.name,
+                                                room: roomOne,
+                                                // The important part we're testing is here!
+                                                // `userC` is not the room creator.
+                                                user: userC,
+                                                skey: "",
+                                                content: {
+                                                    "m.insertion_id": "$abc",
+                                                },
+                                            }),
+                                        ],
+                                        prev_batch: "pagTok",
+                                    },
                                 },
                             },
                         },
-                    },
-                };
+                    };
 
-                // Ensure the marker is being sent by someone who is not the room creator
-                // because this is the main thing we're testing in this spec.
-                const markerEvent = nextSyncData.rooms.join[roomOne].timeline.events[0];
-                expect(markerEvent.sender).toBeDefined();
-                expect(markerEvent.sender).not.toEqual(roomCreateEvent.sender);
+                    // Ensure the marker is being sent by someone who is not the room creator
+                    // because this is the main thing we're testing in this spec.
+                    const markerEvent = nextSyncData.rooms.join[roomOne].timeline.events[0];
+                    expect(markerEvent.sender).toBeDefined();
+                    expect(markerEvent.sender).not.toEqual(roomCreateEvent.sender);
 
-                httpBackend!.when("GET", "/sync").respond(200, normalFirstSync);
-                httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
+                    httpBackend!.when("GET", "/sync").respond(200, normalFirstSync);
+                    httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
 
-                client!.startClient();
-                await Promise.all([
-                    httpBackend!.flushAllExpected(),
-                    awaitSyncEvent(2),
-                ]);
+                    client!.startClient();
+                    await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent(2)]);
 
-                const room = client!.getRoom(roomOne)!;
-                expect(room.getTimelineNeedsRefresh()).toEqual(false);
-            });
+                    const room = client!.getRoom(roomOne)!;
+                    expect(room.getTimelineNeedsRefresh()).toEqual(false);
+                },
+            );
 
-            [{
-                label: 'In existing room versions (when the room creator sends the MSC2716 events)',
-                roomVersion: '9',
-            }, {
-                label: 'In a MSC2716 supported room version',
-                roomVersion: 'org.matrix.msc2716v3',
-            }].forEach((testMeta) => {
+            [
+                {
+                    label: "In existing room versions (when the room creator sends the MSC2716 events)",
+                    roomVersion: "9",
+                },
+                {
+                    label: "In a MSC2716 supported room version",
+                    roomVersion: "org.matrix.msc2716v3",
+                },
+            ].forEach((testMeta) => {
                 describe(testMeta.label, () => {
                     const roomCreateEvent = utils.mkEvent({
-                        type: "m.room.create", room: roomOne, user: otherUserId,
+                        type: "m.room.create",
+                        room: roomOne,
+                        user: otherUserId,
                         content: {
                             creator: otherUserId,
                             room_version: testMeta.roomVersion,
@@ -818,7 +852,9 @@ describe("MatrixClient syncing", () => {
                     });
 
                     const markerEventFromRoomCreator = utils.mkEvent({
-                        type: UNSTABLE_MSC2716_MARKER.name, room: roomOne, user: otherUserId,
+                        type: UNSTABLE_MSC2716_MARKER.name,
+                        room: roomOne,
+                        user: otherUserId,
                         skey: "",
                         content: {
                             "m.insertion_id": "$abc",
@@ -842,156 +878,150 @@ describe("MatrixClient syncing", () => {
                         },
                     };
 
-                    it('no marker event in sync response '+
-                        'should *NOT* mark the timeline as needing a refresh (check for a sane default)', async () => {
-                        const syncData = {
-                            next_batch: "batch_token",
-                            rooms: {
-                                join: {
-                                    [roomOne]: {
-                                        timeline: {
-                                            events: [normalMessageEvent],
-                                            prev_batch: "pagTok",
-                                        },
-                                        state: {
-                                            events: [roomCreateEvent],
+                    it(
+                        "no marker event in sync response " +
+                            "should *NOT* mark the timeline as needing a refresh (check for a sane default)",
+                        async () => {
+                            const syncData = {
+                                next_batch: "batch_token",
+                                rooms: {
+                                    join: {
+                                        [roomOne]: {
+                                            timeline: {
+                                                events: [normalMessageEvent],
+                                                prev_batch: "pagTok",
+                                            },
+                                            state: {
+                                                events: [roomCreateEvent],
+                                            },
                                         },
                                     },
                                 },
-                            },
-                        };
+                            };
 
-                        httpBackend!.when("GET", "/sync").respond(200, syncData);
+                            httpBackend!.when("GET", "/sync").respond(200, syncData);
 
-                        client!.startClient();
-                        await Promise.all([
-                            httpBackend!.flushAllExpected(),
-                            awaitSyncEvent(),
-                        ]);
+                            client!.startClient();
+                            await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
 
-                        const room = client!.getRoom(roomOne)!;
-                        expect(room.getTimelineNeedsRefresh()).toEqual(false);
-                    });
-
-                    it('marker event already sent within timeline range when you join ' +
-                        'should *NOT* mark the timeline as needing a refresh (timelineWasEmpty)', async () => {
-                        const syncData = {
-                            next_batch: "batch_token",
-                            rooms: {
-                                join: {
-                                    [roomOne]: {
-                                        timeline: {
-                                            events: [markerEventFromRoomCreator],
-                                            prev_batch: "pagTok",
-                                        },
-                                        state: {
-                                            events: [roomCreateEvent],
+                            const room = client!.getRoom(roomOne)!;
+                            expect(room.getTimelineNeedsRefresh()).toEqual(false);
+                        },
+                    );
+
+                    it(
+                        "marker event already sent within timeline range when you join " +
+                            "should *NOT* mark the timeline as needing a refresh (timelineWasEmpty)",
+                        async () => {
+                            const syncData = {
+                                next_batch: "batch_token",
+                                rooms: {
+                                    join: {
+                                        [roomOne]: {
+                                            timeline: {
+                                                events: [markerEventFromRoomCreator],
+                                                prev_batch: "pagTok",
+                                            },
+                                            state: {
+                                                events: [roomCreateEvent],
+                                            },
                                         },
                                     },
                                 },
-                            },
-                        };
-
-                        httpBackend!.when("GET", "/sync").respond(200, syncData);
+                            };
 
-                        client!.startClient();
-                        await Promise.all([
-                            httpBackend!.flushAllExpected(),
-                            awaitSyncEvent(),
-                        ]);
+                            httpBackend!.when("GET", "/sync").respond(200, syncData);
 
-                        const room = client!.getRoom(roomOne)!;
-                        expect(room.getTimelineNeedsRefresh()).toEqual(false);
-                    });
+                            client!.startClient();
+                            await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
 
-                    it('marker event already sent before joining (in state) ' +
-                        'should *NOT* mark the timeline as needing a refresh (timelineWasEmpty)', async () => {
-                        const syncData = {
-                            next_batch: "batch_token",
-                            rooms: {
-                                join: {
-                                    [roomOne]: {
-                                        timeline: {
-                                            events: [normalMessageEvent],
-                                            prev_batch: "pagTok",
-                                        },
-                                        state: {
-                                            events: [
-                                                roomCreateEvent,
-                                                markerEventFromRoomCreator,
-                                            ],
+                            const room = client!.getRoom(roomOne)!;
+                            expect(room.getTimelineNeedsRefresh()).toEqual(false);
+                        },
+                    );
+
+                    it(
+                        "marker event already sent before joining (in state) " +
+                            "should *NOT* mark the timeline as needing a refresh (timelineWasEmpty)",
+                        async () => {
+                            const syncData = {
+                                next_batch: "batch_token",
+                                rooms: {
+                                    join: {
+                                        [roomOne]: {
+                                            timeline: {
+                                                events: [normalMessageEvent],
+                                                prev_batch: "pagTok",
+                                            },
+                                            state: {
+                                                events: [roomCreateEvent, markerEventFromRoomCreator],
+                                            },
                                         },
                                     },
                                 },
-                            },
-                        };
+                            };
 
-                        httpBackend!.when("GET", "/sync").respond(200, syncData);
+                            httpBackend!.when("GET", "/sync").respond(200, syncData);
 
-                        client!.startClient();
-                        await Promise.all([
-                            httpBackend!.flushAllExpected(),
-                            awaitSyncEvent(),
-                        ]);
+                            client!.startClient();
+                            await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
 
-                        const room = client!.getRoom(roomOne)!;
-                        expect(room.getTimelineNeedsRefresh()).toEqual(false);
-                    });
-
-                    it('new marker event in a subsequent syncs timeline range ' +
-                        'should mark the timeline as needing a refresh', async () => {
-                        const nextSyncData = {
-                            next_batch: "batch_token",
-                            rooms: {
-                                join: {
-                                    [roomOne]: {
-                                        timeline: {
-                                            events: [
-                                                // In subsequent syncs, a marker event in timeline
-                                                // range should trigger `timelineNeedsRefresh=true`
-                                                markerEventFromRoomCreator,
-                                            ],
-                                            prev_batch: "pagTok",
+                            const room = client!.getRoom(roomOne)!;
+                            expect(room.getTimelineNeedsRefresh()).toEqual(false);
+                        },
+                    );
+
+                    it(
+                        "new marker event in a subsequent syncs timeline range " +
+                            "should mark the timeline as needing a refresh",
+                        async () => {
+                            const nextSyncData = {
+                                next_batch: "batch_token",
+                                rooms: {
+                                    join: {
+                                        [roomOne]: {
+                                            timeline: {
+                                                events: [
+                                                    // In subsequent syncs, a marker event in timeline
+                                                    // range should trigger `timelineNeedsRefresh=true`
+                                                    markerEventFromRoomCreator,
+                                                ],
+                                                prev_batch: "pagTok",
+                                            },
                                         },
                                     },
                                 },
-                            },
-                        };
+                            };
 
-                        const markerEventId = nextSyncData.rooms.join[roomOne].timeline.events[0].event_id;
+                            const markerEventId = nextSyncData.rooms.join[roomOne].timeline.events[0].event_id;
 
-                        // Only do the first sync
-                        httpBackend!.when("GET", "/sync").respond(200, normalFirstSync);
-                        client!.startClient();
-                        await Promise.all([
-                            httpBackend!.flushAllExpected(),
-                            awaitSyncEvent(),
-                        ]);
+                            // Only do the first sync
+                            httpBackend!.when("GET", "/sync").respond(200, normalFirstSync);
+                            client!.startClient();
+                            await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
 
-                        // Get the room after the first sync so the room is created
-                        const room = client!.getRoom(roomOne)!;
+                            // Get the room after the first sync so the room is created
+                            const room = client!.getRoom(roomOne)!;
 
-                        let emitCount = 0;
-                        room.on(RoomEvent.HistoryImportedWithinTimeline, (markerEvent, room) => {
-                            expect(markerEvent.getId()).toEqual(markerEventId);
-                            expect(room.roomId).toEqual(roomOne);
-                            emitCount += 1;
-                        });
+                            let emitCount = 0;
+                            room.on(RoomEvent.HistoryImportedWithinTimeline, (markerEvent, room) => {
+                                expect(markerEvent.getId()).toEqual(markerEventId);
+                                expect(room.roomId).toEqual(roomOne);
+                                emitCount += 1;
+                            });
 
-                        // Now do a subsequent sync with the marker event
-                        httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
-                        await Promise.all([
-                            httpBackend!.flushAllExpected(),
-                            awaitSyncEvent(),
-                        ]);
+                            // Now do a subsequent sync with the marker event
+                            httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
+                            await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
 
-                        expect(room.getTimelineNeedsRefresh()).toEqual(true);
-                        // Make sure `RoomEvent.HistoryImportedWithinTimeline` was emitted
-                        expect(emitCount).toEqual(1);
-                    });
+                            expect(room.getTimelineNeedsRefresh()).toEqual(true);
+                            // Make sure `RoomEvent.HistoryImportedWithinTimeline` was emitted
+                            expect(emitCount).toEqual(1);
+                        },
+                    );
 
                     // Mimic a marker event being sent far back in the scroll back but since our last sync
-                    it('new marker event in sync state should mark the timeline as needing a refresh', async () => {
+                    it("new marker event in sync state should mark the timeline as needing a refresh", async () => {
                         const nextSyncData = {
                             next_batch: "batch_token",
                             rooms: {
@@ -1000,7 +1030,9 @@ describe("MatrixClient syncing", () => {
                                         timeline: {
                                             events: [
                                                 utils.mkMessage({
-                                                    room: roomOne, user: otherUserId, msg: "hello again",
+                                                    room: roomOne,
+                                                    user: otherUserId,
+                                                    msg: "hello again",
                                                 }),
                                             ],
                                             prev_batch: "pagTok",
@@ -1021,10 +1053,7 @@ describe("MatrixClient syncing", () => {
                         httpBackend!.when("GET", "/sync").respond(200, nextSyncData);
 
                         client!.startClient();
-                        await Promise.all([
-                            httpBackend!.flushAllExpected(),
-                            awaitSyncEvent(2),
-                        ]);
+                        await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent(2)]);
 
                         const room = client!.getRoom(roomOne)!;
                         expect(room.getTimelineNeedsRefresh()).toEqual(true);
@@ -1035,112 +1064,116 @@ describe("MatrixClient syncing", () => {
 
         // Make sure the state listeners work and events are re-emitted properly from
         // the client regardless if we reset and refresh the timeline.
-        describe('state listeners and re-registered when RoomEvent.CurrentStateUpdated is fired', () => {
+        describe("state listeners and re-registered when RoomEvent.CurrentStateUpdated is fired", () => {
             const EVENTS = [
                 utils.mkMessage({
-                    room: roomOne, user: userA, msg: "we",
+                    room: roomOne,
+                    user: userA,
+                    msg: "we",
                 }),
                 utils.mkMessage({
-                    room: roomOne, user: userA, msg: "could",
+                    room: roomOne,
+                    user: userA,
+                    msg: "could",
                 }),
                 utils.mkMessage({
-                    room: roomOne, user: userA, msg: "be",
+                    room: roomOne,
+                    user: userA,
+                    msg: "be",
                 }),
                 utils.mkMessage({
-                    room: roomOne, user: userA, msg: "heroes",
+                    room: roomOne,
+                    user: userA,
+                    msg: "heroes",
                 }),
             ];
 
             const SOME_STATE_EVENT = utils.mkEvent({
                 event: true,
-                type: 'org.matrix.test_state',
+                type: "org.matrix.test_state",
                 room: roomOne,
                 user: userA,
                 skey: "",
                 content: {
-                    "foo": "bar",
+                    foo: "bar",
                 },
             });
 
             const USER_MEMBERSHIP_EVENT = utils.mkMembership({
-                room: roomOne, mship: "join", user: userA,
+                room: roomOne,
+                mship: "join",
+                user: userA,
             });
 
             // This appears to work even if we comment out
             // `RoomEvent.CurrentStateUpdated` part which triggers everything to
             // re-listen after the `room.currentState` reference changes. I'm
             // not sure how it's getting re-emitted.
-            it("should be able to listen to state events even after " +
-               "the timeline is reset during `limited` sync response", async () => {
-                // Create a room from the sync
-                httpBackend!.when("GET", "/sync").respond(200, syncData);
-                client!.startClient();
-                await Promise.all([
-                    httpBackend!.flushAllExpected(),
-                    awaitSyncEvent(),
-                ]);
-
-                // Get the room after the first sync so the room is created
-                const room = client!.getRoom(roomOne)!;
-                expect(room).toBeTruthy();
-
-                let stateEventEmitCount = 0;
-                client!.on(RoomStateEvent.Update, () => {
-                    stateEventEmitCount += 1;
-                });
+            it(
+                "should be able to listen to state events even after " +
+                    "the timeline is reset during `limited` sync response",
+                async () => {
+                    // Create a room from the sync
+                    httpBackend!.when("GET", "/sync").respond(200, syncData);
+                    client!.startClient();
+                    await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
+
+                    // Get the room after the first sync so the room is created
+                    const room = client!.getRoom(roomOne)!;
+                    expect(room).toBeTruthy();
+
+                    let stateEventEmitCount = 0;
+                    client!.on(RoomStateEvent.Update, () => {
+                        stateEventEmitCount += 1;
+                    });
 
-                // Cause `RoomStateEvent.Update` to be fired
-                room.currentState.setStateEvents([SOME_STATE_EVENT]);
-                // Make sure we can listen to the room state events before the reset
-                expect(stateEventEmitCount).toEqual(1);
+                    // Cause `RoomStateEvent.Update` to be fired
+                    room.currentState.setStateEvents([SOME_STATE_EVENT]);
+                    // Make sure we can listen to the room state events before the reset
+                    expect(stateEventEmitCount).toEqual(1);
 
-                // Make a `limited` sync which will cause a `room.resetLiveTimeline`
-                const limitedSyncData = {
-                    next_batch: "batch_token",
-                    rooms: {
-                        join: {
-                            [roomOne]: {
-                                timeline: {
-                                    events: [
-                                        utils.mkMessage({
-                                            room: roomOne, user: otherUserId, msg: "world",
-                                        }),
-                                    ],
-                                    // The important part, make the sync `limited`
-                                    limited: true,
-                                    prev_batch: "newerTok",
+                    // Make a `limited` sync which will cause a `room.resetLiveTimeline`
+                    const limitedSyncData = {
+                        next_batch: "batch_token",
+                        rooms: {
+                            join: {
+                                [roomOne]: {
+                                    timeline: {
+                                        events: [
+                                            utils.mkMessage({
+                                                room: roomOne,
+                                                user: otherUserId,
+                                                msg: "world",
+                                            }),
+                                        ],
+                                        // The important part, make the sync `limited`
+                                        limited: true,
+                                        prev_batch: "newerTok",
+                                    },
                                 },
                             },
                         },
-                    },
-                };
-                httpBackend!.when("GET", "/sync").respond(200, limitedSyncData);
+                    };
+                    httpBackend!.when("GET", "/sync").respond(200, limitedSyncData);
 
-                await Promise.all([
-                    httpBackend!.flushAllExpected(),
-                    awaitSyncEvent(),
-                ]);
+                    await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
 
-                // This got incremented again from processing the sync response
-                expect(stateEventEmitCount).toEqual(2);
+                    // This got incremented again from processing the sync response
+                    expect(stateEventEmitCount).toEqual(2);
 
-                // Cause `RoomStateEvent.Update` to be fired
-                room.currentState.setStateEvents([SOME_STATE_EVENT]);
-                // Make sure we can still listen to the room state events after the reset
-                expect(stateEventEmitCount).toEqual(3);
-            });
+                    // Cause `RoomStateEvent.Update` to be fired
+                    room.currentState.setStateEvents([SOME_STATE_EVENT]);
+                    // Make sure we can still listen to the room state events after the reset
+                    expect(stateEventEmitCount).toEqual(3);
+                },
+            );
 
             // Make sure it re-registers the state listeners after the
             // `room.currentState` reference changes
-            it("should be able to listen to state events even after " +
-               "refreshing the timeline", async () => {
-                const testClientWithTimelineSupport = new TestClient(
-                    selfUserId,
-                    "DEVICE",
-                    selfAccessToken,
-                    undefined,
-                    { timelineSupport: true },
-                );
+            it("should be able to listen to state events even after " + "refreshing the timeline", async () => {
+                const testClientWithTimelineSupport = new TestClient(selfUserId, "DEVICE", selfAccessToken, undefined, {
+                    timelineSupport: true,
+                });
                 httpBackend = testClientWithTimelineSupport.httpBackend;
                 httpBackend!.when("GET", "/versions").respond(200, {});
                 httpBackend!.when("GET", "/pushrules").respond(200, {});
@@ -1150,10 +1183,7 @@ describe("MatrixClient syncing", () => {
                 // Create a room from the sync
                 httpBackend!.when("GET", "/sync").respond(200, syncData);
                 client!.startClient();
-                await Promise.all([
-                    httpBackend!.flushAllExpected(),
-                    awaitSyncEvent(),
-                ]);
+                await Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
 
                 // Get the room after the first sync so the room is created
                 const room = client!.getRoom(roomOne)!;
@@ -1170,28 +1200,23 @@ describe("MatrixClient syncing", () => {
                 expect(stateEventEmitCount).toEqual(1);
 
                 const eventsInRoom = syncData.rooms.join[roomOne].timeline.events;
-                const contextUrl = `/rooms/${encodeURIComponent(roomOne)}/context/` +
+                const contextUrl =
+                    `/rooms/${encodeURIComponent(roomOne)}/context/` +
                     `${encodeURIComponent(eventsInRoom[0].event_id!)}`;
-                httpBackend!.when("GET", contextUrl)
-                    .respond(200, () => {
-                        return {
-                            start: "start_token",
-                            events_before: [EVENTS[1], EVENTS[0]],
-                            event: EVENTS[2],
-                            events_after: [EVENTS[3]],
-                            state: [
-                                USER_MEMBERSHIP_EVENT,
-                            ],
-                            end: "end_token",
-                        };
-                    });
+                httpBackend!.when("GET", contextUrl).respond(200, () => {
+                    return {
+                        start: "start_token",
+                        events_before: [EVENTS[1], EVENTS[0]],
+                        event: EVENTS[2],
+                        events_after: [EVENTS[3]],
+                        state: [USER_MEMBERSHIP_EVENT],
+                        end: "end_token",
+                    };
+                });
 
                 // Refresh the timeline. This will cause the `room.currentState`
                 // reference to change
-                await Promise.all([
-                    room.refreshLiveTimeline(),
-                    httpBackend!.flushAllExpected(),
-                ]);
+                await Promise.all([room.refreshLiveTimeline(), httpBackend!.flushAllExpected()]);
 
                 // Cause `RoomStateEvent.Update` to be fired
                 room.currentState.setStateEvents([SOME_STATE_EVENT]);
@@ -1211,7 +1236,9 @@ describe("MatrixClient syncing", () => {
                             timeline: {
                                 events: [
                                     utils.mkMessage({
-                                        room: roomOne, user: otherUserId, msg: "hello",
+                                        room: roomOne,
+                                        user: otherUserId,
+                                        msg: "hello",
                                     }),
                                 ],
                                 prev_batch: "pagTok",
@@ -1224,10 +1251,7 @@ describe("MatrixClient syncing", () => {
             httpBackend!.when("GET", "/sync").respond(200, syncData);
 
             client!.startClient();
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]);
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]);
         });
 
         it("should set the back-pagination token on new rooms", () => {
@@ -1239,7 +1263,9 @@ describe("MatrixClient syncing", () => {
                             timeline: {
                                 events: [
                                     utils.mkMessage({
-                                        room: roomTwo, user: otherUserId, msg: "roomtwo",
+                                        room: roomTwo,
+                                        user: otherUserId,
+                                        msg: "roomtwo",
                                     }),
                                 ],
                                 prev_batch: "roomtwotok",
@@ -1251,14 +1277,10 @@ describe("MatrixClient syncing", () => {
 
             httpBackend!.when("GET", "/sync").respond(200, syncData);
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const room = client!.getRoom(roomTwo)!;
                 expect(room).toBeTruthy();
-                const tok = room.getLiveTimeline()
-                    .getPaginationToken(EventTimeline.BACKWARDS);
+                const tok = room.getLiveTimeline().getPaginationToken(EventTimeline.BACKWARDS);
                 expect(tok).toEqual("roomtwotok");
             });
         });
@@ -1272,7 +1294,9 @@ describe("MatrixClient syncing", () => {
                             timeline: {
                                 events: [
                                     utils.mkMessage({
-                                        room: roomOne, user: otherUserId, msg: "world",
+                                        room: roomOne,
+                                        user: otherUserId,
+                                        msg: "world",
                                     }),
                                 ],
                                 limited: true,
@@ -1295,10 +1319,7 @@ describe("MatrixClient syncing", () => {
                 expect(tok).toEqual("newerTok");
             });
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const room = client!.getRoom(roomOne)!;
                 const tl = room.getLiveTimeline();
                 expect(tl.getEvents().length).toEqual(1);
@@ -1313,35 +1334,46 @@ describe("MatrixClient syncing", () => {
                 join: {
                     [roomOne]: {
                         ephemeral: {
-                            events: [
-                            ],
+                            events: [],
                         } as IEphemeral,
                         timeline: {
                             events: [
                                 utils.mkMessage({
-                                    room: roomOne, user: otherUserId, msg: "hello",
+                                    room: roomOne,
+                                    user: otherUserId,
+                                    msg: "hello",
                                 }),
                                 utils.mkMessage({
-                                    room: roomOne, user: otherUserId, msg: "world",
+                                    room: roomOne,
+                                    user: otherUserId,
+                                    msg: "world",
                                 }),
                             ],
                         },
                         state: {
                             events: [
                                 utils.mkEvent({
-                                    type: "m.room.name", room: roomOne, user: otherUserId,
+                                    type: "m.room.name",
+                                    room: roomOne,
+                                    user: otherUserId,
                                     content: {
                                         name: "Old room name",
                                     },
                                 }),
                                 utils.mkMembership({
-                                    room: roomOne, mship: "join", user: otherUserId,
+                                    room: roomOne,
+                                    mship: "join",
+                                    user: otherUserId,
                                 }),
                                 utils.mkMembership({
-                                    room: roomOne, mship: "join", user: selfUserId,
+                                    room: roomOne,
+                                    mship: "join",
+                                    user: selfUserId,
                                 }),
                                 utils.mkEvent({
-                                    type: "m.room.create", room: roomOne, user: selfUserId,
+                                    type: "m.room.create",
+                                    room: roomOne,
+                                    user: selfUserId,
                                     content: {
                                         creator: selfUserId,
                                     },
@@ -1368,26 +1400,27 @@ describe("MatrixClient syncing", () => {
             receipt[ackEvent.event_id!]["m.read"][userC] = {
                 ts: 176592842636,
             };
-            syncData.rooms.join[roomOne].ephemeral.events = [{
-                content: receipt,
-                type: "m.receipt",
-            }];
+            syncData.rooms.join[roomOne].ephemeral.events = [
+                {
+                    content: receipt,
+                    type: "m.receipt",
+                },
+            ];
             httpBackend!.when("GET", "/sync").respond(200, syncData);
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const room = client!.getRoom(roomOne)!;
-                expect(room.getReceiptsForEvent(new MatrixEvent(ackEvent))).toEqual([{
-                    type: "m.read",
-                    userId: userC,
-                    data: {
-                        ts: 176592842636,
+                expect(room.getReceiptsForEvent(new MatrixEvent(ackEvent))).toEqual([
+                    {
+                        type: "m.read",
+                        userId: userC,
+                        data: {
+                            ts: 176592842636,
+                        },
                     },
-                }]);
+                ]);
             });
         });
     });
@@ -1405,29 +1438,41 @@ describe("MatrixClient syncing", () => {
                         timeline: {
                             events: [
                                 utils.mkMessage({
-                                    room: roomOne, user: otherUserId, msg: "hello",
+                                    room: roomOne,
+                                    user: otherUserId,
+                                    msg: "hello",
                                 }),
                                 utils.mkMessage({
-                                    room: roomOne, user: otherUserId, msg: "world",
+                                    room: roomOne,
+                                    user: otherUserId,
+                                    msg: "world",
                                 }),
                             ],
                         },
                         state: {
                             events: [
                                 utils.mkEvent({
-                                    type: "m.room.name", room: roomOne, user: otherUserId,
+                                    type: "m.room.name",
+                                    room: roomOne,
+                                    user: otherUserId,
                                     content: {
                                         name: "Room name",
                                     },
                                 }),
                                 utils.mkMembership({
-                                    room: roomOne, mship: "join", user: otherUserId,
+                                    room: roomOne,
+                                    mship: "join",
+                                    user: otherUserId,
                                 }),
                                 utils.mkMembership({
-                                    room: roomOne, mship: "join", user: selfUserId,
+                                    room: roomOne,
+                                    mship: "join",
+                                    user: selfUserId,
                                 }),
                                 utils.mkEvent({
-                                    type: "m.room.create", room: roomOne, user: selfUserId,
+                                    type: "m.room.create",
+                                    room: roomOne,
+                                    user: selfUserId,
                                     content: {
                                         creator: selfUserId,
                                     },
@@ -1441,8 +1486,8 @@ describe("MatrixClient syncing", () => {
         it("should sync unread notifications.", () => {
             syncData.rooms.join[roomOne][UNREAD_THREAD_NOTIFICATIONS.name] = {
                 [THREAD_ID]: {
-                    "highlight_count": 2,
-                    "notification_count": 5,
+                    highlight_count: 2,
+                    notification_count: 5,
                 },
             };
 
@@ -1450,10 +1495,7 @@ describe("MatrixClient syncing", () => {
 
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const room = client!.getRoom(roomOne);
 
                 expect(room!.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total)).toBe(5);
@@ -1480,10 +1522,7 @@ describe("MatrixClient syncing", () => {
             httpBackend!.when("GET", "/sync").respond(200, syncData);
             client!.startClient();
 
-            return Promise.all([
-                httpBackend!.flushAllExpected(),
-                awaitSyncEvent(),
-            ]).then(() => {
+            return Promise.all([httpBackend!.flushAllExpected(), awaitSyncEvent()]).then(() => {
                 const room = client?.getRoom(roomOne);
                 expect(room).toBeInstanceOf(Room);
 
@@ -1496,25 +1535,24 @@ describe("MatrixClient syncing", () => {
                 const receipt = thread.getReadReceiptForUserId("@alice:localhost");
 
                 expect(receipt).toStrictEqual({
-                    "data": {
-                        "thread_id": "$unknownthread:localhost",
-                        "ts": 666,
+                    data: {
+                        thread_id: "$unknownthread:localhost",
+                        ts: 666,
                     },
-                    "eventId": "$event1:localhost",
+                    eventId: "$event1:localhost",
                 });
             });
         });
     });
 
     describe("of a room", () => {
-        xit("should sync when a join event (which changes state) for the user" +
-        " arrives down the event stream (e.g. join from another device)", () => {
-
-        });
-
-        xit("should sync when the user explicitly calls joinRoom", () => {
+        xit(
+            "should sync when a join event (which changes state) for the user" +
+                " arrives down the event stream (e.g. join from another device)",
+            () => {},
+        );
 
-        });
+        xit("should sync when the user explicitly calls joinRoom", () => {});
     });
 
     describe("syncLeftRooms", () => {
@@ -1532,20 +1570,26 @@ describe("MatrixClient syncing", () => {
         });
 
         it("should create and use an appropriate filter", () => {
-            httpBackend!.when("POST", "/filter").check((req) => {
-                expect(req.data).toEqual({
-                    room: {
-                        timeline: { limit: 1 },
-                        include_leave: true,
-                    },
-                });
-            }).respond(200, { filter_id: "another_id" });
+            httpBackend!
+                .when("POST", "/filter")
+                .check((req) => {
+                    expect(req.data).toEqual({
+                        room: {
+                            timeline: { limit: 1 },
+                            include_leave: true,
+                        },
+                    });
+                })
+                .respond(200, { filter_id: "another_id" });
 
             const prom = new Promise<void>((resolve) => {
-                httpBackend!.when("GET", "/sync").check((req) => {
-                    expect(req.queryParams!.filter).toEqual("another_id");
-                    resolve();
-                }).respond(200, {});
+                httpBackend!
+                    .when("GET", "/sync")
+                    .check((req) => {
+                        expect(req.queryParams!.filter).toEqual("another_id");
+                        resolve();
+                    })
+                    .respond(200, {});
             });
 
             client!.syncLeftRooms();
@@ -1570,7 +1614,9 @@ describe("MatrixClient syncing", () => {
                             timeline: {
                                 events: [
                                     utils.mkMessage({
-                                        room: roomTwo, user: otherUserId, msg: "hello",
+                                        room: roomTwo,
+                                        user: otherUserId,
+                                        msg: "hello",
                                     }),
                                 ],
                                 prev_batch: "pagTok",
@@ -1589,8 +1635,7 @@ describe("MatrixClient syncing", () => {
             return Promise.all([
                 client!.syncLeftRooms().then(() => {
                     const room = client!.getRoom(roomTwo)!;
-                    const tok = room.getLiveTimeline().getPaginationToken(
-                        EventTimeline.BACKWARDS);
+                    const tok = room.getLiveTimeline().getPaginationToken(EventTimeline.BACKWARDS);
 
                     expect(tok).toEqual("pagTok");
                 }),
@@ -1615,36 +1660,43 @@ describe("MatrixClient syncing", () => {
                 messages: {
                     start: "start",
                     end: "end",
-                    chunk: [{
-                        content: { body: "Message 1" },
-                        type: "m.room.message",
-                        event_id: "$eventId1",
+                    chunk: [
+                        {
+                            content: { body: "Message 1" },
+                            type: "m.room.message",
+                            event_id: "$eventId1",
+                            sender: userA,
+                            origin_server_ts: 12313525,
+                            room_id: roomOne,
+                        },
+                        {
+                            content: { body: "Message 2" },
+                            type: "m.room.message",
+                            event_id: "$eventId2",
+                            sender: userB,
+                            origin_server_ts: 12315625,
+                            room_id: roomOne,
+                        },
+                    ],
+                },
+                state: [
+                    {
+                        content: { name: "Room Name" },
+                        type: "m.room.name",
+                        event_id: "$eventId",
                         sender: userA,
-                        origin_server_ts: 12313525,
+                        origin_server_ts: 12314525,
+                        state_key: "",
                         room_id: roomOne,
-                    }, {
-                        content: { body: "Message 2" },
-                        type: "m.room.message",
-                        event_id: "$eventId2",
-                        sender: userB,
-                        origin_server_ts: 12315625,
-                        room_id: roomOne,
-                    }],
-                },
-                state: [{
-                    content: { name: "Room Name" },
-                    type: "m.room.name",
-                    event_id: "$eventId",
-                    sender: userA,
-                    origin_server_ts: 12314525,
-                    state_key: "",
-                    room_id: roomOne,
-                }],
-                presence: [{
-                    content: {},
-                    type: "m.presence",
-                    sender: userA,
-                }],
+                    },
+                ],
+                presence: [
+                    {
+                        content: {},
+                        type: "m.presence",
+                        sender: userA,
+                    },
+                ],
             });
             httpBackend!.when("GET", "/events").respond(200, { chunk: [] });
 
@@ -1684,10 +1736,7 @@ describe("MatrixClient syncing", () => {
                 },
             });
 
-            await Promise.all([
-                client!.startClient(),
-                httpBackend!.flushAllExpected(),
-            ]);
+            await Promise.all([client!.startClient(), httpBackend!.flushAllExpected()]);
 
             const eventA = client?.getAccountData("a");
             expect(eventA).not.toBe(eventA1);
@@ -1725,13 +1774,9 @@ describe("MatrixClient syncing (IndexedDB version)", () => {
     };
 
     it("should emit ClientEvent.Room when invited while using indexeddb crypto store", async () => {
-        const idbTestClient = new TestClient(
-            selfUserId,
-            "DEVICE",
-            selfAccessToken,
-            undefined,
-            { cryptoStore: new IndexedDBCryptoStore(global.indexedDB, "tests") },
-        );
+        const idbTestClient = new TestClient(selfUserId, "DEVICE", selfAccessToken, undefined, {
+            cryptoStore: new IndexedDBCryptoStore(global.indexedDB, "tests"),
+        });
         const idbHttpBackend = idbTestClient.httpBackend;
         const idbClient = idbTestClient.client;
         idbHttpBackend.when("GET", "/versions").respond(200, {});
@@ -1747,13 +1792,15 @@ describe("MatrixClient syncing (IndexedDB version)", () => {
             invite: {
                 [roomId]: {
                     invite_state: {
-                        events: [{
-                            type: "m.room.member",
-                            state_key: selfUserId,
-                            content: {
-                                membership: "invite",
+                        events: [
+                            {
+                                type: "m.room.member",
+                                state_key: selfUserId,
+                                content: {
+                                    membership: "invite",
+                                },
                             },
-                        }],
+                        ],
                     },
                 },
             },
diff --git a/spec/integ/megolm-backup.spec.ts b/spec/integ/megolm-backup.spec.ts
index 9341d651189..adbfb70d7fa 100644
--- a/spec/integ/megolm-backup.spec.ts
+++ b/spec/integ/megolm-backup.spec.ts
@@ -23,22 +23,23 @@ import { TestClient } from "../TestClient";
 import { IEvent } from "../../src";
 import { MatrixEvent, MatrixEventEvent } from "../../src/models/event";
 
-const ROOM_ID = '!ROOM:ID';
+const ROOM_ID = "!ROOM:ID";
 
-const SESSION_ID = 'o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc';
+const SESSION_ID = "o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc";
 
 const ENCRYPTED_EVENT: Partial<IEvent> = {
-    type: 'm.room.encrypted',
+    type: "m.room.encrypted",
     content: {
-        algorithm: 'm.megolm.v1.aes-sha2',
-        sender_key: 'SENDER_CURVE25519',
+        algorithm: "m.megolm.v1.aes-sha2",
+        sender_key: "SENDER_CURVE25519",
         session_id: SESSION_ID,
-        ciphertext: 'AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N'
-            + 'CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl'
-            + 'mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs',
+        ciphertext:
+            "AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N" +
+            "CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl" +
+            "mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs",
     },
-    room_id: '!ROOM:ID',
-    event_id: '$event1',
+    room_id: "!ROOM:ID",
+    event_id: "$event1",
     origin_server_ts: 1507753886000,
 };
 
@@ -47,19 +48,20 @@ const CURVE25519_KEY_BACKUP_DATA: IKeyBackupSession = {
     forwarded_count: 0,
     is_verified: false,
     session_data: {
-        ciphertext: '2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw'
-            + '6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ'
-            + 'Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9'
-            + 'SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy'
-            + 'Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF'
-            + 'ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV'
-            + '4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv'
-            + 'C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe'
-            + 'Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf'
-            + 'QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy'
-            + 'iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg',
-        mac: '5lxYBHQU80M',
-        ephemeral: '/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14',
+        ciphertext:
+            "2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw" +
+            "6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ" +
+            "Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9" +
+            "SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy" +
+            "Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF" +
+            "ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV" +
+            "4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv" +
+            "C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe" +
+            "Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf" +
+            "QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy" +
+            "iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg",
+        mac: "5lxYBHQU80M",
+        ephemeral: "/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14",
     },
 };
 
@@ -82,16 +84,14 @@ function createOlmSession(olmAccount: Olm.Account, recipientTestClient: TestClie
         const otk = keys[otkId];
 
         const session = new global.Olm.Session();
-        session.create_outbound(
-            olmAccount, recipientTestClient.getDeviceKey(), otk.key,
-        );
+        session.create_outbound(olmAccount, recipientTestClient.getDeviceKey(), otk.key);
         return session;
     });
 }
 
-describe("megolm key backups", function() {
+describe("megolm key backups", function () {
     if (!global.Olm) {
-        logger.warn('not running megolm tests: Olm not present');
+        logger.warn("not running megolm tests: Olm not present");
         return;
     }
     const Olm = global.Olm;
@@ -99,30 +99,28 @@ describe("megolm key backups", function() {
     let aliceTestClient: TestClient;
 
     const setupTestClient = (): [Account, TestClient] => {
-        const aliceTestClient = new TestClient(
-            "@alice:localhost", "xzcvb", "akjgkrgjs",
-        );
+        const aliceTestClient = new TestClient("@alice:localhost", "xzcvb", "akjgkrgjs");
         const testOlmAccount = new Olm.Account();
         testOlmAccount!.create();
 
         return [testOlmAccount, aliceTestClient];
     };
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
-    beforeEach(async function() {
+    beforeEach(async function () {
         [testOlmAccount, aliceTestClient] = setupTestClient();
         await aliceTestClient!.client.initCrypto();
         aliceTestClient!.client.crypto!.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
     });
 
-    afterEach(function() {
+    afterEach(function () {
         return aliceTestClient!.stop();
     });
 
-    it("Alice checks key backups when receiving a message she can't decrypt", function() {
+    it("Alice checks key backups when receiving a message she can't decrypt", function () {
         const syncResponse = {
             next_batch: 1,
             rooms: {
@@ -136,36 +134,37 @@ describe("megolm key backups", function() {
             },
         };
 
-        return aliceTestClient!.start().then(() => {
-            return createOlmSession(testOlmAccount, aliceTestClient);
-        }).then(() => {
-            const privkey = decodeRecoveryKey(RECOVERY_KEY);
-            return aliceTestClient!.client!.crypto!.storeSessionBackupPrivateKey(privkey);
-        }).then(() => {
-            aliceTestClient!.httpBackend.when("GET", "/sync").respond(200, syncResponse);
-            aliceTestClient!.expectKeyBackupQuery(
-                ROOM_ID,
-                SESSION_ID,
-                200,
-                CURVE25519_KEY_BACKUP_DATA,
-            );
-            return aliceTestClient!.httpBackend.flushAllExpected();
-        }).then(function(): Promise<MatrixEvent> {
-            const room = aliceTestClient!.client.getRoom(ROOM_ID)!;
-            const event = room.getLiveTimeline().getEvents()[0];
-
-            if (event.getContent()) {
-                return Promise.resolve(event);
-            }
-
-            return new Promise((resolve, reject) => {
-                event.once(MatrixEventEvent.Decrypted, (ev) => {
-                    logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
-                    resolve(ev);
+        return aliceTestClient!
+            .start()
+            .then(() => {
+                return createOlmSession(testOlmAccount, aliceTestClient);
+            })
+            .then(() => {
+                const privkey = decodeRecoveryKey(RECOVERY_KEY);
+                return aliceTestClient!.client!.crypto!.storeSessionBackupPrivateKey(privkey);
+            })
+            .then(() => {
+                aliceTestClient!.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+                aliceTestClient!.expectKeyBackupQuery(ROOM_ID, SESSION_ID, 200, CURVE25519_KEY_BACKUP_DATA);
+                return aliceTestClient!.httpBackend.flushAllExpected();
+            })
+            .then(function (): Promise<MatrixEvent> {
+                const room = aliceTestClient!.client.getRoom(ROOM_ID)!;
+                const event = room.getLiveTimeline().getEvents()[0];
+
+                if (event.getContent()) {
+                    return Promise.resolve(event);
+                }
+
+                return new Promise((resolve, reject) => {
+                    event.once(MatrixEventEvent.Decrypted, (ev) => {
+                        logger.log(`${Date.now()} event ${event.getId()} now decrypted`);
+                        resolve(ev);
+                    });
                 });
+            })
+            .then((event) => {
+                expect(event.getContent()).toEqual("testytest");
             });
-        }).then((event) => {
-            expect(event.getContent()).toEqual('testytest');
-        });
     });
 });
diff --git a/spec/integ/megolm-integ.spec.ts b/spec/integ/megolm-integ.spec.ts
index 73a1999363b..1280cc98cb6 100644
--- a/spec/integ/megolm-integ.spec.ts
+++ b/spec/integ/megolm-integ.spec.ts
@@ -77,20 +77,20 @@ function encryptOlmEvent(opts: {
         recipient_keys: {
             ed25519: opts.recipient.getSigningKey(),
         },
-        sender: opts.sender || '@bob:xyz',
-        type: opts.plaintype || 'm.test',
+        sender: opts.sender || "@bob:xyz",
+        type: opts.plaintype || "m.test",
     };
 
     return {
         content: {
-            algorithm: 'm.olm.v1.curve25519-aes-sha2',
+            algorithm: "m.olm.v1.curve25519-aes-sha2",
             ciphertext: {
                 [opts.recipient.getDeviceKey()]: opts.p2pSession.encrypt(JSON.stringify(plaintext)),
             },
             sender_key: opts.senderKey,
         },
-        sender: opts.sender || '@bob:xyz',
-        type: 'm.room.encrypted',
+        sender: opts.sender || "@bob:xyz",
+        type: "m.room.encrypted",
     };
 }
 
@@ -107,7 +107,7 @@ function encryptMegolmEvent(opts: {
     const plaintext = opts.plaintext || {};
     if (!plaintext.content) {
         plaintext.content = {
-            body: '42',
+            body: "42",
             msgtype: "m.text",
         };
     }
@@ -120,7 +120,7 @@ function encryptMegolmEvent(opts: {
     }
 
     return {
-        event_id: 'test_megolm_event_' + Math.random(),
+        event_id: "test_megolm_event_" + Math.random(),
         content: {
             algorithm: "m.megolm.v1.aes-sha2",
             ciphertext: opts.groupSession.encrypt(JSON.stringify(plaintext)),
@@ -145,12 +145,12 @@ function encryptGroupSessionKey(opts: {
         recipient: opts.recipient,
         p2pSession: opts.p2pSession,
         plaincontent: {
-            algorithm: 'm.megolm.v1.aes-sha2',
+            algorithm: "m.megolm.v1.aes-sha2",
             room_id: opts.room_id,
             session_id: opts.groupSession.session_id(),
             session_key: opts.groupSession.session_key(),
         },
-        plaintype: 'm.room_key',
+        plaintype: "m.room_key",
     });
 }
 
@@ -166,17 +166,17 @@ function getSyncResponse(roomMembers: string[]): ISyncResponse {
             events: [
                 testUtils.mkEventCustom({
                     sender: roomMembers[0],
-                    type: 'm.room.encryption',
-                    state_key: '',
+                    type: "m.room.encryption",
+                    state_key: "",
                     content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
+                        algorithm: "m.megolm.v1.aes-sha2",
                     },
                 }),
             ],
         },
         timeline: {
             events: [],
-            prev_batch: '',
+            prev_batch: "",
         },
         ephemeral: { events: [] },
         account_data: { events: [] },
@@ -186,7 +186,7 @@ function getSyncResponse(roomMembers: string[]): ISyncResponse {
     for (let i = 0; i < roomMembers.length; i++) {
         roomResponse.state.events.push(
             testUtils.mkMembershipCustom({
-                membership: 'join',
+                membership: "join",
                 sender: roomMembers[i],
             }),
         );
@@ -205,16 +205,14 @@ function getSyncResponse(roomMembers: string[]): ISyncResponse {
 
 describe("megolm", () => {
     if (!global.Olm) {
-        logger.warn('not running megolm tests: Olm not present');
+        logger.warn("not running megolm tests: Olm not present");
         return;
     }
     const Olm = global.Olm;
 
     let testOlmAccount = {} as unknown as Olm.Account;
-    let testSenderKey = '';
-    let aliceTestClient = new TestClient(
-        "@alice:localhost", "device2", "access_token2",
-    );
+    let testSenderKey = "";
+    let aliceTestClient = new TestClient("@alice:localhost", "device2", "access_token2");
 
     /**
      * Get the device keys for testOlmAccount in a format suitable for a
@@ -226,20 +224,20 @@ describe("megolm", () => {
     function getTestKeysQueryResponse(userId: string): IDownloadKeyResult {
         const testE2eKeys = JSON.parse(testOlmAccount.identity_keys());
         const testDeviceKeys: IDeviceKeys = {
-            algorithms: ['m.olm.v1.curve25519-aes-sha2', 'm.megolm.v1.aes-sha2'],
-            device_id: 'DEVICE_ID',
+            algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+            device_id: "DEVICE_ID",
             keys: {
-                'curve25519:DEVICE_ID': testE2eKeys.curve25519,
-                'ed25519:DEVICE_ID': testE2eKeys.ed25519,
+                "curve25519:DEVICE_ID": testE2eKeys.curve25519,
+                "ed25519:DEVICE_ID": testE2eKeys.ed25519,
             },
             user_id: userId,
         };
         const j = anotherjson.stringify(testDeviceKeys);
         const sig = testOlmAccount.sign(j);
-        testDeviceKeys.signatures = { [userId]: { 'ed25519:DEVICE_ID': sig } };
+        testDeviceKeys.signatures = { [userId]: { "ed25519:DEVICE_ID": sig } };
 
         return {
-            device_keys: { [userId]: { 'DEVICE_ID': testDeviceKeys } },
+            device_keys: { [userId]: { DEVICE_ID: testDeviceKeys } },
             failures: {},
         };
     }
@@ -263,19 +261,17 @@ describe("megolm", () => {
         const sig = testOlmAccount.sign(j);
         const keyResult = {
             ...unsignedKeyResult,
-            signatures: { [userId]: { 'ed25519:DEVICE_ID': sig } },
+            signatures: { [userId]: { "ed25519:DEVICE_ID": sig } },
         };
 
         return {
-            one_time_keys: { [userId]: { 'DEVICE_ID': { ['signed_curve25519:' + keyId]: keyResult } } },
+            one_time_keys: { [userId]: { DEVICE_ID: { ["signed_curve25519:" + keyId]: keyResult } } },
             failures: {},
         };
     }
 
     beforeEach(async () => {
-        aliceTestClient = new TestClient(
-            "@alice:localhost", "xzcvb", "akjgkrgjs",
-        );
+        aliceTestClient = new TestClient("@alice:localhost", "xzcvb", "akjgkrgjs");
         await aliceTestClient.client.initCrypto();
 
         testOlmAccount = new Olm.Account();
@@ -333,7 +329,7 @@ describe("megolm", () => {
 
         // it probably won't be decrypted yet, because it takes a while to process the olm keys
         const decryptedEvent = await testUtils.awaitDecryption(event, { waitOnDecryptionFailure: true });
-        expect(decryptedEvent.getContent().body).toEqual('42');
+        expect(decryptedEvent.getContent().body).toEqual("42");
     });
 
     it("Alice receives a megolm message before the session keys", async () => {
@@ -370,7 +366,7 @@ describe("megolm", () => {
         await aliceTestClient.flushSync();
 
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
-        expect(room.getLiveTimeline().getEvents()[0].getContent().msgtype).toEqual('m.bad.encrypted');
+        expect(room.getLiveTimeline().getEvents()[0].getContent().msgtype).toEqual("m.bad.encrypted");
 
         // now she gets the room_key event
         aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
@@ -384,7 +380,7 @@ describe("megolm", () => {
         const event = room.getLiveTimeline().getEvents()[0];
 
         let decryptedEvent: MatrixEvent;
-        if (event.getContent().msgtype != 'm.bad.encrypted') {
+        if (event.getContent().msgtype != "m.bad.encrypted") {
             decryptedEvent = event;
         } else {
             decryptedEvent = await new Promise<MatrixEvent>((resolve) => {
@@ -394,7 +390,7 @@ describe("megolm", () => {
                 });
             });
         }
-        expect(decryptedEvent.getContent().body).toEqual('42');
+        expect(decryptedEvent.getContent().body).toEqual("42");
     });
 
     it("Alice gets a second room_key message", async () => {
@@ -461,16 +457,16 @@ describe("megolm", () => {
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
         await room.decryptCriticalEvents();
         const event = room.getLiveTimeline().getEvents()[0];
-        expect(event.getContent().body).toEqual('42');
+        expect(event.getContent().body).toEqual("42");
     });
 
-    it('Alice sends a megolm message', async () => {
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} }, failures: {} });
+    it("Alice sends a megolm message", async () => {
+        aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
         // establish an olm session with alice
         const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
 
-        const syncResponse = getSyncResponse(['@bob:xyz']);
+        const syncResponse = getSyncResponse(["@bob:xyz"]);
 
         const olmEvent = encryptOlmEvent({
             senderKey: testSenderKey,
@@ -480,56 +476,53 @@ describe("megolm", () => {
 
         syncResponse.to_device = { events: [olmEvent] };
 
-        aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
         await aliceTestClient.flushSync();
 
         // start out with the device unknown - the send should be rejected.
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
-        );
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
-        );
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
 
         await Promise.all([
-            aliceTestClient.client.sendTextMessage(ROOM_ID, 'test').then(() => {
-                throw new Error("sendTextMessage failed on an unknown device");
-            }, (e) => {
-                expect(e.name).toEqual("UnknownDeviceError");
-            }),
+            aliceTestClient.client.sendTextMessage(ROOM_ID, "test").then(
+                () => {
+                    throw new Error("sendTextMessage failed on an unknown device");
+                },
+                (e) => {
+                    expect(e.name).toEqual("UnknownDeviceError");
+                },
+            ),
             aliceTestClient.httpBackend.flushAllExpected(),
         ]);
 
         // mark the device as known, and resend.
-        aliceTestClient.client.setDeviceKnown('@bob:xyz', 'DEVICE_ID');
+        aliceTestClient.client.setDeviceKnown("@bob:xyz", "DEVICE_ID");
 
         let inboundGroupSession: Olm.InboundGroupSession;
-        aliceTestClient.httpBackend.when(
-            'PUT', '/sendToDevice/m.room.encrypted/',
-        ).respond(200, function(_path, content: any) {
-            const m = content.messages['@bob:xyz'].DEVICE_ID;
-            const ct = m.ciphertext[testSenderKey];
-            const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
-
-            expect(decrypted.type).toEqual('m.room_key');
-            inboundGroupSession = new Olm.InboundGroupSession();
-            inboundGroupSession.create(decrypted.content.session_key);
-            return {};
-        });
+        aliceTestClient.httpBackend
+            .when("PUT", "/sendToDevice/m.room.encrypted/")
+            .respond(200, function (_path, content: any) {
+                const m = content.messages["@bob:xyz"].DEVICE_ID;
+                const ct = m.ciphertext[testSenderKey];
+                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
+
+                expect(decrypted.type).toEqual("m.room_key");
+                inboundGroupSession = new Olm.InboundGroupSession();
+                inboundGroupSession.create(decrypted.content.session_key);
+                return {};
+            });
 
-        aliceTestClient.httpBackend.when(
-            'PUT', '/send/',
-        ).respond(200, (_path, content: IContent) => {
+        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, (_path, content: IContent) => {
             const ct = content.ciphertext;
             const r: any = inboundGroupSession.decrypt(ct);
-            logger.log('Decrypted received megolm message', r);
+            logger.log("Decrypted received megolm message", r);
 
             expect(r.message_index).toEqual(0);
             const decrypted = JSON.parse(r.plaintext);
-            expect(decrypted.type).toEqual('m.room.message');
-            expect(decrypted.content.body).toEqual('test');
+            expect(decrypted.type).toEqual("m.room.message");
+            expect(decrypted.content.body).toEqual("test");
 
-            return { event_id: '$event_id' };
+            return { event_id: "$event_id" };
         });
 
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
@@ -544,11 +537,11 @@ describe("megolm", () => {
     });
 
     it("We shouldn't attempt to send to blocked devices", async () => {
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} }, failures: {} });
+        aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
         // establish an olm session with alice
         const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
-        const syncResponse = getSyncResponse(['@bob:xyz']);
+        const syncResponse = getSyncResponse(["@bob:xyz"]);
 
         const olmEvent = encryptOlmEvent({
             senderKey: testSenderKey,
@@ -557,39 +550,31 @@ describe("megolm", () => {
         });
 
         syncResponse.to_device = { events: [olmEvent] };
-        aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
 
         await aliceTestClient.flushSync();
 
-        logger.log('Forcing alice to download our device keys');
+        logger.log("Forcing alice to download our device keys");
 
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
-        );
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
-        );
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
 
         await Promise.all([
-            aliceTestClient.client.downloadKeys(['@bob:xyz']),
-            aliceTestClient.httpBackend.flush('/keys/query', 2),
+            aliceTestClient.client.downloadKeys(["@bob:xyz"]),
+            aliceTestClient.httpBackend.flush("/keys/query", 2),
         ]);
 
-        logger.log('Telling alice to block our device');
-        aliceTestClient.client.setDeviceBlocked('@bob:xyz', 'DEVICE_ID');
+        logger.log("Telling alice to block our device");
+        aliceTestClient.client.setDeviceBlocked("@bob:xyz", "DEVICE_ID");
 
-        logger.log('Telling alice to send a megolm message');
-        aliceTestClient.httpBackend.when(
-            'PUT', '/send/',
-        ).respond(200, {
-            event_id: '$event_id',
+        logger.log("Telling alice to send a megolm message");
+        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, {
+            event_id: "$event_id",
         });
-        aliceTestClient.httpBackend.when(
-            'PUT', '/sendToDevice/m.room_key.withheld/',
-        ).respond(200, {});
+        aliceTestClient.httpBackend.when("PUT", "/sendToDevice/m.room_key.withheld/").respond(200, {});
 
         await Promise.all([
-            aliceTestClient.client.sendTextMessage(ROOM_ID, 'test'),
+            aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
 
             // the crypto stuff can take a while, so give the requests a whole second.
             aliceTestClient.httpBackend.flushAllExpected({ timeout: 1000 }),
@@ -597,12 +582,12 @@ describe("megolm", () => {
     });
 
     it("We should start a new megolm session when a device is blocked", async () => {
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} }, failures: {} });
+        aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
         // establish an olm session with alice
         const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
 
-        const syncResponse = getSyncResponse(['@bob:xyz']);
+        const syncResponse = getSyncResponse(["@bob:xyz"]);
 
         const olmEvent = encryptOlmEvent({
             senderKey: testSenderKey,
@@ -611,78 +596,68 @@ describe("megolm", () => {
         });
 
         syncResponse.to_device = { events: [olmEvent] };
-        aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
 
         await aliceTestClient.flushSync();
 
         logger.log("Fetching bob's devices and marking known");
 
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
-        );
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
-        );
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
 
         await Promise.all([
-            aliceTestClient.client.downloadKeys(['@bob:xyz']),
+            aliceTestClient.client.downloadKeys(["@bob:xyz"]),
             aliceTestClient.httpBackend.flushAllExpected(),
         ]);
-        await aliceTestClient.client.setDeviceKnown('@bob:xyz', 'DEVICE_ID');
+        await aliceTestClient.client.setDeviceKnown("@bob:xyz", "DEVICE_ID");
 
-        logger.log('Telling alice to send a megolm message');
+        logger.log("Telling alice to send a megolm message");
 
         let megolmSessionId: string;
-        aliceTestClient.httpBackend.when(
-            'PUT', '/sendToDevice/m.room.encrypted/',
-        ).respond(200, function(_path, content: any) {
-            logger.log('sendToDevice: ', content);
-            const m = content.messages['@bob:xyz'].DEVICE_ID;
-            const ct = m.ciphertext[testSenderKey];
-            expect(ct.type).toEqual(1); // normal message
-            const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
-            logger.log('decrypted sendToDevice:', decrypted);
-            expect(decrypted.type).toEqual('m.room_key');
-            megolmSessionId = decrypted.content.session_id;
-            return {};
-        });
+        aliceTestClient.httpBackend
+            .when("PUT", "/sendToDevice/m.room.encrypted/")
+            .respond(200, function (_path, content: any) {
+                logger.log("sendToDevice: ", content);
+                const m = content.messages["@bob:xyz"].DEVICE_ID;
+                const ct = m.ciphertext[testSenderKey];
+                expect(ct.type).toEqual(1); // normal message
+                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
+                logger.log("decrypted sendToDevice:", decrypted);
+                expect(decrypted.type).toEqual("m.room_key");
+                megolmSessionId = decrypted.content.session_id;
+                return {};
+            });
 
-        aliceTestClient.httpBackend.when(
-            'PUT', '/send/',
-        ).respond(200, function(_path, content) {
-            logger.log('/send:', content);
+        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, function (_path, content) {
+            logger.log("/send:", content);
             expect(content.session_id).toEqual(megolmSessionId);
             return {
-                event_id: '$event_id',
+                event_id: "$event_id",
             };
         });
 
         await Promise.all([
-            aliceTestClient.client.sendTextMessage(ROOM_ID, 'test'),
+            aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
 
             // the crypto stuff can take a while, so give the requests a whole second.
             aliceTestClient.httpBackend.flushAllExpected({ timeout: 1000 }),
         ]);
 
-        logger.log('Telling alice to block our device');
-        aliceTestClient.client.setDeviceBlocked('@bob:xyz', 'DEVICE_ID');
+        logger.log("Telling alice to block our device");
+        aliceTestClient.client.setDeviceBlocked("@bob:xyz", "DEVICE_ID");
 
-        logger.log('Telling alice to send another megolm message');
-        aliceTestClient.httpBackend.when(
-            'PUT', '/send/',
-        ).respond(200, function(_path, content) {
-            logger.log('/send:', content);
+        logger.log("Telling alice to send another megolm message");
+        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, function (_path, content) {
+            logger.log("/send:", content);
             expect(content.session_id).not.toEqual(megolmSessionId);
             return {
-                event_id: '$event_id',
+                event_id: "$event_id",
             };
         });
-        aliceTestClient.httpBackend.when(
-            'PUT', '/sendToDevice/m.room_key.withheld/',
-        ).respond(200, {});
+        aliceTestClient.httpBackend.when("PUT", "/sendToDevice/m.room_key.withheld/").respond(200, {});
 
         await Promise.all([
-            aliceTestClient.client.sendTextMessage(ROOM_ID, 'test2'),
+            aliceTestClient.client.sendTextMessage(ROOM_ID, "test2"),
             aliceTestClient.httpBackend.flushAllExpected(),
         ]);
     });
@@ -695,82 +670,89 @@ describe("megolm", () => {
         // an encrypted room with just alice
         const syncResponse = {
             next_batch: 1,
-            rooms: { join: { [ROOM_ID]: { state: { events: [
-                testUtils.mkEvent({
-                    type: 'm.room.encryption',
-                    skey: '',
-                    content: { algorithm: 'm.megolm.v1.aes-sha2' },
-                }),
-                testUtils.mkMembership({
-                    mship: 'join',
-                    sender: aliceTestClient.userId,
-                }),
-            ] } } } },
+            rooms: {
+                join: {
+                    [ROOM_ID]: {
+                        state: {
+                            events: [
+                                testUtils.mkEvent({
+                                    type: "m.room.encryption",
+                                    skey: "",
+                                    content: { algorithm: "m.megolm.v1.aes-sha2" },
+                                }),
+                                testUtils.mkMembership({
+                                    mship: "join",
+                                    sender: aliceTestClient.userId,
+                                }),
+                            ],
+                        },
+                    },
+                },
+            },
         };
-        aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
 
         // the completion of the first initialsync should make Alice
         // invalidate the device cache for all members in e2e rooms (ie,
         // herself), and do a key query.
-        aliceTestClient.expectKeyQuery(
-            getTestKeysQueryResponse(aliceTestClient.userId!),
-        );
+        aliceTestClient.expectKeyQuery(getTestKeysQueryResponse(aliceTestClient.userId!));
 
         await aliceTestClient.httpBackend.flushAllExpected();
 
         // start out with the device unknown - the send should be rejected.
         try {
-            await aliceTestClient.client.sendTextMessage(ROOM_ID, 'test');
+            await aliceTestClient.client.sendTextMessage(ROOM_ID, "test");
             throw new Error("sendTextMessage succeeded on an unknown device");
         } catch (e) {
             expect((e as any).name).toEqual("UnknownDeviceError");
             expect(Object.keys((e as any).devices)).toEqual([aliceTestClient.userId!]);
-            expect(Object.keys((e as any)?.devices[aliceTestClient.userId!])).
-                toEqual(['DEVICE_ID']);
+            expect(Object.keys((e as any)?.devices[aliceTestClient.userId!])).toEqual(["DEVICE_ID"]);
         }
 
         // mark the device as known, and resend.
-        aliceTestClient.client.setDeviceKnown(aliceTestClient.userId!, 'DEVICE_ID');
-        aliceTestClient.httpBackend.when('POST', '/keys/claim').respond(
-            200, function(_path, content: IClaimOTKsResult) {
-                expect(content.one_time_keys[aliceTestClient.userId!].DEVICE_ID)
-                    .toEqual("signed_curve25519");
+        aliceTestClient.client.setDeviceKnown(aliceTestClient.userId!, "DEVICE_ID");
+        aliceTestClient.httpBackend
+            .when("POST", "/keys/claim")
+            .respond(200, function (_path, content: IClaimOTKsResult) {
+                expect(content.one_time_keys[aliceTestClient.userId!].DEVICE_ID).toEqual("signed_curve25519");
                 return getTestKeysClaimResponse(aliceTestClient.userId!);
             });
 
         let p2pSession: Olm.Session;
         let inboundGroupSession: Olm.InboundGroupSession;
-        aliceTestClient.httpBackend.when(
-            'PUT', '/sendToDevice/m.room.encrypted/',
-        ).respond(200, function(_path, content: {
-            messages: { [userId: string]: { [deviceId: string]: Record<string, any> }};
-        }) {
-            logger.log("sendToDevice: ", content);
-            const m = content.messages[aliceTestClient.userId!].DEVICE_ID;
-            const ct = m.ciphertext[testSenderKey];
-            expect(ct.type).toEqual(0); // pre-key message
-
-            p2pSession = new Olm.Session();
-            p2pSession.create_inbound(testOlmAccount, ct.body);
-            const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
-
-            expect(decrypted.type).toEqual('m.room_key');
-            inboundGroupSession = new Olm.InboundGroupSession();
-            inboundGroupSession.create(decrypted.content.session_key);
-            return {};
-        });
+        aliceTestClient.httpBackend.when("PUT", "/sendToDevice/m.room.encrypted/").respond(
+            200,
+            function (
+                _path,
+                content: {
+                    messages: { [userId: string]: { [deviceId: string]: Record<string, any> } };
+                },
+            ) {
+                logger.log("sendToDevice: ", content);
+                const m = content.messages[aliceTestClient.userId!].DEVICE_ID;
+                const ct = m.ciphertext[testSenderKey];
+                expect(ct.type).toEqual(0); // pre-key message
+
+                p2pSession = new Olm.Session();
+                p2pSession.create_inbound(testOlmAccount, ct.body);
+                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
+
+                expect(decrypted.type).toEqual("m.room_key");
+                inboundGroupSession = new Olm.InboundGroupSession();
+                inboundGroupSession.create(decrypted.content.session_key);
+                return {};
+            },
+        );
 
         let decrypted: Partial<IEvent> = {};
-        aliceTestClient.httpBackend.when(
-            'PUT', '/send/',
-        ).respond(200, function(_path, content: IContent) {
+        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, function (_path, content: IContent) {
             const ct = content.ciphertext;
             const r: any = inboundGroupSession.decrypt(ct);
-            logger.log('Decrypted received megolm message', r);
+            logger.log("Decrypted received megolm message", r);
             decrypted = JSON.parse(r.plaintext);
 
             return {
-                event_id: '$event_id',
+                event_id: "$event_id",
             };
         });
 
@@ -789,17 +771,17 @@ describe("megolm", () => {
             }),
         ]);
 
-        expect(decrypted.type).toEqual('m.room.message');
-        expect(decrypted.content?.body).toEqual('test');
+        expect(decrypted.type).toEqual("m.room.message");
+        expect(decrypted.content?.body).toEqual("test");
     });
 
-    it('Alice should wait for device list to complete when sending a megolm message', async () => {
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} }, failures: {} });
+    it("Alice should wait for device list to complete when sending a megolm message", async () => {
+        aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
         // establish an olm session with alice
         const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
 
-        const syncResponse = getSyncResponse(['@bob:xyz']);
+        const syncResponse = getSyncResponse(["@bob:xyz"]);
 
         const olmEvent = encryptOlmEvent({
             senderKey: testSenderKey,
@@ -809,35 +791,33 @@ describe("megolm", () => {
 
         syncResponse.to_device = { events: [olmEvent] };
 
-        aliceTestClient.httpBackend.when('GET', '/sync').respond(200, syncResponse);
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
         await aliceTestClient.flushSync();
 
         // this will block
-        logger.log('Forcing alice to download our device keys');
-        const downloadPromise = aliceTestClient.client.downloadKeys(['@bob:xyz']);
+        logger.log("Forcing alice to download our device keys");
+        const downloadPromise = aliceTestClient.client.downloadKeys(["@bob:xyz"]);
 
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
-        );
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
 
         // so will this.
-        const sendPromise = aliceTestClient.client.sendTextMessage(ROOM_ID, 'test')
-            .then(() => {
+        const sendPromise = aliceTestClient.client.sendTextMessage(ROOM_ID, "test").then(
+            () => {
                 throw new Error("sendTextMessage failed on an unknown device");
-            }, (e) => {
+            },
+            (e) => {
                 expect(e.name).toEqual("UnknownDeviceError");
-            });
-
-        aliceTestClient.httpBackend.when('POST', '/keys/query').respond(
-            200, getTestKeysQueryResponse('@bob:xyz'),
+            },
         );
 
+        aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+
         await aliceTestClient.httpBackend.flushAllExpected();
         await Promise.all([downloadPromise, sendPromise]);
     });
 
     it("Alice exports megolm keys and imports them to a new device", async () => {
-        aliceTestClient.expectKeyQuery({ device_keys: { '@alice:localhost': {} }, failures: {} });
+        aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
         aliceTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve({});
         // establish an olm session with alice
@@ -880,19 +860,17 @@ describe("megolm", () => {
         await room.decryptCriticalEvents();
 
         // it probably won't be decrypted yet, because it takes a while to process the olm keys
-        const decryptedEvent = await testUtils.awaitDecryption(
-            room.getLiveTimeline().getEvents()[0], { waitOnDecryptionFailure: true },
-        );
-        expect(decryptedEvent.getContent().body).toEqual('42');
+        const decryptedEvent = await testUtils.awaitDecryption(room.getLiveTimeline().getEvents()[0], {
+            waitOnDecryptionFailure: true,
+        });
+        expect(decryptedEvent.getContent().body).toEqual("42");
 
         const exported = await aliceTestClient.client.exportRoomKeys();
 
         // start a new client
         aliceTestClient.stop();
 
-        aliceTestClient = new TestClient(
-            "@alice:localhost", "device2", "access_token2",
-        );
+        aliceTestClient = new TestClient("@alice:localhost", "device2", "access_token2");
         await aliceTestClient.client.initCrypto();
         await aliceTestClient.client.importRoomKeys(exported);
         await aliceTestClient.start();
@@ -910,7 +888,7 @@ describe("megolm", () => {
         await aliceTestClient.flushSync();
 
         const event = room.getLiveTimeline().getEvents()[0];
-        expect(event.getContent().body).toEqual('42');
+        expect(event.getContent().body).toEqual("42");
     });
 
     it("Alice receives an untrusted megolm key, only to receive the trusted one shortly after", async () => {
@@ -925,15 +903,17 @@ describe("megolm", () => {
             room_id: ROOM_ID,
         });
         await testClient.client.initCrypto();
-        const keys = [{
-            room_id: ROOM_ID,
-            algorithm: 'm.megolm.v1.aes-sha2',
-            session_id: groupSession.session_id(),
-            session_key: inboundGroupSession.export_session(0),
-            sender_key: testSenderKey,
-            forwarding_curve25519_key_chain: [],
-            sender_claimed_keys: {},
-        }];
+        const keys = [
+            {
+                room_id: ROOM_ID,
+                algorithm: "m.megolm.v1.aes-sha2",
+                session_id: groupSession.session_id(),
+                session_key: inboundGroupSession.export_session(0),
+                sender_key: testSenderKey,
+                forwarding_curve25519_key_chain: [],
+                sender_claimed_keys: {},
+            },
+        ];
         await testClient.client.importRoomKeys(keys, { untrusted: true });
 
         const event1 = testUtils.mkEvent({
@@ -945,10 +925,10 @@ describe("megolm", () => {
         expect(event1.isKeySourceUntrusted()).toBeTruthy();
 
         const event2 = testUtils.mkEvent({
-            type: 'm.room_key',
+            type: "m.room_key",
             content: {
                 room_id: ROOM_ID,
-                algorithm: 'm.megolm.v1.aes-sha2',
+                algorithm: "m.megolm.v1.aes-sha2",
                 session_id: groupSession.session_id(),
                 session_key: groupSession.session_key(),
             },
@@ -994,7 +974,7 @@ describe("megolm", () => {
         };
 
         const messageEncrypted = {
-            event_id: 'test_megolm_event',
+            event_id: "test_megolm_event",
             content: {
                 algorithm: "m.megolm.v1.aes-sha2",
                 ciphertext: groupSession.encrypt(JSON.stringify(plaintext)),
@@ -1030,78 +1010,73 @@ describe("megolm", () => {
         expect(decryptedEvent.getClearContent()).toBeUndefined();
     });
 
-    it(
-        "should successfully decrypt bundled redaction events that don't include a room_id in their /sync data",
-        async () => {
-            await aliceTestClient.start();
-            aliceTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve({});
-            const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
-            const groupSession = new Olm.OutboundGroupSession();
-            groupSession.create();
-
-            aliceTestClient.client.crypto!.deviceList.getUserByIdentityKey = () => "@bob:xyz";
-
-            // make the room_key event
-            const roomKeyEncrypted = encryptGroupSessionKey({
-                senderKey: testSenderKey,
-                recipient: aliceTestClient,
-                p2pSession: p2pSession,
-                groupSession: groupSession,
-                room_id: ROOM_ID,
-            });
+    it("should successfully decrypt bundled redaction events that don't include a room_id in their /sync data", async () => {
+        await aliceTestClient.start();
+        aliceTestClient.client.crypto!.deviceList.downloadKeys = () => Promise.resolve({});
+        const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
+        const groupSession = new Olm.OutboundGroupSession();
+        groupSession.create();
 
-            // encrypt a message with the group session
-            const messageEncrypted = encryptMegolmEvent({
-                senderKey: testSenderKey,
-                groupSession: groupSession,
-                room_id: ROOM_ID,
-            });
+        aliceTestClient.client.crypto!.deviceList.getUserByIdentityKey = () => "@bob:xyz";
 
-            const redactionEncrypted = encryptMegolmEvent({
-                senderKey: testSenderKey,
-                groupSession: groupSession,
-                plaintext: {
-                    room_id: ROOM_ID,
-                    type: "m.room.redaction",
-                    redacts: messageEncrypted.event_id,
-                    content: { reason: "redaction test" },
-                },
-            });
+        // make the room_key event
+        const roomKeyEncrypted = encryptGroupSessionKey({
+            senderKey: testSenderKey,
+            recipient: aliceTestClient,
+            p2pSession: p2pSession,
+            groupSession: groupSession,
+            room_id: ROOM_ID,
+        });
 
-            const messageEncryptedWithRedaction = {
-                ...messageEncrypted,
-                unsigned: { redacted_because: redactionEncrypted },
-            };
+        // encrypt a message with the group session
+        const messageEncrypted = encryptMegolmEvent({
+            senderKey: testSenderKey,
+            groupSession: groupSession,
+            room_id: ROOM_ID,
+        });
 
-            const syncResponse = {
-                next_batch: 1,
-                to_device: {
-                    events: [roomKeyEncrypted],
-                },
-                rooms: {
-                    join: {
-                        [ROOM_ID]: { timeline: { events: [messageEncryptedWithRedaction] } },
-                    },
+        const redactionEncrypted = encryptMegolmEvent({
+            senderKey: testSenderKey,
+            groupSession: groupSession,
+            plaintext: {
+                room_id: ROOM_ID,
+                type: "m.room.redaction",
+                redacts: messageEncrypted.event_id,
+                content: { reason: "redaction test" },
+            },
+        });
+
+        const messageEncryptedWithRedaction = {
+            ...messageEncrypted,
+            unsigned: { redacted_because: redactionEncrypted },
+        };
+
+        const syncResponse = {
+            next_batch: 1,
+            to_device: {
+                events: [roomKeyEncrypted],
+            },
+            rooms: {
+                join: {
+                    [ROOM_ID]: { timeline: { events: [messageEncryptedWithRedaction] } },
                 },
-            };
+            },
+        };
 
-            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
-            await aliceTestClient.flushSync();
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+        await aliceTestClient.flushSync();
 
-            const room = aliceTestClient.client.getRoom(ROOM_ID)!;
-            const event = room.getLiveTimeline().getEvents()[0];
-            expect(event.isEncrypted()).toBe(true);
-            await event.attemptDecryption(aliceTestClient.client.crypto!);
-            expect(event.getContent()).toEqual({});
-            const redactionEvent: any = event.getRedactionEvent();
-            expect(redactionEvent.content.reason).toEqual("redaction test");
-        },
-    );
+        const room = aliceTestClient.client.getRoom(ROOM_ID)!;
+        const event = room.getLiveTimeline().getEvents()[0];
+        expect(event.isEncrypted()).toBe(true);
+        await event.attemptDecryption(aliceTestClient.client.crypto!);
+        expect(event.getContent()).toEqual({});
+        const redactionEvent: any = event.getRedactionEvent();
+        expect(redactionEvent.content.reason).toEqual("redaction test");
+    });
 
     it("Alice receives shared history before being invited to a room by the sharer", async () => {
-        const beccaTestClient = new TestClient(
-            "@becca:localhost", "foobar", "bazquux",
-        );
+        const beccaTestClient = new TestClient("@becca:localhost", "foobar", "bazquux");
         await beccaTestClient.client.initCrypto();
 
         await aliceTestClient.start();
@@ -1110,7 +1085,7 @@ describe("megolm", () => {
 
         const beccaRoom = new Room(ROOM_ID, beccaTestClient.client, "@becca:localhost", {});
         beccaTestClient.client.store.storeRoom(beccaRoom);
-        await beccaTestClient.client.setRoomEncryption(ROOM_ID, { "algorithm": "m.megolm.v1.aes-sha2" });
+        await beccaTestClient.client.setRoomEncryption(ROOM_ID, { algorithm: "m.megolm.v1.aes-sha2" });
 
         const event = new MatrixEvent({
             type: "m.room.message",
@@ -1142,7 +1117,7 @@ describe("megolm", () => {
         const aliceOtk = aliceOtks[aliceOtkId];
         const p2pSession = new global.Olm.Session();
         await beccaTestClient.client.crypto!.cryptoStore.doTxn(
-            'readonly',
+            "readonly",
             [IndexedDBCryptoStore.STORE_ACCOUNT],
             (txn) => {
                 beccaTestClient.client.crypto!.cryptoStore.getAccount(txn, (pickledAccount: string | null) => {
@@ -1169,7 +1144,7 @@ describe("megolm", () => {
             recipient: aliceTestClient,
             p2pSession: p2pSession,
             plaincontent: {
-                "algorithm": 'm.megolm.v1.aes-sha2',
+                "algorithm": "m.megolm.v1.aes-sha2",
                 "room_id": ROOM_ID,
                 "sender_key": content.sender_key,
                 "sender_claimed_ed25519_key": groupSessionKey!.sender_claimed_ed25519_key,
@@ -1179,7 +1154,7 @@ describe("megolm", () => {
                 "forwarding_curve25519_key_chain": groupSessionKey!.forwarding_curve25519_key_chain,
                 "org.matrix.msc3061.shared_history": true,
             },
-            plaintype: 'm.forwarded_room_key',
+            plaintype: "m.forwarded_room_key",
         });
 
         // Alice receives shared history
@@ -1192,31 +1167,39 @@ describe("megolm", () => {
         // Alice is invited to the room by Becca
         aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
             next_batch: 2,
-            rooms: { invite: { [ROOM_ID]: { invite_state: { events: [
-                {
-                    sender: '@becca:localhost',
-                    type: 'm.room.encryption',
-                    state_key: '',
-                    content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                    },
-                },
-                {
-                    sender: '@becca:localhost',
-                    type: 'm.room.member',
-                    state_key: '@alice:localhost',
-                    content: {
-                        membership: 'invite',
+            rooms: {
+                invite: {
+                    [ROOM_ID]: {
+                        invite_state: {
+                            events: [
+                                {
+                                    sender: "@becca:localhost",
+                                    type: "m.room.encryption",
+                                    state_key: "",
+                                    content: {
+                                        algorithm: "m.megolm.v1.aes-sha2",
+                                    },
+                                },
+                                {
+                                    sender: "@becca:localhost",
+                                    type: "m.room.member",
+                                    state_key: "@alice:localhost",
+                                    content: {
+                                        membership: "invite",
+                                    },
+                                },
+                            ],
+                        },
                     },
                 },
-            ] } } } },
+            },
         });
         await aliceTestClient.flushSync();
 
         // Alice has joined the room
-        aliceTestClient.httpBackend.when("GET", "/sync").respond(
-            200, getSyncResponse(["@alice:localhost", "@becca:localhost"]),
-        );
+        aliceTestClient.httpBackend
+            .when("GET", "/sync")
+            .respond(200, getSyncResponse(["@alice:localhost", "@becca:localhost"]));
         await aliceTestClient.flushSync();
 
         aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
@@ -1233,15 +1216,13 @@ describe("megolm", () => {
         const roomEvent = room.getLiveTimeline().getEvents()[0];
         expect(roomEvent.isEncrypted()).toBe(true);
         const decryptedEvent = await testUtils.awaitDecryption(roomEvent);
-        expect(decryptedEvent.getContent().body).toEqual('test message');
+        expect(decryptedEvent.getContent().body).toEqual("test message");
 
         await beccaTestClient.stop();
     });
 
     it("Alice receives shared history before being invited to a room by someone else", async () => {
-        const beccaTestClient = new TestClient(
-            "@becca:localhost", "foobar", "bazquux",
-        );
+        const beccaTestClient = new TestClient("@becca:localhost", "foobar", "bazquux");
         await beccaTestClient.client.initCrypto();
 
         await aliceTestClient.start();
@@ -1249,7 +1230,7 @@ describe("megolm", () => {
 
         const beccaRoom = new Room(ROOM_ID, beccaTestClient.client, "@becca:localhost", {});
         beccaTestClient.client.store.storeRoom(beccaRoom);
-        await beccaTestClient.client.setRoomEncryption(ROOM_ID, { "algorithm": "m.megolm.v1.aes-sha2" });
+        await beccaTestClient.client.setRoomEncryption(ROOM_ID, { algorithm: "m.megolm.v1.aes-sha2" });
 
         const event = new MatrixEvent({
             type: "m.room.message",
@@ -1280,7 +1261,7 @@ describe("megolm", () => {
         const aliceOtk = aliceOtks[aliceOtkId];
         const p2pSession = new global.Olm.Session();
         await beccaTestClient.client.crypto!.cryptoStore.doTxn(
-            'readonly',
+            "readonly",
             [IndexedDBCryptoStore.STORE_ACCOUNT],
             (txn) => {
                 beccaTestClient.client.crypto!.cryptoStore.getAccount(txn, (pickledAccount: string | null) => {
@@ -1307,7 +1288,7 @@ describe("megolm", () => {
             recipient: aliceTestClient,
             p2pSession: p2pSession,
             plaincontent: {
-                "algorithm": 'm.megolm.v1.aes-sha2',
+                "algorithm": "m.megolm.v1.aes-sha2",
                 "room_id": ROOM_ID,
                 "sender_key": content.sender_key,
                 "sender_claimed_ed25519_key": groupSessionKey!.sender_claimed_ed25519_key,
@@ -1317,7 +1298,7 @@ describe("megolm", () => {
                 "forwarding_curve25519_key_chain": groupSessionKey!.forwarding_curve25519_key_chain,
                 "org.matrix.msc3061.shared_history": true,
             },
-            plaintype: 'm.forwarded_room_key',
+            plaintype: "m.forwarded_room_key",
         });
 
         // Alice receives forwarded history from Becca
@@ -1330,31 +1311,39 @@ describe("megolm", () => {
         // Alice is invited to the room by Charlie
         aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
             next_batch: 2,
-            rooms: { invite: { [ROOM_ID]: { invite_state: { events: [
-                {
-                    sender: '@becca:localhost',
-                    type: 'm.room.encryption',
-                    state_key: '',
-                    content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                    },
-                },
-                {
-                    sender: '@charlie:localhost',
-                    type: 'm.room.member',
-                    state_key: '@alice:localhost',
-                    content: {
-                        membership: 'invite',
+            rooms: {
+                invite: {
+                    [ROOM_ID]: {
+                        invite_state: {
+                            events: [
+                                {
+                                    sender: "@becca:localhost",
+                                    type: "m.room.encryption",
+                                    state_key: "",
+                                    content: {
+                                        algorithm: "m.megolm.v1.aes-sha2",
+                                    },
+                                },
+                                {
+                                    sender: "@charlie:localhost",
+                                    type: "m.room.member",
+                                    state_key: "@alice:localhost",
+                                    content: {
+                                        membership: "invite",
+                                    },
+                                },
+                            ],
+                        },
                     },
                 },
-            ] } } } },
+            },
         });
         await aliceTestClient.flushSync();
 
         // Alice has joined the room
-        aliceTestClient.httpBackend.when("GET", "/sync").respond(
-            200, getSyncResponse(["@alice:localhost", "@becca:localhost", "@charlie:localhost"]),
-        );
+        aliceTestClient.httpBackend
+            .when("GET", "/sync")
+            .respond(200, getSyncResponse(["@alice:localhost", "@becca:localhost", "@charlie:localhost"]));
         await aliceTestClient.flushSync();
 
         aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
@@ -1384,67 +1373,77 @@ describe("megolm", () => {
         const testRoomId = "!testRoom:id";
         await aliceTestClient.start();
 
-        aliceTestClient.httpBackend.when("POST", "/keys/query")
-            .respond(200, function(_path, content: IUploadKeysRequest) {
+        aliceTestClient.httpBackend
+            .when("POST", "/keys/query")
+            .respond(200, function (_path, content: IUploadKeysRequest) {
                 return { device_keys: {} };
             });
 
         /* Alice makes the /createRoom call */
-        aliceTestClient.httpBackend.when("POST", "/createRoom")
-            .respond(200, { room_id: testRoomId });
+        aliceTestClient.httpBackend.when("POST", "/createRoom").respond(200, { room_id: testRoomId });
         await Promise.all([
             aliceTestClient.client.createRoom({
-                initial_state: [{
-                    type: 'm.room.encryption',
-                    state_key: '',
-                    content: { algorithm: 'm.megolm.v1.aes-sha2' },
-                }],
+                initial_state: [
+                    {
+                        type: "m.room.encryption",
+                        state_key: "",
+                        content: { algorithm: "m.megolm.v1.aes-sha2" },
+                    },
+                ],
             }),
             aliceTestClient.httpBackend.flushAllExpected(),
         ]);
 
         /* The sync arrives in two parts; first the m.room.create... */
         aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-            rooms: { join: {
-                [testRoomId]: {
-                    timeline: { events: [
-                        {
-                            type: 'm.room.create',
-                            state_key: '',
-                            event_id: "$create",
-                        },
-                        {
-                            type: 'm.room.member',
-                            state_key: aliceTestClient.getUserId(),
-                            content: { membership: "join" },
-                            event_id: "$alijoin",
+            rooms: {
+                join: {
+                    [testRoomId]: {
+                        timeline: {
+                            events: [
+                                {
+                                    type: "m.room.create",
+                                    state_key: "",
+                                    event_id: "$create",
+                                },
+                                {
+                                    type: "m.room.member",
+                                    state_key: aliceTestClient.getUserId(),
+                                    content: { membership: "join" },
+                                    event_id: "$alijoin",
+                                },
+                            ],
                         },
-                    ] },
+                    },
                 },
-            } },
+            },
         });
         await aliceTestClient.flushSync();
 
         // ... and then the e2e event and an invite ...
         aliceTestClient.httpBackend.when("GET", "/sync").respond(200, {
-            rooms: { join: {
-                [testRoomId]: {
-                    timeline: { events: [
-                        {
-                            type: 'm.room.encryption',
-                            state_key: '',
-                            content: { algorithm: 'm.megolm.v1.aes-sha2' },
-                            event_id: "$e2e",
-                        },
-                        {
-                            type: 'm.room.member',
-                            state_key: "@other:user",
-                            content: { membership: "invite" },
-                            event_id: "$otherinvite",
+            rooms: {
+                join: {
+                    [testRoomId]: {
+                        timeline: {
+                            events: [
+                                {
+                                    type: "m.room.encryption",
+                                    state_key: "",
+                                    content: { algorithm: "m.megolm.v1.aes-sha2" },
+                                    event_id: "$e2e",
+                                },
+                                {
+                                    type: "m.room.member",
+                                    state_key: "@other:user",
+                                    content: { membership: "invite" },
+                                    event_id: "$otherinvite",
+                                },
+                            ],
                         },
-                    ] },
+                    },
                 },
-            } },
+            },
         });
 
         // as soon as the roomMember arrives, try to send a message
@@ -1455,7 +1454,8 @@ describe("megolm", () => {
         });
 
         // flush the sync and wait for the /send/ request.
-        aliceTestClient.httpBackend.when("PUT", "/send/m.room.encrypted/")
+        aliceTestClient.httpBackend
+            .when("PUT", "/send/m.room.encrypted/")
             .respond(200, (_path, _content) => ({ event_id: "asdfgh" }));
         await Promise.all([
             aliceTestClient.flushSync(),
diff --git a/spec/integ/sliding-sync-sdk.spec.ts b/spec/integ/sliding-sync-sdk.spec.ts
index 20dfa6141fa..165e3142012 100644
--- a/spec/integ/sliding-sync-sdk.spec.ts
+++ b/spec/integ/sliding-sync-sdk.spec.ts
@@ -22,8 +22,20 @@ import { SlidingSync, SlidingSyncEvent, MSC3575RoomData, SlidingSyncState, Exten
 import { TestClient } from "../TestClient";
 import { IRoomEvent, IStateEvent } from "../../src/sync-accumulator";
 import {
-    MatrixClient, MatrixEvent, NotificationCountType, JoinRule, MatrixError,
-    EventType, IPushRules, PushRuleKind, TweakName, ClientEvent, RoomMemberEvent, RoomEvent, Room, IRoomTimelineData,
+    MatrixClient,
+    MatrixEvent,
+    NotificationCountType,
+    JoinRule,
+    MatrixError,
+    EventType,
+    IPushRules,
+    PushRuleKind,
+    TweakName,
+    ClientEvent,
+    RoomMemberEvent,
+    RoomEvent,
+    Room,
+    IRoomTimelineData,
 } from "../../src";
 import { SlidingSyncSdk } from "../../src/sliding-sync-sdk";
 import { SyncState } from "../../src/sync";
@@ -67,7 +79,7 @@ describe("SlidingSyncSdk", () => {
             event_id: "$" + eventIdCounter,
         };
     };
-    const mkOwnStateEvent = (evType: string, content: object, stateKey = ''): IStateEvent => {
+    const mkOwnStateEvent = (evType: string, content: object, stateKey = ""): IStateEvent => {
         eventIdCounter++;
         return {
             type: evType,
@@ -97,7 +109,7 @@ describe("SlidingSyncSdk", () => {
     };
 
     // assign client/httpBackend globals
-    const setupClient = async (testOpts?: Partial<IStoredClientOpts&{withCrypto: boolean}>) => {
+    const setupClient = async (testOpts?: Partial<IStoredClientOpts & { withCrypto: boolean }>) => {
         testOpts = testOpts || {};
         const testClient = new TestClient(selfUserId, "DEVICE", selfAccessToken);
         httpBackend = testClient.httpBackend;
@@ -195,7 +207,6 @@ describe("SlidingSyncSdk", () => {
                         mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
                         mkOwnEvent(EventType.RoomMessage, { body: "hello B" }),
                         mkOwnEvent(EventType.RoomMessage, { body: "world B" }),
-
                     ],
                     initial: true,
                 },
@@ -294,7 +305,9 @@ describe("SlidingSyncSdk", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomA, data[roomA]);
                 const gotRoom = client!.getRoom(roomA);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
+                if (gotRoom == null) {
+                    return;
+                }
                 expect(gotRoom.name).toEqual(data[roomA].name);
                 expect(gotRoom.getMyMembership()).toEqual("join");
                 assertTimelineEvents(gotRoom.getLiveTimeline().getEvents().slice(-2), data[roomA].timeline);
@@ -304,7 +317,9 @@ describe("SlidingSyncSdk", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomB, data[roomB]);
                 const gotRoom = client!.getRoom(roomB);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
+                if (gotRoom == null) {
+                    return;
+                }
                 expect(gotRoom.name).toEqual(data[roomB].name);
                 expect(gotRoom.getMyMembership()).toEqual("join");
                 assertTimelineEvents(gotRoom.getLiveTimeline().getEvents().slice(-5), data[roomB].timeline);
@@ -314,27 +329,33 @@ describe("SlidingSyncSdk", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomC, data[roomC]);
                 const gotRoom = client!.getRoom(roomC);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(
-                    gotRoom.getUnreadNotificationCount(NotificationCountType.Highlight),
-                ).toEqual(data[roomC].highlight_count);
+                if (gotRoom == null) {
+                    return;
+                }
+                expect(gotRoom.getUnreadNotificationCount(NotificationCountType.Highlight)).toEqual(
+                    data[roomC].highlight_count,
+                );
             });
 
             it("can be created with a notification_count", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomD, data[roomD]);
                 const gotRoom = client!.getRoom(roomD);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(
-                    gotRoom.getUnreadNotificationCount(NotificationCountType.Total),
-                ).toEqual(data[roomD].notification_count);
+                if (gotRoom == null) {
+                    return;
+                }
+                expect(gotRoom.getUnreadNotificationCount(NotificationCountType.Total)).toEqual(
+                    data[roomD].notification_count,
+                );
             });
 
             it("can be created with an invited/joined_count", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomG, data[roomG]);
                 const gotRoom = client!.getRoom(roomG);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
+                if (gotRoom == null) {
+                    return;
+                }
                 expect(gotRoom.getInvitedMemberCount()).toEqual(data[roomG].invited_count);
                 expect(gotRoom.getJoinedMemberCount()).toEqual(data[roomG].joined_count);
             });
@@ -358,7 +379,9 @@ describe("SlidingSyncSdk", () => {
                 client!.off(RoomEvent.Timeline, listener);
                 const gotRoom = client!.getRoom(roomH);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
+                if (gotRoom == null) {
+                    return;
+                }
                 expect(gotRoom.name).toEqual(data[roomH].name);
                 expect(gotRoom.getMyMembership()).toEqual("join");
                 // check the entire timeline is correct
@@ -370,7 +393,9 @@ describe("SlidingSyncSdk", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomE, data[roomE]);
                 const gotRoom = client!.getRoom(roomE);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
+                if (gotRoom == null) {
+                    return;
+                }
                 expect(gotRoom.getMyMembership()).toEqual("invite");
                 expect(gotRoom.currentState.getJoinRule()).toEqual(JoinRule.Invite);
             });
@@ -379,10 +404,10 @@ describe("SlidingSyncSdk", () => {
                 mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomF, data[roomF]);
                 const gotRoom = client!.getRoom(roomF);
                 expect(gotRoom).toBeDefined();
-                if (gotRoom == null) { return; }
-                expect(
-                    gotRoom.name,
-                ).toEqual(data[roomF].name);
+                if (gotRoom == null) {
+                    return;
+                }
+                expect(gotRoom.name).toEqual(data[roomF].name);
             });
 
             describe("updating", () => {
@@ -395,7 +420,9 @@ describe("SlidingSyncSdk", () => {
                     });
                     const gotRoom = client!.getRoom(roomA);
                     expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
+                    if (gotRoom == null) {
+                        return;
+                    }
                     const newTimeline = data[roomA].timeline;
                     newTimeline.push(newEvent);
                     assertTimelineEvents(gotRoom.getLiveTimeline().getEvents().slice(-3), newTimeline);
@@ -404,18 +431,20 @@ describe("SlidingSyncSdk", () => {
                 it("can update with a new required_state event", async () => {
                     let gotRoom = client!.getRoom(roomB);
                     expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
+                    if (gotRoom == null) {
+                        return;
+                    }
                     expect(gotRoom.getJoinRule()).toEqual(JoinRule.Invite); // default
                     mockSlidingSync!.emit(SlidingSyncEvent.RoomData, roomB, {
-                        required_state: [
-                            mkOwnStateEvent("m.room.join_rules", { join_rule: "restricted" }, ""),
-                        ],
+                        required_state: [mkOwnStateEvent("m.room.join_rules", { join_rule: "restricted" }, "")],
                         timeline: [],
                         name: data[roomB].name,
                     });
                     gotRoom = client!.getRoom(roomB);
                     expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
+                    if (gotRoom == null) {
+                        return;
+                    }
                     expect(gotRoom.getJoinRule()).toEqual(JoinRule.Restricted);
                 });
 
@@ -428,10 +457,10 @@ describe("SlidingSyncSdk", () => {
                     });
                     const gotRoom = client!.getRoom(roomC);
                     expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    expect(
-                        gotRoom.getUnreadNotificationCount(NotificationCountType.Highlight),
-                    ).toEqual(1);
+                    if (gotRoom == null) {
+                        return;
+                    }
+                    expect(gotRoom.getUnreadNotificationCount(NotificationCountType.Highlight)).toEqual(1);
                 });
 
                 it("can update with a new notification_count", async () => {
@@ -443,10 +472,10 @@ describe("SlidingSyncSdk", () => {
                     });
                     const gotRoom = client!.getRoom(roomD);
                     expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
-                    expect(
-                        gotRoom.getUnreadNotificationCount(NotificationCountType.Total),
-                    ).toEqual(1);
+                    if (gotRoom == null) {
+                        return;
+                    }
+                    expect(gotRoom.getUnreadNotificationCount(NotificationCountType.Total)).toEqual(1);
                 });
 
                 it("can update with a new joined_count", () => {
@@ -458,7 +487,9 @@ describe("SlidingSyncSdk", () => {
                     });
                     const gotRoom = client!.getRoom(roomG);
                     expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
+                    if (gotRoom == null) {
+                        return;
+                    }
                     expect(gotRoom.getJoinedMemberCount()).toEqual(1);
                 });
 
@@ -482,11 +513,20 @@ describe("SlidingSyncSdk", () => {
                     });
                     const gotRoom = client!.getRoom(roomA);
                     expect(gotRoom).toBeDefined();
-                    if (gotRoom == null) { return; }
+                    if (gotRoom == null) {
+                        return;
+                    }
 
-                    logger.log("want:", oldTimeline.map((e) => (e.type + " : " + (e.content || {}).body)));
-                    logger.log("got:", gotRoom.getLiveTimeline().getEvents().map(
-                        (e) => (e.getType() + " : " + e.getContent().body)),
+                    logger.log(
+                        "want:",
+                        oldTimeline.map((e) => e.type + " : " + (e.content || {}).body),
+                    );
+                    logger.log(
+                        "got:",
+                        gotRoom
+                            .getLiveTimeline()
+                            .getEvents()
+                            .map((e) => e.getType() + " : " + e.getContent().body),
                     );
 
                     // we expect the timeline now to be oldTimeline (so the old events are in fact old)
@@ -506,40 +546,54 @@ describe("SlidingSyncSdk", () => {
         const FAILED_SYNC_ERROR_THRESHOLD = 3; // would be nice to export the const in the actual class...
 
         it("emits SyncState.Reconnecting when < FAILED_SYNC_ERROR_THRESHOLD & SyncState.Error when over", async () => {
-            mockSlidingSync!.emit(
-                SlidingSyncEvent.Lifecycle, SlidingSyncState.Complete,
-                { pos: "h", lists: [], rooms: {}, extensions: {} },
-            );
+            mockSlidingSync!.emit(SlidingSyncEvent.Lifecycle, SlidingSyncState.Complete, {
+                pos: "h",
+                lists: [],
+                rooms: {},
+                extensions: {},
+            });
             expect(sdk!.getSyncState()).toEqual(SyncState.Syncing);
 
             mockSlidingSync!.emit(
-                SlidingSyncEvent.Lifecycle, SlidingSyncState.RequestFinished, null, new Error("generic"),
+                SlidingSyncEvent.Lifecycle,
+                SlidingSyncState.RequestFinished,
+                null,
+                new Error("generic"),
             );
             expect(sdk!.getSyncState()).toEqual(SyncState.Reconnecting);
 
             for (let i = 0; i < FAILED_SYNC_ERROR_THRESHOLD; i++) {
                 mockSlidingSync!.emit(
-                    SlidingSyncEvent.Lifecycle, SlidingSyncState.RequestFinished, null, new Error("generic"),
+                    SlidingSyncEvent.Lifecycle,
+                    SlidingSyncState.RequestFinished,
+                    null,
+                    new Error("generic"),
                 );
             }
             expect(sdk!.getSyncState()).toEqual(SyncState.Error);
         });
 
         it("emits SyncState.Syncing after a previous SyncState.Error", async () => {
-            mockSlidingSync!.emit(
-                SlidingSyncEvent.Lifecycle,
-                SlidingSyncState.Complete,
-                { pos: "i", lists: [], rooms: {}, extensions: {} },
-            );
+            mockSlidingSync!.emit(SlidingSyncEvent.Lifecycle, SlidingSyncState.Complete, {
+                pos: "i",
+                lists: [],
+                rooms: {},
+                extensions: {},
+            });
             expect(sdk!.getSyncState()).toEqual(SyncState.Syncing);
         });
 
         it("emits SyncState.Error immediately when receiving M_UNKNOWN_TOKEN and stops syncing", async () => {
             expect(mockSlidingSync!.stop).not.toBeCalled();
-            mockSlidingSync!.emit(SlidingSyncEvent.Lifecycle, SlidingSyncState.RequestFinished, null, new MatrixError({
-                errcode: "M_UNKNOWN_TOKEN",
-                message: "Oh no your access token is no longer valid",
-            }));
+            mockSlidingSync!.emit(
+                SlidingSyncEvent.Lifecycle,
+                SlidingSyncState.RequestFinished,
+                null,
+                new MatrixError({
+                    errcode: "M_UNKNOWN_TOKEN",
+                    message: "Oh no your access token is no longer valid",
+                }),
+            );
             expect(sdk!.getSyncState()).toEqual(SyncState.Error);
             expect(mockSlidingSync!.stop).toBeCalled();
         });
@@ -694,7 +748,6 @@ describe("SlidingSyncSdk", () => {
                     mkOwnStateEvent(EventType.RoomMember, { membership: "join" }, selfUserId),
                     mkOwnStateEvent(EventType.RoomPowerLevels, { users: { [selfUserId]: 100 } }, ""),
                     mkOwnEvent(EventType.RoomMessage, { body: "hello" }),
-
                 ],
                 initial: true,
             });
@@ -743,18 +796,20 @@ describe("SlidingSyncSdk", () => {
             const roomId = "!foo:bar";
             const pushRulesContent: IPushRules = {
                 global: {
-                    [PushRuleKind.RoomSpecific]: [{
-                        enabled: true,
-                        default: true,
-                        pattern: "monkey",
-                        actions: [
-                            {
-                                set_tweak: TweakName.Sound,
-                                value: "default",
-                            },
-                        ],
-                        rule_id: roomId,
-                    }],
+                    [PushRuleKind.RoomSpecific]: [
+                        {
+                            enabled: true,
+                            default: true,
+                            pattern: "monkey",
+                            actions: [
+                                {
+                                    set_tweak: TweakName.Sound,
+                                    value: "default",
+                                },
+                            ],
+                            rule_id: roomId,
+                        },
+                    ],
                 },
             };
             let pushRule = client!.getRoomPushRule("global", roomId);
@@ -973,7 +1028,11 @@ describe("SlidingSyncSdk", () => {
         let ext: Extension<any, any>;
 
         const generateReceiptResponse = (
-            userId: string, roomId: string, eventId: string, recType: string, ts: number,
+            userId: string,
+            roomId: string,
+            eventId: string,
+            recType: string,
+            ts: number,
         ) => {
             return {
                 rooms: {
@@ -1034,9 +1093,7 @@ describe("SlidingSyncSdk", () => {
             const room = client!.getRoom(roomId)!;
             expect(room).toBeDefined();
             expect(room.getReadReceiptForUserId(alice, true)).toBeNull();
-            ext.onResponse(
-                generateReceiptResponse(alice, roomId, lastEvent.event_id, "m.read", 1234567),
-            );
+            ext.onResponse(generateReceiptResponse(alice, roomId, lastEvent.event_id, "m.read", 1234567));
             const receipt = room.getReadReceiptForUserId(alice);
             expect(receipt).toBeDefined();
             expect(receipt?.eventId).toEqual(lastEvent.event_id);
@@ -1048,9 +1105,7 @@ describe("SlidingSyncSdk", () => {
             const roomId = "!room:id";
             const alice = "@alice:alice";
             const eventId = "$something";
-            ext.onResponse(
-                generateReceiptResponse(alice, roomId, eventId, "m.read", 1234567),
-            );
+            ext.onResponse(generateReceiptResponse(alice, roomId, eventId, "m.read", 1234567));
             // we expect it not to crash
         });
     });
diff --git a/spec/integ/sliding-sync.spec.ts b/spec/integ/sliding-sync.spec.ts
index d90c0236a56..4655ca0efd0 100644
--- a/spec/integ/sliding-sync.spec.ts
+++ b/spec/integ/sliding-sync.spec.ts
@@ -104,8 +104,12 @@ describe("SlidingSync", () => {
             };
             const ext: Extension<any, any> = {
                 name: () => "custom_extension",
-                onRequest: (initial) => { return { initial: initial }; },
-                onResponse: (res) => { return {}; },
+                onRequest: (initial) => {
+                    return { initial: initial };
+                },
+                onResponse: (res) => {
+                    return {};
+                },
                 when: () => ExtensionState.PreProcess,
             };
             slidingSync.modifyRoomSubscriptions(new Set([roomId]));
@@ -116,49 +120,55 @@ describe("SlidingSync", () => {
 
             // expect everything to be sent
             let txnId: string | undefined;
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toEqual({
-                    [roomId]: subInfo,
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toEqual({
+                        [roomId]: subInfo,
+                    });
+                    expect(body.lists[0]).toEqual(listInfo);
+                    expect(body.extensions).toBeTruthy();
+                    expect(body.extensions["custom_extension"]).toEqual({ initial: true });
+                    expect(req.queryParams!["pos"]).toBeUndefined();
+                    txnId = body.txn_id;
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "11",
+                        lists: [{ count: 5 }],
+                        extensions: {},
+                        txn_id: txnId,
+                    };
                 });
-                expect(body.lists[0]).toEqual(listInfo);
-                expect(body.extensions).toBeTruthy();
-                expect(body.extensions["custom_extension"]).toEqual({ initial: true });
-                expect(req.queryParams!["pos"]).toBeUndefined();
-                txnId = body.txn_id;
-            }).respond(200, function() {
-                return {
-                    pos: "11",
-                    lists: [{ count: 5 }],
-                    extensions: {},
-                    txn_id: txnId,
-                };
-            });
             await httpBackend!.flushAllExpected();
 
             // expect nothing but ranges and non-initial extensions to be sent
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toBeFalsy();
-                expect(body.lists[0]).toEqual({
-                    ranges: [[0, 10]],
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toBeFalsy();
+                    expect(body.lists[0]).toEqual({
+                        ranges: [[0, 10]],
+                    });
+                    expect(body.extensions).toBeTruthy();
+                    expect(body.extensions["custom_extension"]).toEqual({ initial: false });
+                    expect(req.queryParams!["pos"]).toEqual("11");
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "12",
+                        lists: [{ count: 5 }],
+                        extensions: {},
+                    };
                 });
-                expect(body.extensions).toBeTruthy();
-                expect(body.extensions["custom_extension"]).toEqual({ initial: false });
-                expect(req.queryParams!["pos"]).toEqual("11");
-            }).respond(200, function() {
-                return {
-                    pos: "12",
-                    lists: [{ count: 5 }],
-                    extensions: {},
-                };
-            });
             await httpBackend!.flushAllExpected();
 
             // now we expire the session
-            httpBackend!.when("POST", syncUrl).respond(400, function() {
+            httpBackend!.when("POST", syncUrl).respond(400, function () {
                 logger.debug("sending session expired 400");
                 return {
                     error: "HTTP 400 : session expired",
@@ -167,23 +177,26 @@ describe("SlidingSync", () => {
             await httpBackend!.flushAllExpected();
 
             // ...and everything should be sent again
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toEqual({
-                    [roomId]: subInfo,
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toEqual({
+                        [roomId]: subInfo,
+                    });
+                    expect(body.lists[0]).toEqual(listInfo);
+                    expect(body.extensions).toBeTruthy();
+                    expect(body.extensions["custom_extension"]).toEqual({ initial: true });
+                    expect(req.queryParams!["pos"]).toBeUndefined();
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "1",
+                        lists: [{ count: 6 }],
+                        extensions: {},
+                    };
                 });
-                expect(body.lists[0]).toEqual(listInfo);
-                expect(body.extensions).toBeTruthy();
-                expect(body.extensions["custom_extension"]).toEqual({ initial: true });
-                expect(req.queryParams!["pos"]).toBeUndefined();
-            }).respond(200, function() {
-                return {
-                    pos: "1",
-                    lists: [{ count: 6 }],
-                    extensions: {},
-                };
-            });
             await httpBackend!.flushAllExpected();
             slidingSync.stop();
         });
@@ -196,9 +209,7 @@ describe("SlidingSync", () => {
         const anotherRoomID = "!another:room";
         let roomSubInfo = {
             timeline_limit: 1,
-            required_state: [
-                ["m.room.name", ""],
-            ],
+            required_state: [["m.room.name", ""]],
         };
         const wantRoomData = {
             name: "foo bar",
@@ -212,19 +223,22 @@ describe("SlidingSync", () => {
             // add the subscription
             slidingSync = new SlidingSync(proxyBaseUrl, [], roomSubInfo, client!, 1);
             slidingSync.modifyRoomSubscriptions(new Set([roomId]));
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("room sub", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomId]).toEqual(roomSubInfo);
-            }).respond(200, {
-                pos: "a",
-                lists: [],
-                extensions: {},
-                rooms: {
-                    [roomId]: wantRoomData,
-                },
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("room sub", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomId]).toEqual(roomSubInfo);
+                })
+                .respond(200, {
+                    pos: "a",
+                    lists: [],
+                    extensions: {},
+                    rooms: {
+                        [roomId]: wantRoomData,
+                    },
+                });
 
             const p = listenUntil(slidingSync, "SlidingSync.RoomData", (gotRoomId, gotRoomData) => {
                 expect(gotRoomId).toEqual(roomId);
@@ -240,23 +254,24 @@ describe("SlidingSync", () => {
             // listen for updated request
             const newSubInfo = {
                 timeline_limit: 100,
-                required_state: [
-                    ["m.room.member", "*"],
-                ],
+                required_state: [["m.room.member", "*"]],
             };
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("adjusted sub", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomId]).toEqual(newSubInfo);
-            }).respond(200, {
-                pos: "a",
-                lists: [],
-                extensions: {},
-                rooms: {
-                    [roomId]: wantRoomData,
-                },
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("adjusted sub", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomId]).toEqual(newSubInfo);
+                })
+                .respond(200, {
+                    pos: "a",
+                    lists: [],
+                    extensions: {},
+                    rooms: {
+                        [roomId]: wantRoomData,
+                    },
+                });
 
             const p = listenUntil(slidingSync, "SlidingSync.RoomData", (gotRoomId, gotRoomData) => {
                 expect(gotRoomId).toEqual(roomId);
@@ -286,21 +301,24 @@ describe("SlidingSync", () => {
                 required_state: [],
                 timeline: [],
             };
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("new subs", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                // only the new room is sent, the other is sticky
-                expect(body.room_subscriptions[anotherRoomID]).toEqual(roomSubInfo);
-                expect(body.room_subscriptions[roomId]).toBeUndefined();
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-                extensions: {},
-                rooms: {
-                    [anotherRoomID]: anotherRoomData,
-                },
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("new subs", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    // only the new room is sent, the other is sticky
+                    expect(body.room_subscriptions[anotherRoomID]).toEqual(roomSubInfo);
+                    expect(body.room_subscriptions[roomId]).toBeUndefined();
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                    extensions: {},
+                    rooms: {
+                        [anotherRoomID]: anotherRoomData,
+                    },
+                });
 
             const p = listenUntil(slidingSync, "SlidingSync.RoomData", (gotRoomId, gotRoomData) => {
                 expect(gotRoomId).toEqual(anotherRoomID);
@@ -316,15 +334,18 @@ describe("SlidingSync", () => {
         });
 
         it("should be able to unsubscribe from a room", async () => {
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("unsub request", body);
-                expect(body.room_subscriptions).toBeFalsy();
-                expect(body.unsubscribe_rooms).toEqual([roomId]);
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("unsub request", body);
+                    expect(body.room_subscriptions).toBeFalsy();
+                    expect(body.unsubscribe_rooms).toEqual([roomId]);
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                });
 
             const p = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
@@ -364,7 +385,10 @@ describe("SlidingSync", () => {
                 timeline: [],
             },
         };
-        const newRanges = [[0, 2], [3, 5]];
+        const newRanges = [
+            [0, 2],
+            [3, 5],
+        ];
 
         let slidingSync: SlidingSync;
         it("should be possible to subscribe to a list", async () => {
@@ -373,31 +397,36 @@ describe("SlidingSync", () => {
                 ranges: [[0, 2]],
                 sort: ["by_name"],
                 timeline_limit: 1,
-                required_state: [
-                    ["m.room.topic", ""],
-                ],
+                required_state: [["m.room.topic", ""]],
                 filters: {
                     is_dm: true,
                 },
             };
             slidingSync = new SlidingSync(proxyBaseUrl, [listReq], {}, client!, 1);
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("list", body);
-                expect(body.lists).toBeTruthy();
-                expect(body.lists[0]).toEqual(listReq);
-            }).respond(200, {
-                pos: "a",
-                lists: [{
-                    count: 500,
-                    ops: [{
-                        op: "SYNC",
-                        range: [0, 2],
-                        room_ids: Object.keys(rooms),
-                    }],
-                }],
-                rooms: rooms,
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("list", body);
+                    expect(body.lists).toBeTruthy();
+                    expect(body.lists[0]).toEqual(listReq);
+                })
+                .respond(200, {
+                    pos: "a",
+                    lists: [
+                        {
+                            count: 500,
+                            ops: [
+                                {
+                                    op: "SYNC",
+                                    range: [0, 2],
+                                    room_ids: Object.keys(rooms),
+                                },
+                            ],
+                        },
+                    ],
+                    rooms: rooms,
+                });
             const listenerData: Record<string, MSC3575RoomData> = {};
             const dataListener: SlidingSyncEventHandlerMap[SlidingSyncEvent.RoomData] = (roomId, roomData) => {
                 expect(listenerData[roomId]).toBeFalsy();
@@ -434,25 +463,32 @@ describe("SlidingSync", () => {
 
         it("should be possible to adjust list ranges", async () => {
             // modify the list ranges
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("next ranges", body.lists[0].ranges);
-                expect(body.lists).toBeTruthy();
-                expect(body.lists[0]).toEqual({
-                    // only the ranges should be sent as the rest are unchanged and sticky
-                    ranges: newRanges,
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("next ranges", body.lists[0].ranges);
+                    expect(body.lists).toBeTruthy();
+                    expect(body.lists[0]).toEqual({
+                        // only the ranges should be sent as the rest are unchanged and sticky
+                        ranges: newRanges,
+                    });
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [
+                        {
+                            count: 500,
+                            ops: [
+                                {
+                                    op: "SYNC",
+                                    range: [0, 2],
+                                    room_ids: Object.keys(rooms),
+                                },
+                            ],
+                        },
+                    ],
                 });
-            }).respond(200, {
-                pos: "b",
-                lists: [{
-                    count: 500,
-                    ops: [{
-                        op: "SYNC",
-                        range: [0, 2],
-                        room_ids: Object.keys(rooms),
-                    }],
-                }],
-            });
 
             const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.RequestFinished;
@@ -468,34 +504,39 @@ describe("SlidingSync", () => {
                 ranges: [[0, 100]],
                 sort: ["by_name"],
                 filters: {
-                    "is_dm": true,
+                    is_dm: true,
                 },
             };
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("extra list", body);
-                expect(body.lists).toBeTruthy();
-                expect(body.lists[0]).toEqual({
-                    // only the ranges should be sent as the rest are unchanged and sticky
-                    ranges: newRanges,
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("extra list", body);
+                    expect(body.lists).toBeTruthy();
+                    expect(body.lists[0]).toEqual({
+                        // only the ranges should be sent as the rest are unchanged and sticky
+                        ranges: newRanges,
+                    });
+                    expect(body.lists[1]).toEqual(extraListReq);
+                })
+                .respond(200, {
+                    pos: "c",
+                    lists: [
+                        {
+                            count: 500,
+                        },
+                        {
+                            count: 50,
+                            ops: [
+                                {
+                                    op: "SYNC",
+                                    range: [0, 2],
+                                    room_ids: Object.keys(rooms),
+                                },
+                            ],
+                        },
+                    ],
                 });
-                expect(body.lists[1]).toEqual(extraListReq);
-            }).respond(200, {
-                pos: "c",
-                lists: [
-                    {
-                        count: 500,
-                    },
-                    {
-                        count: 50,
-                        ops: [{
-                            op: "SYNC",
-                            range: [0, 2],
-                            room_ids: Object.keys(rooms),
-                        }],
-                    },
-                ],
-            });
             listenUntil(slidingSync, "SlidingSync.List", (listIndex, joinedCount, roomIndexToRoomId) => {
                 expect(listIndex).toEqual(1);
                 expect(joinedCount).toEqual(50);
@@ -518,22 +559,29 @@ describe("SlidingSync", () => {
             // move C (2) to A (0)
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "e",
-                lists: [{
-                    count: 500,
-                    ops: [{
-                        op: "DELETE",
-                        index: 2,
-                    }, {
-                        op: "INSERT",
-                        index: 0,
-                        room_id: roomC,
-                    }],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 500,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 2,
+                            },
+                            {
+                                op: "INSERT",
+                                index: 0,
+                                room_id: roomC,
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
-            let listPromise = listenUntil(slidingSync, "SlidingSync.List",
+            let listPromise = listenUntil(
+                slidingSync,
+                "SlidingSync.List",
                 (listIndex, joinedCount, roomIndexToRoomId) => {
                     expect(listIndex).toEqual(0);
                     expect(joinedCount).toEqual(500);
@@ -543,7 +591,8 @@ describe("SlidingSync", () => {
                         2: roomB,
                     });
                     return true;
-                });
+                },
+            );
             let responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -554,32 +603,36 @@ describe("SlidingSync", () => {
             // move C (0) back to A (2)
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "f",
-                lists: [{
-                    count: 500,
-                    ops: [{
-                        op: "DELETE",
-                        index: 0,
-                    }, {
-                        op: "INSERT",
-                        index: 2,
-                        room_id: roomC,
-                    }],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 500,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 0,
+                            },
+                            {
+                                op: "INSERT",
+                                index: 2,
+                                room_id: roomC,
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
-            listPromise = listenUntil(slidingSync, "SlidingSync.List",
-                (listIndex, joinedCount, roomIndexToRoomId) => {
-                    expect(listIndex).toEqual(0);
-                    expect(joinedCount).toEqual(500);
-                    expect(roomIndexToRoomId).toEqual({
-                        0: roomA,
-                        1: roomB,
-                        2: roomC,
-                    });
-                    return true;
+            listPromise = listenUntil(slidingSync, "SlidingSync.List", (listIndex, joinedCount, roomIndexToRoomId) => {
+                expect(listIndex).toEqual(0);
+                expect(joinedCount).toEqual(500);
+                expect(roomIndexToRoomId).toEqual({
+                    0: roomA,
+                    1: roomB,
+                    2: roomC,
                 });
+                return true;
+            });
             responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -591,18 +644,24 @@ describe("SlidingSync", () => {
         it("should ignore invalid list indexes", async () => {
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "e",
-                lists: [{
-                    count: 500,
-                    ops: [{
-                        op: "DELETE",
-                        index: 2324324,
-                    }],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 500,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 2324324,
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
-            const listPromise = listenUntil(slidingSync, "SlidingSync.List",
+            const listPromise = listenUntil(
+                slidingSync,
+                "SlidingSync.List",
                 (listIndex, joinedCount, roomIndexToRoomId) => {
                     expect(listIndex).toEqual(0);
                     expect(joinedCount).toEqual(500);
@@ -612,7 +671,8 @@ describe("SlidingSync", () => {
                         2: roomC,
                     });
                     return true;
-                });
+                },
+            );
             const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -624,23 +684,25 @@ describe("SlidingSync", () => {
         it("should be possible to update a list", async () => {
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "g",
-                lists: [{
-                    count: 42,
-                    ops: [
-                        {
-                            op: "INVALIDATE",
-                            range: [0, 2],
-                        },
-                        {
-                            op: "SYNC",
-                            range: [0, 1],
-                            room_ids: [roomB, roomC],
-                        },
-                    ],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 42,
+                        ops: [
+                            {
+                                op: "INVALIDATE",
+                                range: [0, 2],
+                            },
+                            {
+                                op: "SYNC",
+                                range: [0, 1],
+                                room_ids: [roomB, roomC],
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
             // update the list with a new filter
             slidingSync.setList(0, {
@@ -649,7 +711,9 @@ describe("SlidingSync", () => {
                 },
                 ranges: [[0, 100]],
             });
-            const listPromise = listenUntil(slidingSync, "SlidingSync.List",
+            const listPromise = listenUntil(
+                slidingSync,
+                "SlidingSync.List",
                 (listIndex, joinedCount, roomIndexToRoomId) => {
                     expect(listIndex).toEqual(0);
                     expect(joinedCount).toEqual(42);
@@ -658,7 +722,8 @@ describe("SlidingSync", () => {
                         1: roomC,
                     });
                     return true;
-                });
+                },
+            );
             const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -677,31 +742,40 @@ describe("SlidingSync", () => {
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "f",
                 // currently the list is [B,C] so we will insert D then immediately delete it
-                lists: [{
-                    count: 500,
-                    ops: [
-                        {
-                            op: "DELETE", index: 2,
-                        },
-                        {
-                            op: "INSERT", index: 0, room_id: roomA,
-                        },
-                        {
-                            op: "DELETE", index: 0,
-                        },
-                    ],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 500,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 2,
+                            },
+                            {
+                                op: "INSERT",
+                                index: 0,
+                                room_id: roomA,
+                            },
+                            {
+                                op: "DELETE",
+                                index: 0,
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
-            const listPromise = listenUntil(slidingSync, "SlidingSync.List",
+            const listPromise = listenUntil(
+                slidingSync,
+                "SlidingSync.List",
                 (listIndex, joinedCount, roomIndexToRoomId) => {
                     expect(listIndex).toEqual(0);
                     expect(joinedCount).toEqual(500);
                     expect(roomIndexToRoomId).toEqual(indexToRoomId);
                     return true;
-                });
+                },
+            );
             const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -717,19 +791,24 @@ describe("SlidingSync", () => {
             });
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "g",
-                lists: [{
-                    count: 499,
-                    ops: [
-                        {
-                            op: "DELETE", index: 0,
-                        },
-                    ],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 499,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 0,
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
-            const listPromise = listenUntil(slidingSync, "SlidingSync.List",
+            const listPromise = listenUntil(
+                slidingSync,
+                "SlidingSync.List",
                 (listIndex, joinedCount, roomIndexToRoomId) => {
                     expect(listIndex).toEqual(0);
                     expect(joinedCount).toEqual(499);
@@ -737,7 +816,8 @@ describe("SlidingSync", () => {
                         0: roomC,
                     });
                     return true;
-                });
+                },
+            );
             const responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -752,19 +832,25 @@ describe("SlidingSync", () => {
             });
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "h",
-                lists: [{
-                    count: 500,
-                    ops: [
-                        {
-                            op: "INSERT", index: 1, room_id: roomA,
-                        },
-                    ],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 500,
+                        ops: [
+                            {
+                                op: "INSERT",
+                                index: 1,
+                                room_id: roomA,
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
-            let listPromise = listenUntil(slidingSync, "SlidingSync.List",
+            let listPromise = listenUntil(
+                slidingSync,
+                "SlidingSync.List",
                 (listIndex, joinedCount, roomIndexToRoomId) => {
                     expect(listIndex).toEqual(0);
                     expect(joinedCount).toEqual(500);
@@ -773,7 +859,8 @@ describe("SlidingSync", () => {
                         1: roomA,
                     });
                     return true;
-                });
+                },
+            );
             let responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -783,29 +870,32 @@ describe("SlidingSync", () => {
 
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "h",
-                lists: [{
-                    count: 501,
-                    ops: [
-                        {
-                            op: "INSERT", index: 1, room_id: roomB,
-                        },
-                    ],
-                },
-                {
-                    count: 50,
-                }],
+                lists: [
+                    {
+                        count: 501,
+                        ops: [
+                            {
+                                op: "INSERT",
+                                index: 1,
+                                room_id: roomB,
+                            },
+                        ],
+                    },
+                    {
+                        count: 50,
+                    },
+                ],
             });
-            listPromise = listenUntil(slidingSync, "SlidingSync.List",
-                (listIndex, joinedCount, roomIndexToRoomId) => {
-                    expect(listIndex).toEqual(0);
-                    expect(joinedCount).toEqual(501);
-                    expect(roomIndexToRoomId).toEqual({
-                        0: roomC,
-                        1: roomB,
-                        2: roomA,
-                    });
-                    return true;
+            listPromise = listenUntil(slidingSync, "SlidingSync.List", (listIndex, joinedCount, roomIndexToRoomId) => {
+                expect(listIndex).toEqual(0);
+                expect(joinedCount).toEqual(501);
+                expect(roomIndexToRoomId).toEqual({
+                    0: roomC,
+                    1: roomB,
+                    2: roomA,
                 });
+                return true;
+            });
             responseProcessed = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state) => {
                 return state === SlidingSyncState.Complete;
             });
@@ -818,18 +908,26 @@ describe("SlidingSync", () => {
         // Regression test to make sure things like DELETE 0 INSERT 0 work correctly and we don't
         // end up losing room IDs.
         it("should handle insertions with a spurious DELETE correctly", async () => {
-            slidingSync = new SlidingSync(proxyBaseUrl, [
-                {
-                    ranges: [[0, 20]],
-                },
-            ], {}, client!, 1);
+            slidingSync = new SlidingSync(
+                proxyBaseUrl,
+                [
+                    {
+                        ranges: [[0, 20]],
+                    },
+                ],
+                {},
+                client!,
+                1,
+            );
             // initially start with nothing
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "a",
-                lists: [{
-                    count: 0,
-                    ops: [],
-                }],
+                lists: [
+                    {
+                        count: 0,
+                        ops: [],
+                    },
+                ],
             });
             slidingSync.start();
             await httpBackend!.flushAllExpected();
@@ -838,17 +936,22 @@ describe("SlidingSync", () => {
             // insert a room
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "b",
-                lists: [{
-                    count: 1,
-                    ops: [
-                        {
-                            op: "DELETE", index: 0,
-                        },
-                        {
-                            op: "INSERT", index: 0, room_id: roomA,
-                        },
-                    ],
-                }],
+                lists: [
+                    {
+                        count: 1,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 0,
+                            },
+                            {
+                                op: "INSERT",
+                                index: 0,
+                                room_id: roomA,
+                            },
+                        ],
+                    },
+                ],
             });
             await httpBackend!.flushAllExpected();
             expect(slidingSync.getListData(0)!.roomIndexToRoomId).toEqual({
@@ -858,17 +961,22 @@ describe("SlidingSync", () => {
             // insert another room
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "c",
-                lists: [{
-                    count: 1,
-                    ops: [
-                        {
-                            op: "DELETE", index: 1,
-                        },
-                        {
-                            op: "INSERT", index: 0, room_id: roomB,
-                        },
-                    ],
-                }],
+                lists: [
+                    {
+                        count: 1,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 1,
+                            },
+                            {
+                                op: "INSERT",
+                                index: 0,
+                                room_id: roomB,
+                            },
+                        ],
+                    },
+                ],
             });
             await httpBackend!.flushAllExpected();
             expect(slidingSync.getListData(0)!.roomIndexToRoomId).toEqual({
@@ -879,17 +987,22 @@ describe("SlidingSync", () => {
             // insert a final room
             httpBackend!.when("POST", syncUrl).respond(200, {
                 pos: "c",
-                lists: [{
-                    count: 1,
-                    ops: [
-                        {
-                            op: "DELETE", index: 2,
-                        },
-                        {
-                            op: "INSERT", index: 0, room_id: roomC,
-                        },
-                    ],
-                }],
+                lists: [
+                    {
+                        count: 1,
+                        ops: [
+                            {
+                                op: "DELETE",
+                                index: 2,
+                            },
+                            {
+                                op: "INSERT",
+                                index: 0,
+                                room_id: roomC,
+                            },
+                        ],
+                    },
+                ],
             });
             await httpBackend!.flushAllExpected();
             expect(slidingSync.getListData(0)!.roomIndexToRoomId).toEqual({
@@ -912,37 +1025,38 @@ describe("SlidingSync", () => {
         it("should resolve modifyRoomSubscriptions after SlidingSync.start() is called", async () => {
             const roomSubInfo = {
                 timeline_limit: 1,
-                required_state: [
-                    ["m.room.name", ""],
-                ],
+                required_state: [["m.room.name", ""]],
             };
             // add the subscription
             slidingSync = new SlidingSync(proxyBaseUrl, [], roomSubInfo, client!, 1);
             // modification before SlidingSync.start()
             const subscribePromise = slidingSync.modifyRoomSubscriptions(new Set([roomId]));
             let txnId: string | undefined;
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomId]).toEqual(roomSubInfo);
-                expect(body.txn_id).toBeTruthy();
-                txnId = body.txn_id;
-            }).respond(200, function() {
-                return {
-                    pos: "aaa",
-                    txn_id: txnId,
-                    lists: [],
-                    extensions: {},
-                    rooms: {
-                        [roomId]: {
-                            name: "foo bar",
-                            required_state: [],
-                            timeline: [],
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomId]).toEqual(roomSubInfo);
+                    expect(body.txn_id).toBeTruthy();
+                    txnId = body.txn_id;
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "aaa",
+                        txn_id: txnId,
+                        lists: [],
+                        extensions: {},
+                        rooms: {
+                            [roomId]: {
+                                name: "foo bar",
+                                required_state: [],
+                                timeline: [],
+                            },
                         },
-                    },
-                };
-            });
+                    };
+                });
             slidingSync.start();
             await httpBackend!.flushAllExpected();
             await subscribePromise;
@@ -953,21 +1067,24 @@ describe("SlidingSync", () => {
             };
             const promise = slidingSync.setList(0, newList);
             let txnId: string | undefined;
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toBeFalsy();
-                expect(body.lists[0]).toEqual(newList);
-                expect(body.txn_id).toBeTruthy();
-                txnId = body.txn_id;
-            }).respond(200, function() {
-                return {
-                    pos: "bbb",
-                    txn_id: txnId,
-                    lists: [{ count: 5 }],
-                    extensions: {},
-                };
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toBeFalsy();
+                    expect(body.lists[0]).toEqual(newList);
+                    expect(body.txn_id).toBeTruthy();
+                    txnId = body.txn_id;
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "bbb",
+                        txn_id: txnId,
+                        lists: [{ count: 5 }],
+                        extensions: {},
+                    };
+                });
             await httpBackend!.flushAllExpected();
             await promise;
             expect(txnId).toBeDefined();
@@ -975,23 +1092,26 @@ describe("SlidingSync", () => {
         it("should resolve setListRanges during a connection", async () => {
             const promise = slidingSync.setListRanges(0, [[20, 40]]);
             let txnId: string | undefined;
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toBeFalsy();
-                expect(body.lists[0]).toEqual({
-                    ranges: [[20, 40]],
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toBeFalsy();
+                    expect(body.lists[0]).toEqual({
+                        ranges: [[20, 40]],
+                    });
+                    expect(body.txn_id).toBeTruthy();
+                    txnId = body.txn_id;
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "ccc",
+                        txn_id: txnId,
+                        lists: [{ count: 5 }],
+                        extensions: {},
+                    };
                 });
-                expect(body.txn_id).toBeTruthy();
-                txnId = body.txn_id;
-            }).respond(200, function() {
-                return {
-                    pos: "ccc",
-                    txn_id: txnId,
-                    lists: [{ count: 5 }],
-                    extensions: {},
-                };
-            });
             await httpBackend!.flushAllExpected();
             await promise;
             expect(txnId).toBeDefined();
@@ -1001,22 +1121,25 @@ describe("SlidingSync", () => {
                 timeline_limit: 99,
             });
             let txnId: string | undefined;
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomId]).toEqual({
-                    timeline_limit: 99,
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomId]).toEqual({
+                        timeline_limit: 99,
+                    });
+                    expect(body.txn_id).toBeTruthy();
+                    txnId = body.txn_id;
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "ddd",
+                        txn_id: txnId,
+                        extensions: {},
+                    };
                 });
-                expect(body.txn_id).toBeTruthy();
-                txnId = body.txn_id;
-            }).respond(200, function() {
-                return {
-                    pos: "ddd",
-                    txn_id: txnId,
-                    extensions: {},
-                };
-            });
             await httpBackend!.flushAllExpected();
             await promise;
             expect(txnId).toBeDefined();
@@ -1024,7 +1147,7 @@ describe("SlidingSync", () => {
         it("should reject earlier pending promises if a later transaction is acknowledged", async () => {
             // i.e if we have [A,B,C] and see txn_id=C then A,B should be rejected.
             const gotTxnIds: any[] = [];
-            const pushTxn = function(req: MockHttpBackend["requests"][0]) {
+            const pushTxn = function (req: MockHttpBackend["requests"][0]) {
                 gotTxnIds.push(req.data.txn_id);
             };
             const failPromise = slidingSync.setListRanges(0, [[20, 40]]);
@@ -1041,15 +1164,18 @@ describe("SlidingSync", () => {
 
             const okPromise = slidingSync.setListRanges(0, [[0, 20]]);
             let txnId: string | undefined;
-            httpBackend!.when("POST", syncUrl).check((req) => {
-                txnId = req.data.txn_id;
-            }).respond(200, () => {
-                // include the txn_id, earlier requests should now be reject()ed.
-                return {
-                    pos: "g",
-                    txn_id: txnId,
-                };
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check((req) => {
+                    txnId = req.data.txn_id;
+                })
+                .respond(200, () => {
+                    // include the txn_id, earlier requests should now be reject()ed.
+                    return {
+                        pos: "g",
+                        txn_id: txnId,
+                    };
+                });
             await httpBackend!.flushAllExpected();
             await okPromise;
 
@@ -1058,7 +1184,7 @@ describe("SlidingSync", () => {
         it("should not reject later pending promises if an earlier transaction is acknowledged", async () => {
             // i.e if we have [A,B,C] and see txn_id=B then C should not be rejected but A should.
             const gotTxnIds: any[] = [];
-            const pushTxn = function(req: MockHttpBackend["requests"][0]) {
+            const pushTxn = function (req: MockHttpBackend["requests"][0]) {
                 gotTxnIds.push(req.data?.txn_id);
             };
             const A = slidingSync.setListRanges(0, [[20, 40]]);
@@ -1077,13 +1203,16 @@ describe("SlidingSync", () => {
             C.finally(() => {
                 pendingC = false;
             });
-            httpBackend!.when("POST", syncUrl).check(pushTxn).respond(200, () => {
-                // include the txn_id for B, so C's promise is outstanding
-                return {
-                    pos: "C",
-                    txn_id: gotTxnIds[1],
-                };
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(pushTxn)
+                .respond(200, () => {
+                    // include the txn_id for B, so C's promise is outstanding
+                    return {
+                        pos: "C",
+                        txn_id: gotTxnIds[1],
+                    };
+                });
             await httpBackend!.flushAllExpected();
             // A is rejected, see above
             expect(B).resolves.toEqual(gotTxnIds[1]); // B is resolved
@@ -1096,23 +1225,26 @@ describe("SlidingSync", () => {
                 pending = false;
             });
             let txnId: string | undefined;
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.debug("got ", body);
-                expect(body.room_subscriptions).toBeFalsy();
-                expect(body.lists[0]).toEqual({
-                    ranges: [[20, 40]],
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.debug("got ", body);
+                    expect(body.room_subscriptions).toBeFalsy();
+                    expect(body.lists[0]).toEqual({
+                        ranges: [[20, 40]],
+                    });
+                    expect(body.txn_id).toBeTruthy();
+                    txnId = body.txn_id;
+                })
+                .respond(200, function () {
+                    return {
+                        pos: "ccc",
+                        txn_id: "bogus transaction id",
+                        lists: [{ count: 5 }],
+                        extensions: {},
+                    };
                 });
-                expect(body.txn_id).toBeTruthy();
-                txnId = body.txn_id;
-            }).respond(200, function() {
-                return {
-                    pos: "ccc",
-                    txn_id: "bogus transaction id",
-                    lists: [{ count: 5 }],
-                    extensions: {},
-                };
-            });
             await httpBackend!.flushAllExpected();
             expect(txnId).toBeDefined();
             expect(pending).toBe(true);
@@ -1157,20 +1289,23 @@ describe("SlidingSync", () => {
             slidingSync.useCustomSubscription(roomC, customSubName2);
             slidingSync.modifyRoomSubscriptions(new Set<string>([roomA, roomB, roomC, roomD]));
 
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("custom subs", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomA]).toEqual(customSub1);
-                expect(body.room_subscriptions[roomB]).toEqual(customSub1);
-                expect(body.room_subscriptions[roomC]).toEqual(customSub2);
-                expect(body.room_subscriptions[roomD]).toEqual(defaultSub);
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-                extensions: {},
-                rooms: {},
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("custom subs", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomA]).toEqual(customSub1);
+                    expect(body.room_subscriptions[roomB]).toEqual(customSub1);
+                    expect(body.room_subscriptions[roomC]).toEqual(customSub2);
+                    expect(body.room_subscriptions[roomD]).toEqual(defaultSub);
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                    extensions: {},
+                    rooms: {},
+                });
             slidingSync.start();
             await httpBackend!.flushAllExpected();
             slidingSync.stop();
@@ -1182,64 +1317,76 @@ describe("SlidingSync", () => {
             slidingSync.addCustomSubscription(customSubName1, customSub1);
             slidingSync.addCustomSubscription(customSubName2, customSub2);
             // initially no subs
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("custom subs", body);
-                expect(body.room_subscriptions).toBeFalsy();
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-                extensions: {},
-                rooms: {},
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("custom subs", body);
+                    expect(body.room_subscriptions).toBeFalsy();
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                    extensions: {},
+                    rooms: {},
+                });
             slidingSync.start();
             await httpBackend!.flushAllExpected();
 
             // now the user clicks on a room which uses the default sub
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("custom subs", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomA]).toEqual(defaultSub);
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-                extensions: {},
-                rooms: {},
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("custom subs", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomA]).toEqual(defaultSub);
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                    extensions: {},
+                    rooms: {},
+                });
             slidingSync.modifyRoomSubscriptions(new Set<string>([roomA]));
             await httpBackend!.flushAllExpected();
 
             // now the user clicks on a room which uses a custom sub
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("custom subs", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomB]).toEqual(customSub1);
-                expect(body.unsubscribe_rooms).toEqual([roomA]);
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-                extensions: {},
-                rooms: {},
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("custom subs", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomB]).toEqual(customSub1);
+                    expect(body.unsubscribe_rooms).toEqual([roomA]);
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                    extensions: {},
+                    rooms: {},
+                });
             slidingSync.useCustomSubscription(roomB, customSubName1);
             slidingSync.modifyRoomSubscriptions(new Set<string>([roomB]));
             await httpBackend!.flushAllExpected();
 
             // now the user uses a different sub for the same room: we don't unsub but just resend
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("custom subs", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomB]).toEqual(customSub2);
-                expect(body.unsubscribe_rooms).toBeFalsy();
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-                extensions: {},
-                rooms: {},
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("custom subs", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomB]).toEqual(customSub2);
+                    expect(body.unsubscribe_rooms).toBeFalsy();
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                    extensions: {},
+                    rooms: {},
+                });
             slidingSync.useCustomSubscription(roomB, customSubName2);
             slidingSync.modifyRoomSubscriptions(new Set<string>([roomB]));
             await httpBackend!.flushAllExpected();
@@ -1253,17 +1400,20 @@ describe("SlidingSync", () => {
             slidingSync.useCustomSubscription(roomA, "unknown name");
             slidingSync.modifyRoomSubscriptions(new Set<string>([roomA]));
 
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("custom subs", body);
-                expect(body.room_subscriptions).toBeTruthy();
-                expect(body.room_subscriptions[roomA]).toEqual(defaultSub);
-            }).respond(200, {
-                pos: "b",
-                lists: [],
-                extensions: {},
-                rooms: {},
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("custom subs", body);
+                    expect(body.room_subscriptions).toBeTruthy();
+                    expect(body.room_subscriptions[roomA]).toEqual(defaultSub);
+                })
+                .respond(200, {
+                    pos: "b",
+                    lists: [],
+                    extensions: {},
+                    rooms: {},
+                });
             slidingSync.start();
             await httpBackend!.flushAllExpected();
             slidingSync.stop();
@@ -1293,14 +1443,22 @@ describe("SlidingSync", () => {
 
         const extPre: Extension<any, any> = {
             name: () => preExtName,
-            onRequest: (initial) => { return onPreExtensionRequest(initial); },
-            onResponse: (res) => { return onPreExtensionResponse(res); },
+            onRequest: (initial) => {
+                return onPreExtensionRequest(initial);
+            },
+            onResponse: (res) => {
+                return onPreExtensionResponse(res);
+            },
             when: () => ExtensionState.PreProcess,
         };
         const extPost: Extension<any, any> = {
             name: () => postExtName,
-            onRequest: (initial) => { return onPostExtensionRequest(initial); },
-            onResponse: (res) => { return onPostExtensionResponse(res); },
+            onRequest: (initial) => {
+                return onPostExtensionRequest(initial);
+            },
+            onResponse: (res) => {
+                return onPostExtensionResponse(res);
+            },
             when: () => ExtensionState.PostProcess,
         };
 
@@ -1319,19 +1477,22 @@ describe("SlidingSync", () => {
                 expect(resp).toEqual(extResp);
             };
 
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("ext req", body);
-                expect(body.extensions).toBeTruthy();
-                expect(body.extensions[preExtName]).toEqual(extReq);
-            }).respond(200, {
-                pos: "a",
-                ops: [],
-                counts: [],
-                extensions: {
-                    [preExtName]: extResp,
-                },
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("ext req", body);
+                    expect(body.extensions).toBeTruthy();
+                    expect(body.extensions[preExtName]).toEqual(extReq);
+                })
+                .respond(200, {
+                    pos: "a",
+                    ops: [],
+                    counts: [],
+                    extensions: {
+                        [preExtName]: extResp,
+                    },
+                });
 
             const p = listenUntil(slidingSync, "SlidingSync.Lifecycle", (state, resp, err) => {
                 if (state === SlidingSyncState.Complete) {
@@ -1354,17 +1515,20 @@ describe("SlidingSync", () => {
             onPreExtensionResponse = (resp) => {
                 responseCalled = true;
             };
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("ext req nothing", body);
-                expect(body.extensions).toBeTruthy();
-                expect(body.extensions[preExtName]).toBeUndefined();
-            }).respond(200, {
-                pos: "a",
-                ops: [],
-                counts: [],
-                extensions: {},
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("ext req nothing", body);
+                    expect(body.extensions).toBeTruthy();
+                    expect(body.extensions[preExtName]).toBeUndefined();
+                })
+                .respond(200, {
+                    pos: "a",
+                    ops: [],
+                    counts: [],
+                    extensions: {},
+                });
             // we need to resend as sliding sync will already have a buffered request with the old
             // extension values from the previous test.
             slidingSync.resend();
@@ -1389,20 +1553,23 @@ describe("SlidingSync", () => {
                 responseCalled = true;
                 callbackOrder.push("onPostExtensionResponse");
             };
-            httpBackend!.when("POST", syncUrl).check(function(req) {
-                const body = req.data;
-                logger.log("ext req after start", body);
-                expect(body.extensions).toBeTruthy();
-                expect(body.extensions[preExtName]).toBeUndefined(); // from the earlier test
-                expect(body.extensions[postExtName]).toEqual(extReq);
-            }).respond(200, {
-                pos: "c",
-                ops: [],
-                counts: [],
-                extensions: {
-                    [postExtName]: extResp,
-                },
-            });
+            httpBackend!
+                .when("POST", syncUrl)
+                .check(function (req) {
+                    const body = req.data;
+                    logger.log("ext req after start", body);
+                    expect(body.extensions).toBeTruthy();
+                    expect(body.extensions[preExtName]).toBeUndefined(); // from the earlier test
+                    expect(body.extensions[postExtName]).toEqual(extReq);
+                })
+                .respond(200, {
+                    pos: "c",
+                    ops: [],
+                    counts: [],
+                    extensions: {
+                        [postExtName]: extResp,
+                    },
+                });
             // we need to resend as sliding sync will already have a buffered request with the old
             // extension values from the previous test.
             slidingSync.resend();
@@ -1423,12 +1590,14 @@ describe("SlidingSync", () => {
         it("is not possible to register the same extension name twice", async () => {
             slidingSync = new SlidingSync(proxyBaseUrl, [], {}, client!, 1);
             slidingSync.registerExtension(extPre);
-            expect(() => { slidingSync.registerExtension(extPre); }).toThrow();
+            expect(() => {
+                slidingSync.registerExtension(extPre);
+            }).toThrow();
         });
     });
 });
 
-function timeout(delayMs: number, reason: string): { promise: Promise<never>, cancel: () => void } {
+function timeout(delayMs: number, reason: string): { promise: Promise<never>; cancel: () => void } {
     let timeoutId: NodeJS.Timeout;
     return {
         promise: new Promise((resolve, reject) => {
@@ -1461,20 +1630,23 @@ function listenUntil<T>(
 ): Promise<T> {
     const trace = new Error().stack?.split(`\n`)[2];
     const t = timeout(timeoutMs, "timed out waiting for event " + eventName + " " + trace);
-    return Promise.race([new Promise<T>((resolve, reject) => {
-        const wrapper = (...args: any[]) => {
-            try {
-                const data = callback(...args);
-                if (data) {
-                    emitter.off(eventName, wrapper);
+    return Promise.race([
+        new Promise<T>((resolve, reject) => {
+            const wrapper = (...args: any[]) => {
+                try {
+                    const data = callback(...args);
+                    if (data) {
+                        emitter.off(eventName, wrapper);
+                        t.cancel();
+                        resolve(data);
+                    }
+                } catch (err) {
+                    reject(err);
                     t.cancel();
-                    resolve(data);
                 }
-            } catch (err) {
-                reject(err);
-                t.cancel();
-            }
-        };
-        emitter.on(eventName, wrapper);
-    }), t.promise]);
+            };
+            emitter.on(eventName, wrapper);
+        }),
+        t.promise,
+    ]);
 }
diff --git a/spec/olm-loader.ts b/spec/olm-loader.ts
index 3ab07254df6..a139a48672b 100644
--- a/spec/olm-loader.ts
+++ b/spec/olm-loader.ts
@@ -15,13 +15,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from '../src/logger';
+import { logger } from "../src/logger";
 
 // try to load the olm library.
 try {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    global.Olm = require('@matrix-org/olm');
-    logger.log('loaded libolm');
+    global.Olm = require("@matrix-org/olm");
+    logger.log("loaded libolm");
 } catch (e) {
     logger.warn("unable to run crypto tests: libolm not available");
 }
diff --git a/spec/slowReporter.js b/spec/slowReporter.js
index 3a653ffda28..b50d9ea79de 100644
--- a/spec/slowReporter.js
+++ b/spec/slowReporter.js
@@ -38,18 +38,18 @@ class JestSlowTestReporter {
             if (isTestSuite) {
                 console.log(
                     `Top ${slowestTests.length} slowest test suites (${slowTestTime / 1000} seconds,` +
-              ` ${percentTime.toFixed(1)}% of total time):`,
+                        ` ${percentTime.toFixed(1)}% of total time):`,
                 );
             } else {
                 console.log(
                     `Top ${slowestTests.length} slowest tests (${slowTestTime / 1000} seconds,` +
-              ` ${percentTime.toFixed(1)}% of total time):`,
+                        ` ${percentTime.toFixed(1)}% of total time):`,
                 );
             }
 
             for (let i = 0; i < slowestTests.length; i++) {
                 const duration = slowestTests[i].duration;
-                const filePath = slowestTests[i].filePath.replace(rootPathRegex, '.');
+                const filePath = slowestTests[i].filePath.replace(rootPathRegex, ".");
 
                 if (isTestSuite) {
                     console.log(`  ${duration / 1000} seconds ${filePath}`);
diff --git a/spec/test-utils/beacon.ts b/spec/test-utils/beacon.ts
index 252c85c8150..9cfebf95675 100644
--- a/spec/test-utils/beacon.ts
+++ b/spec/test-utils/beacon.ts
@@ -17,10 +17,7 @@ limitations under the License.
 import { MatrixEvent } from "../../src";
 import { M_BEACON, M_BEACON_INFO } from "../../src/@types/beacon";
 import { LocationAssetType } from "../../src/@types/location";
-import {
-    makeBeaconContent,
-    makeBeaconInfoContent,
-} from "../../src/content-helpers";
+import { makeBeaconContent, makeBeaconInfoContent } from "../../src/content-helpers";
 
 type InfoContentProps = {
     timeout: number;
@@ -44,13 +41,7 @@ export const makeBeaconInfoEvent = (
     contentProps: Partial<InfoContentProps> = {},
     eventId?: string,
 ): MatrixEvent => {
-    const {
-        timeout,
-        isLive,
-        description,
-        assetType,
-        timestamp,
-    } = {
+    const { timeout, isLive, description, assetType, timestamp } = {
         ...DEFAULT_INFO_CONTENT_PROPS,
         ...contentProps,
     };
@@ -77,9 +68,9 @@ type ContentProps = {
     description?: string;
 };
 const DEFAULT_CONTENT_PROPS: ContentProps = {
-    uri: 'geo:-36.24484561954707,175.46884959563613;u=10',
+    uri: "geo:-36.24484561954707,175.46884959563613;u=10",
     timestamp: 123,
-    beaconInfoId: '$123',
+    beaconInfoId: "$123",
 };
 
 /**
@@ -87,10 +78,7 @@ const DEFAULT_CONTENT_PROPS: ContentProps = {
  * all required properties are mocked
  * override with contentProps
  */
-export const makeBeaconEvent = (
-    sender: string,
-    contentProps: Partial<ContentProps> = {},
-): MatrixEvent => {
+export const makeBeaconEvent = (sender: string, contentProps: Partial<ContentProps> = {}): MatrixEvent => {
     const { uri, timestamp, beaconInfoId, description } = {
         ...DEFAULT_CONTENT_PROPS,
         ...contentProps,
@@ -107,10 +95,13 @@ export const makeBeaconEvent = (
  * Create a mock geolocation position
  * defaults all required properties
  */
-export const makeGeolocationPosition = (
-    { timestamp, coords }:
-        { timestamp?: number, coords: Partial<GeolocationCoordinates> },
-): GeolocationPosition => ({
+export const makeGeolocationPosition = ({
+    timestamp,
+    coords,
+}: {
+    timestamp?: number;
+    coords: Partial<GeolocationCoordinates>;
+}): GeolocationPosition => ({
     timestamp: timestamp ?? 1647256791840,
     coords: {
         accuracy: 1,
diff --git a/spec/test-utils/client.ts b/spec/test-utils/client.ts
index 79af87022bb..800730fd528 100644
--- a/spec/test-utils/client.ts
+++ b/spec/test-utils/client.ts
@@ -58,11 +58,11 @@ export const getMockClientWithEventEmitter = (
     });
  * ```
  */
-export const mockClientMethodsUser = (userId = '@alice:domain') => ({
+export const mockClientMethodsUser = (userId = "@alice:domain") => ({
     getUserId: jest.fn().mockReturnValue(userId),
     getUser: jest.fn().mockReturnValue(new User(userId)),
     isGuest: jest.fn().mockReturnValue(false),
-    mxcUrlToHttp: jest.fn().mockReturnValue('mock-mxcUrlToHttp'),
+    mxcUrlToHttp: jest.fn().mockReturnValue("mock-mxcUrlToHttp"),
     credentials: { userId },
     getThreePids: jest.fn().mockResolvedValue({ threepids: [] }),
     getAccessToken: jest.fn(),
@@ -91,4 +91,3 @@ export const mockClientMethodsServer = (): Partial<Record<MethodLikeKeys<MatrixC
     getCapabilities: jest.fn().mockReturnValue({}),
     doesServerSupportUnstableFeature: jest.fn().mockResolvedValue(false),
 });
-
diff --git a/spec/test-utils/flushPromises.ts b/spec/test-utils/flushPromises.ts
index 8512410aa9f..35302506131 100644
--- a/spec/test-utils/flushPromises.ts
+++ b/spec/test-utils/flushPromises.ts
@@ -22,7 +22,7 @@ limitations under the License.
 // and avoids assuming anything about the app's behaviour.
 const realSetTimeout = setTimeout;
 export function flushPromises() {
-    return new Promise(r => {
+    return new Promise((r) => {
         realSetTimeout(r, 1);
     });
 }
diff --git a/spec/test-utils/test-utils.ts b/spec/test-utils/test-utils.ts
index 814f9b15e40..2588a6e1606 100644
--- a/spec/test-utils/test-utils.ts
+++ b/spec/test-utils/test-utils.ts
@@ -2,9 +2,9 @@
 import EventEmitter from "events";
 
 // load olm before the sdk if possible
-import '../olm-loader';
+import "../olm-loader";
 
-import { logger } from '../../src/logger';
+import { logger } from "../../src/logger";
 import { IContent, IEvent, IEventRelation, IUnsigned, MatrixEvent, MatrixEventEvent } from "../../src/models/event";
 import { ClientEvent, EventType, IPusher, MatrixClient, MsgType } from "../../src";
 import { SyncState } from "../../src/sync";
@@ -45,16 +45,17 @@ export function syncPromise(client: MatrixClient, count = 1): Promise<void> {
  * @param name - The name of the class
  * @returns An instantiated object with spied methods/properties.
  */
-export function mock<T>(constr: { new(...args: any[]): T }, name: string): T {
+export function mock<T>(constr: { new (...args: any[]): T }, name: string): T {
     // Based on http://eclipsesource.com/blogs/2014/03/27/mocks-in-jasmine-tests/
     const HelperConstr = new Function(); // jshint ignore:line
     HelperConstr.prototype = constr.prototype;
     // @ts-ignore
     const result = new HelperConstr();
-    result.toString = function() {
+    result.toString = function () {
         return "mock" + (name ? " of " + name : "");
     };
-    for (const key of Object.getOwnPropertyNames(constr.prototype)) { // eslint-disable-line guard-for-in
+    for (const key of Object.getOwnPropertyNames(constr.prototype)) {
+        // eslint-disable-line guard-for-in
         try {
             if (constr.prototype[key] instanceof Function) {
                 result[key] = jest.fn();
@@ -114,15 +115,17 @@ export function mkEvent(opts: IEventOpts & { event?: boolean }, client?: MatrixC
     };
     if (opts.skey !== undefined) {
         event.state_key = opts.skey;
-    } else if ([
-        EventType.RoomName,
-        EventType.RoomTopic,
-        EventType.RoomCreate,
-        EventType.RoomJoinRules,
-        EventType.RoomPowerLevels,
-        EventType.RoomTopic,
-        "com.example.state",
-    ].includes(opts.type)) {
+    } else if (
+        [
+            EventType.RoomName,
+            EventType.RoomTopic,
+            EventType.RoomCreate,
+            EventType.RoomJoinRules,
+            EventType.RoomPowerLevels,
+            EventType.RoomTopic,
+            "com.example.state",
+        ].includes(opts.type)
+    ) {
         event.state_key = "";
     }
 
@@ -228,8 +231,8 @@ export function mkMembership(opts: IMembershipOpts & { event?: boolean }): Parti
 }
 
 export function mkMembershipCustom<T>(
-    base: T & { membership: string, sender: string, content?: IContent },
-): T & { type: EventType, sender: string, state_key: string, content: IContent } & GeneratedMetadata {
+    base: T & { membership: string; sender: string; content?: IContent },
+): T & { type: EventType; sender: string; state_key: string; content: IContent } & GeneratedMetadata {
     const content = base.content || {};
     return mkEventCustom({
         ...base,
@@ -315,7 +318,7 @@ export function mkReplyMessage(
                 "rel_type": "m.in_reply_to",
                 "event_id": opts.replyToMessage.getId(),
                 "m.in_reply_to": {
-                    "event_id": opts.replyToMessage.getId()!,
+                    event_id: opts.replyToMessage.getId()!,
                 },
             },
         },
@@ -364,7 +367,8 @@ export class MockStorageApi implements Storage {
  * @returns promise which resolves (to `event`) when the event has been decrypted
  */
 export async function awaitDecryption(
-    event: MatrixEvent, { waitOnDecryptionFailure = false } = {},
+    event: MatrixEvent,
+    { waitOnDecryptionFailure = false } = {},
 ): Promise<MatrixEvent> {
     // An event is not always decrypted ahead of time
     // getClearContent is a good signal to know whether an event has been decrypted
@@ -387,7 +391,7 @@ export async function awaitDecryption(
     });
 }
 
-export const emitPromise = (e: EventEmitter, k: string): Promise<any> => new Promise(r => e.once(k, r));
+export const emitPromise = (e: EventEmitter, k: string): Promise<any> => new Promise((r) => e.once(k, r));
 
 export const mkPusher = (extra: Partial<IPusher> = {}): IPusher => ({
     app_display_name: "app",
diff --git a/spec/test-utils/thread.ts b/spec/test-utils/thread.ts
index 376b8d81121..6111aba40b5 100644
--- a/spec/test-utils/thread.ts
+++ b/spec/test-utils/thread.ts
@@ -21,18 +21,25 @@ import { Room } from "../../src/models/room";
 import { Thread } from "../../src/models/thread";
 import { mkMessage } from "./test-utils";
 
-export const makeThreadEvent = ({ rootEventId, replyToEventId, ...props }: any & {
-    rootEventId: string; replyToEventId: string; event?: boolean;
-}): MatrixEvent => mkMessage({
-    ...props,
-    relatesTo: {
-        event_id: rootEventId,
-        rel_type: "m.thread",
-        ['m.in_reply_to']: {
-            event_id: replyToEventId,
+export const makeThreadEvent = ({
+    rootEventId,
+    replyToEventId,
+    ...props
+}: any & {
+    rootEventId: string;
+    replyToEventId: string;
+    event?: boolean;
+}): MatrixEvent =>
+    mkMessage({
+        ...props,
+        relatesTo: {
+            event_id: rootEventId,
+            rel_type: "m.thread",
+            ["m.in_reply_to"]: {
+                event_id: replyToEventId,
+            },
         },
-    },
-});
+    });
 
 type MakeThreadEventsProps = {
     roomId: Room["roomId"];
@@ -50,12 +57,17 @@ type MakeThreadEventsProps = {
 };
 
 export const makeThreadEvents = ({
-    roomId, authorId, participantUserIds, length = 2, ts = 1, currentUserId,
-}: MakeThreadEventsProps): { rootEvent: MatrixEvent, events: MatrixEvent[] } => {
+    roomId,
+    authorId,
+    participantUserIds,
+    length = 2,
+    ts = 1,
+    currentUserId,
+}: MakeThreadEventsProps): { rootEvent: MatrixEvent; events: MatrixEvent[] } => {
     const rootEvent = mkMessage({
         user: authorId,
         room: roomId,
-        msg: 'root event message ' + Math.random(),
+        msg: "root event message " + Math.random(),
         ts,
         event: true,
     });
@@ -67,16 +79,18 @@ export const makeThreadEvents = ({
         const prevEvent = events[i - 1];
         const replyToEventId = prevEvent.getId();
         const user = participantUserIds[i % participantUserIds.length];
-        events.push(makeThreadEvent({
-            user,
-            room: roomId,
-            event: true,
-            msg: `reply ${i} by ${user}`,
-            rootEventId,
-            replyToEventId,
-            // replies are 1ms after each other
-            ts: ts + i,
-        }));
+        events.push(
+            makeThreadEvent({
+                user,
+                room: roomId,
+                event: true,
+                msg: `reply ${i} by ${user}`,
+                rootEventId,
+                replyToEventId,
+                // replies are 1ms after each other
+                ts: ts + i,
+            }),
+        );
     }
 
     rootEvent.setUnsigned({
@@ -108,7 +122,7 @@ export const mkThread = ({
     participantUserIds,
     length = 2,
     ts = 1,
-}: MakeThreadProps): { thread: Thread, rootEvent: MatrixEvent, events: MatrixEvent[] } => {
+}: MakeThreadProps): { thread: Thread; rootEvent: MatrixEvent; events: MatrixEvent[] } => {
     const { rootEvent, events } = makeThreadEvents({
         roomId: room.roomId,
         authorId,
@@ -120,9 +134,7 @@ export const mkThread = ({
     expect(rootEvent).toBeTruthy();
 
     for (const evt of events) {
-        room?.reEmitter.reEmit(evt, [
-            MatrixEventEvent.BeforeRedaction,
-        ]);
+        room?.reEmitter.reEmit(evt, [MatrixEventEvent.BeforeRedaction]);
     }
 
     const thread = room.createThread(rootEvent.getId() ?? "", rootEvent, events, true);
diff --git a/spec/test-utils/webrtc.ts b/spec/test-utils/webrtc.ts
index 84d1f4868f4..d8e350030f1 100644
--- a/spec/test-utils/webrtc.ts
+++ b/spec/test-utils/webrtc.ts
@@ -41,7 +41,7 @@ import { GroupCallEventHandlerMap } from "../../src/webrtc/groupCall";
 import { GroupCallEventHandlerEvent } from "../../src/webrtc/groupCallEventHandler";
 import { IScreensharingOpts, MediaHandler } from "../../src/webrtc/mediaHandler";
 
-export const DUMMY_SDP = (
+export const DUMMY_SDP =
     "v=0\r\n" +
     "o=- 5022425983810148698 2 IN IP4 127.0.0.1\r\n" +
     "s=-\r\nt=0 0\r\na=group:BUNDLE 0\r\n" +
@@ -78,8 +78,7 @@ export const DUMMY_SDP = (
     "a=rtpmap:112 telephone-event/32000\r\n" +
     "a=rtpmap:113 telephone-event/16000\r\n" +
     "a=rtpmap:126 telephone-event/8000\r\n" +
-    "a=ssrc:3619738545 cname:2RWtmqhXLdoF4sOi\r\n"
-);
+    "a=ssrc:3619738545 cname:2RWtmqhXLdoF4sOi\r\n";
 
 export const USERMEDIA_STREAM_ID = "mock_stream_from_media_handler";
 export const SCREENSHARE_STREAM_ID = "mock_screen_stream_from_media_handler";
@@ -100,13 +99,19 @@ class MockMediaStreamAudioSourceNode {
 }
 
 class MockAnalyser {
-    public getFloatFrequencyData() { return 0.0; }
+    public getFloatFrequencyData() {
+        return 0.0;
+    }
 }
 
 export class MockAudioContext {
     constructor() {}
-    public createAnalyser() { return new MockAnalyser(); }
-    public createMediaStreamSource() { return new MockMediaStreamAudioSourceNode(); }
+    public createAnalyser() {
+        return new MockAnalyser();
+    }
+    public createMediaStreamSource() {
+        return new MockMediaStreamAudioSourceNode();
+    }
     public close() {}
 }
 
@@ -132,7 +137,7 @@ export class MockRTCPeerConnection {
     }
 
     public static hasAnyPendingNegotiations(): boolean {
-        return this.instances.some(i => i.needsNegotiation);
+        return this.instances.some((i) => i.needsNegotiation);
     }
 
     public static resetInstances() {
@@ -142,11 +147,11 @@ export class MockRTCPeerConnection {
     constructor() {
         this.localDescription = {
             sdp: DUMMY_SDP,
-            type: 'offer',
-            toJSON: function() { },
+            type: "offer",
+            toJSON: function () {},
         };
 
-        this.readyToNegotiate = new Promise<void>(resolve => {
+        this.readyToNegotiate = new Promise<void>((resolve) => {
             this.onReadyToNegotiate = resolve;
         });
 
@@ -154,26 +159,28 @@ export class MockRTCPeerConnection {
     }
 
     public addEventListener(type: string, listener: () => void) {
-        if (type === 'negotiationneeded') {
+        if (type === "negotiationneeded") {
             this.negotiationNeededListener = listener;
-        } else if (type == 'icecandidate') {
+        } else if (type == "icecandidate") {
             this.iceCandidateListener = listener;
-        } else if (type === 'iceconnectionstatechange') {
+        } else if (type === "iceconnectionstatechange") {
             this.iceConnectionStateChangeListener = listener;
-        } else if (type == 'track') {
+        } else if (type == "track") {
             this.onTrackListener = listener;
         }
     }
-    public createDataChannel(label: string, opts: RTCDataChannelInit) { return { label, ...opts }; }
+    public createDataChannel(label: string, opts: RTCDataChannelInit) {
+        return { label, ...opts };
+    }
     public createOffer() {
         return Promise.resolve({
-            type: 'offer',
+            type: "offer",
             sdp: DUMMY_SDP,
         });
     }
     public createAnswer() {
         return Promise.resolve({
-            type: 'answer',
+            type: "answer",
             sdp: DUMMY_SDP,
         });
     }
@@ -183,8 +190,10 @@ export class MockRTCPeerConnection {
     public setLocalDescription() {
         return Promise.resolve();
     }
-    public close() { }
-    public getStats() { return []; }
+    public close() {}
+    public getStats() {
+        return [];
+    }
     public addTransceiver(track: MockMediaStreamTrack): MockRTCRtpTransceiver {
         this.needsNegotiation = true;
         if (this.onReadyToNegotiate) this.onReadyToNegotiate();
@@ -209,9 +218,11 @@ export class MockRTCPeerConnection {
         if (this.onReadyToNegotiate) this.onReadyToNegotiate();
     }
 
-    public getTransceivers(): MockRTCRtpTransceiver[] { return this.transceivers; }
+    public getTransceivers(): MockRTCRtpTransceiver[] {
+        return this.transceivers;
+    }
     public getSenders(): MockRTCRtpSender[] {
-        return this.transceivers.map(t => t.sender as unknown as MockRTCRtpSender);
+        return this.transceivers.map((t) => t.sender as unknown as MockRTCRtpSender);
     }
 
     public doNegotiation() {
@@ -223,13 +234,15 @@ export class MockRTCPeerConnection {
 }
 
 export class MockRTCRtpSender {
-    constructor(public track: MockMediaStreamTrack) { }
+    constructor(public track: MockMediaStreamTrack) {}
 
-    public replaceTrack(track: MockMediaStreamTrack) { this.track = track; }
+    public replaceTrack(track: MockMediaStreamTrack) {
+        this.track = track;
+    }
 }
 
 export class MockRTCRtpReceiver {
-    constructor(public track: MockMediaStreamTrack) { }
+    constructor(public track: MockMediaStreamTrack) {}
 }
 
 export class MockRTCRtpTransceiver {
@@ -246,7 +259,7 @@ export class MockRTCRtpTransceiver {
 }
 
 export class MockMediaStreamTrack {
-    constructor(public readonly id: string, public readonly kind: "audio" | "video", public enabled = true) { }
+    constructor(public readonly id: string, public readonly kind: "audio" | "video", public enabled = true) {}
 
     public stop = jest.fn<void, []>();
 
@@ -254,7 +267,9 @@ export class MockMediaStreamTrack {
     public isStopped = false;
     public settings?: MediaTrackSettings;
 
-    public getSettings(): MediaTrackSettings { return this.settings!; }
+    public getSettings(): MediaTrackSettings {
+        return this.settings!;
+    }
 
     // XXX: Using EventTarget in jest doesn't seem to work, so we write our own
     // implementation
@@ -273,16 +288,15 @@ export class MockMediaStreamTrack {
         });
     }
 
-    public typed(): MediaStreamTrack { return this as unknown as MediaStreamTrack; }
+    public typed(): MediaStreamTrack {
+        return this as unknown as MediaStreamTrack;
+    }
 }
 
 // XXX: Using EventTarget in jest doesn't seem to work, so we write our own
 // implementation
 export class MockMediaStream {
-    constructor(
-        public id: string,
-        private tracks: MockMediaStreamTrack[] = [],
-    ) {}
+    constructor(public id: string, private tracks: MockMediaStreamTrack[] = []) {}
 
     public listeners: [string, (...args: any[]) => any][] = [];
     public isStopped = false;
@@ -293,9 +307,15 @@ export class MockMediaStream {
             c();
         });
     }
-    public getTracks() { return this.tracks; }
-    public getAudioTracks() { return this.tracks.filter((track) => track.kind === "audio"); }
-    public getVideoTracks() { return this.tracks.filter((track) => track.kind === "video"); }
+    public getTracks() {
+        return this.tracks;
+    }
+    public getAudioTracks() {
+        return this.tracks.filter((track) => track.kind === "audio");
+    }
+    public getVideoTracks() {
+        return this.tracks.filter((track) => track.kind === "video");
+    }
     public addEventListener(eventType: string, callback: (...args: any[]) => any) {
         this.listeners.push([eventType, callback]);
     }
@@ -308,7 +328,9 @@ export class MockMediaStream {
         this.tracks.push(track);
         this.dispatchEvent("addtrack");
     }
-    public removeTrack(track: MockMediaStreamTrack) { this.tracks.splice(this.tracks.indexOf(track), 1); }
+    public removeTrack(track: MockMediaStreamTrack) {
+        this.tracks.splice(this.tracks.indexOf(track), 1);
+    }
 
     public clone(): MediaStream {
         return new MockMediaStream(this.id + ".clone", this.tracks).typed();
@@ -325,11 +347,11 @@ export class MockMediaStream {
 }
 
 export class MockMediaDeviceInfo {
-    constructor(
-        public kind: "audioinput" | "videoinput" | "audiooutput",
-    ) { }
+    constructor(public kind: "audioinput" | "videoinput" | "audiooutput") {}
 
-    public typed(): MediaDeviceInfo { return this as unknown as MediaDeviceInfo; }
+    public typed(): MediaDeviceInfo {
+        return this as unknown as MediaDeviceInfo;
+    }
 }
 
 export class MockMediaHandler {
@@ -359,28 +381,38 @@ export class MockMediaHandler {
     public stopScreensharingStream(stream: MockMediaStream) {
         stream.isStopped = true;
     }
-    public hasAudioDevice() { return true; }
-    public hasVideoDevice() { return true; }
+    public hasAudioDevice() {
+        return true;
+    }
+    public hasVideoDevice() {
+        return true;
+    }
     public stopAllStreams() {}
 
-    public typed(): MediaHandler { return this as unknown as MediaHandler; }
+    public typed(): MediaHandler {
+        return this as unknown as MediaHandler;
+    }
 }
 
 export class MockMediaDevices {
-    public enumerateDevices = jest.fn<Promise<MediaDeviceInfo[]>, []>().mockResolvedValue([
-        new MockMediaDeviceInfo("audioinput").typed(),
-        new MockMediaDeviceInfo("videoinput").typed(),
-    ]);
+    public enumerateDevices = jest
+        .fn<Promise<MediaDeviceInfo[]>, []>()
+        .mockResolvedValue([
+            new MockMediaDeviceInfo("audioinput").typed(),
+            new MockMediaDeviceInfo("videoinput").typed(),
+        ]);
 
-    public getUserMedia = jest.fn<Promise<MediaStream>, [MediaStreamConstraints]>().mockReturnValue(
-        Promise.resolve(new MockMediaStream("local_stream").typed()),
-    );
+    public getUserMedia = jest
+        .fn<Promise<MediaStream>, [MediaStreamConstraints]>()
+        .mockReturnValue(Promise.resolve(new MockMediaStream("local_stream").typed()));
 
-    public getDisplayMedia = jest.fn<Promise<MediaStream>, [MediaStreamConstraints]>().mockReturnValue(
-        Promise.resolve(new MockMediaStream("local_display_stream").typed()),
-    );
+    public getDisplayMedia = jest
+        .fn<Promise<MediaStream>, [MediaStreamConstraints]>()
+        .mockReturnValue(Promise.resolve(new MockMediaStream("local_display_stream").typed()));
 
-    public typed(): MediaDevices { return this as unknown as MediaDevices; }
+    public typed(): MediaDevices {
+        return this as unknown as MediaDevices;
+    }
 }
 
 type EmittedEvents = CallEventHandlerEvent | CallEvent | ClientEvent | RoomStateEvent | GroupCallEventHandlerEvent;
@@ -405,21 +437,33 @@ export class MockCallMatrixClient extends TypedEventEmitter<EmittedEvents, Emitt
         calls: new Map<string, MatrixCall>(),
     };
 
-    public sendStateEvent = jest.fn<Promise<ISendEventResponse>, [
-        roomId: string, eventType: EventType, content: any, statekey: string,
-    ]>();
-    public sendToDevice = jest.fn<Promise<{}>, [
-        eventType: string,
-        contentMap: { [userId: string]: { [deviceId: string]: Record<string, any> } },
-        txnId?: string,
-    ]>();
+    public sendStateEvent = jest.fn<
+        Promise<ISendEventResponse>,
+        [roomId: string, eventType: EventType, content: any, statekey: string]
+    >();
+    public sendToDevice = jest.fn<
+        Promise<{}>,
+        [
+            eventType: string,
+            contentMap: { [userId: string]: { [deviceId: string]: Record<string, any> } },
+            txnId?: string,
+        ]
+    >();
 
-    public getMediaHandler(): MediaHandler { return this.mediaHandler.typed(); }
+    public getMediaHandler(): MediaHandler {
+        return this.mediaHandler.typed();
+    }
 
-    public getUserId(): string { return this.userId; }
+    public getUserId(): string {
+        return this.userId;
+    }
 
-    public getDeviceId(): string { return this.deviceId; }
-    public getSessionId(): string { return this.sessionId; }
+    public getDeviceId(): string {
+        return this.deviceId;
+    }
+    public getSessionId(): string {
+        return this.sessionId;
+    }
 
     public getTurnServers = () => [];
     public isFallbackICEServerAllowed = () => false;
@@ -432,18 +476,17 @@ export class MockCallMatrixClient extends TypedEventEmitter<EmittedEvents, Emitt
     public getRooms = jest.fn<Room[], []>().mockReturnValue([]);
     public getRoom = jest.fn();
 
-    public supportsExperimentalThreads(): boolean { return true; }
+    public supportsExperimentalThreads(): boolean {
+        return true;
+    }
     public async decryptEventIfNeeded(): Promise<void> {}
 
-    public typed(): MatrixClient { return this as unknown as MatrixClient; }
+    public typed(): MatrixClient {
+        return this as unknown as MatrixClient;
+    }
 
     public emitRoomState(event: MatrixEvent, state: RoomState): void {
-        this.emit(
-            RoomStateEvent.Events,
-            event,
-            state,
-            null,
-        );
+        this.emit(RoomStateEvent.Events, event, state, null);
     }
 }
 
@@ -481,15 +524,13 @@ export class MockMatrixCall extends TypedEventEmitter<CallEvent, CallEventHandle
         return this.opponentDeviceId;
     }
 
-    public typed(): MatrixCall { return this as unknown as MatrixCall; }
+    public typed(): MatrixCall {
+        return this as unknown as MatrixCall;
+    }
 }
 
 export class MockCallFeed {
-    constructor(
-        public userId: string,
-        public deviceId: string | undefined,
-        public stream: MockMediaStream,
-    ) {}
+    constructor(public userId: string, public deviceId: string | undefined, public stream: MockMediaStream) {}
 
     public measureVolumeActivity(val: boolean) {}
     public dispose() {}
@@ -536,10 +577,14 @@ export function installWebRTCMocks() {
     };
 }
 
-export function makeMockGroupCallStateEvent(roomId: string, groupCallId: string, content: IContent = {
-    "m.type": GroupCallType.Video,
-    "m.intent": GroupCallIntent.Prompt,
-}): MatrixEvent {
+export function makeMockGroupCallStateEvent(
+    roomId: string,
+    groupCallId: string,
+    content: IContent = {
+        "m.type": GroupCallType.Video,
+        "m.intent": GroupCallIntent.Prompt,
+    },
+): MatrixEvent {
     return {
         getType: jest.fn().mockReturnValue(EventType.GroupCallPrefix),
         getRoomId: jest.fn().mockReturnValue(roomId),
diff --git a/spec/unit/ReEmitter.spec.ts b/spec/unit/ReEmitter.spec.ts
index 4ce28429d12..9c4ea19255b 100644
--- a/spec/unit/ReEmitter.spec.ts
+++ b/spec/unit/ReEmitter.spec.ts
@@ -27,16 +27,14 @@ class EventSource extends EventEmitter {
     }
 
     doAnError() {
-        this.emit('error');
+        this.emit("error");
     }
 }
 
-class EventTarget extends EventEmitter {
+class EventTarget extends EventEmitter {}
 
-}
-
-describe("ReEmitter", function() {
-    it("Re-Emits events with the same args", function() {
+describe("ReEmitter", function () {
+    it("Re-Emits events with the same args", function () {
         const src = new EventSource();
         const tgt = new EventTarget();
 
@@ -53,18 +51,18 @@ describe("ReEmitter", function() {
         expect(handler).toHaveBeenCalledWith("foo", "bar", src);
     });
 
-    it("Doesn't throw if no handler for 'error' event", function() {
+    it("Doesn't throw if no handler for 'error' event", function () {
         const src = new EventSource();
         const tgt = new EventTarget();
 
         const reEmitter = new ReEmitter(tgt);
-        reEmitter.reEmit(src, ['error']);
+        reEmitter.reEmit(src, ["error"]);
 
         // without the workaround in ReEmitter, this would throw
         src.doAnError();
 
         const handler = jest.fn();
-        tgt.on('error', handler);
+        tgt.on("error", handler);
 
         src.doAnError();
 
diff --git a/spec/unit/autodiscovery.spec.ts b/spec/unit/autodiscovery.spec.ts
index fae5089c50b..0b6f8036d61 100644
--- a/spec/unit/autodiscovery.spec.ts
+++ b/spec/unit/autodiscovery.spec.ts
@@ -19,44 +19,56 @@ import MockHttpBackend from "matrix-mock-request";
 
 import { AutoDiscovery } from "../../src/autodiscovery";
 
-describe("AutoDiscovery", function() {
+describe("AutoDiscovery", function () {
     const getHttpBackend = (): MockHttpBackend => {
         const httpBackend = new MockHttpBackend();
         AutoDiscovery.setFetchFn(httpBackend.fetchFn as typeof global.fetch);
         return httpBackend;
     };
 
-    it("should throw an error when no domain is specified", function() {
+    it("should throw an error when no domain is specified", function () {
         getHttpBackend();
         return Promise.all([
             // @ts-ignore testing no args
-            AutoDiscovery.findClientConfig(/* no args */).then(() => {
-                throw new Error("Expected a failure, not success with no args");
-            }, () => {
-                return true;
-            }),
+            AutoDiscovery.findClientConfig(/* no args */).then(
+                () => {
+                    throw new Error("Expected a failure, not success with no args");
+                },
+                () => {
+                    return true;
+                },
+            ),
 
-            AutoDiscovery.findClientConfig("").then(() => {
-                throw new Error("Expected a failure, not success with an empty string");
-            }, () => {
-                return true;
-            }),
+            AutoDiscovery.findClientConfig("").then(
+                () => {
+                    throw new Error("Expected a failure, not success with an empty string");
+                },
+                () => {
+                    return true;
+                },
+            ),
 
-            AutoDiscovery.findClientConfig(null as any).then(() => {
-                throw new Error("Expected a failure, not success with null");
-            }, () => {
-                return true;
-            }),
+            AutoDiscovery.findClientConfig(null as any).then(
+                () => {
+                    throw new Error("Expected a failure, not success with null");
+                },
+                () => {
+                    return true;
+                },
+            ),
 
-            AutoDiscovery.findClientConfig(true as any).then(() => {
-                throw new Error("Expected a failure, not success with a non-string");
-            }, () => {
-                return true;
-            }),
+            AutoDiscovery.findClientConfig(true as any).then(
+                () => {
+                    throw new Error("Expected a failure, not success with a non-string");
+                },
+                () => {
+                    return true;
+                },
+            ),
         ]);
     });
 
-    it("should return PROMPT when .well-known 404s", function() {
+    it("should return PROMPT when .well-known 404s", function () {
         const httpBackend = getHttpBackend();
         httpBackend.when("GET", "/.well-known/matrix/client").respond(404, {});
         return Promise.all([
@@ -80,7 +92,7 @@ describe("AutoDiscovery", function() {
         ]);
     });
 
-    it("should return FAIL_PROMPT when .well-known returns a 500 error", function() {
+    it("should return FAIL_PROMPT when .well-known returns a 500 error", function () {
         const httpBackend = getHttpBackend();
         httpBackend.when("GET", "/.well-known/matrix/client").respond(500, {});
         return Promise.all([
@@ -104,7 +116,7 @@ describe("AutoDiscovery", function() {
         ]);
     });
 
-    it("should return FAIL_PROMPT when .well-known returns a 400 error", function() {
+    it("should return FAIL_PROMPT when .well-known returns a 400 error", function () {
         const httpBackend = getHttpBackend();
         httpBackend.when("GET", "/.well-known/matrix/client").respond(400, {});
         return Promise.all([
@@ -128,7 +140,7 @@ describe("AutoDiscovery", function() {
         ]);
     });
 
-    it("should return FAIL_PROMPT when .well-known returns an empty body", function() {
+    it("should return FAIL_PROMPT when .well-known returns an empty body", function () {
         const httpBackend = getHttpBackend();
         httpBackend.when("GET", "/.well-known/matrix/client").respond(200, "");
         return Promise.all([
@@ -169,9 +181,7 @@ describe("AutoDiscovery", function() {
         };
         return Promise.all([
             httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then(
-                expect(expected).toEqual,
-            ),
+            AutoDiscovery.findClientConfig("example.org").then(expect(expected).toEqual),
         ]);
     });
 
@@ -257,106 +267,117 @@ describe("AutoDiscovery", function() {
         ]);
     });
 
-    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
-        "m.homeserver (verification failure: 404)", function() {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").respond(404, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "https://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
-        "m.homeserver (verification failure: 500)", function() {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").respond(500, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "https://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return FAIL_ERROR when .well-known has an invalid base_url for " +
-        "m.homeserver (verification failure: 200 but wrong content)", function() {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
-            not_matrix_versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                base_url: "https://example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "FAIL_ERROR",
-                        error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
-                        base_url: "https://example.org",
-                    },
-                    "m.identity_server": {
-                        state: "PROMPT",
-                        error: null,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS when .well-known has a verifiably accurate base_url for " +
-        "m.homeserver", function() {
+    it(
+        "should return FAIL_ERROR when .well-known has an invalid base_url for " +
+            "m.homeserver (verification failure: 404)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend.when("GET", "/_matrix/client/versions").respond(404, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    base_url: "https://example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "FAIL_ERROR",
+                            error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
+                            base_url: "https://example.org",
+                        },
+                        "m.identity_server": {
+                            state: "PROMPT",
+                            error: null,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return FAIL_ERROR when .well-known has an invalid base_url for " +
+            "m.homeserver (verification failure: 500)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend.when("GET", "/_matrix/client/versions").respond(500, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    base_url: "https://example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "FAIL_ERROR",
+                            error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
+                            base_url: "https://example.org",
+                        },
+                        "m.identity_server": {
+                            state: "PROMPT",
+                            error: null,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return FAIL_ERROR when .well-known has an invalid base_url for " +
+            "m.homeserver (verification failure: 200 but wrong content)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
+                not_matrix_versions: ["r0.0.1"],
+            });
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    base_url: "https://example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "FAIL_ERROR",
+                            error: AutoDiscovery.ERROR_INVALID_HOMESERVER,
+                            base_url: "https://example.org",
+                        },
+                        "m.identity_server": {
+                            state: "PROMPT",
+                            error: null,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it("should return SUCCESS when .well-known has a verifiably accurate base_url for " + "m.homeserver", function () {
         const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path).toEqual("https://example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
         httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
             "m.homeserver": {
                 base_url: "https://example.org",
@@ -383,14 +404,16 @@ describe("AutoDiscovery", function() {
         ]);
     });
 
-    it("should return SUCCESS with the right homeserver URL", function() {
+    it("should return SUCCESS with the right homeserver URL", function () {
         const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
         httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
             "m.homeserver": {
                 // Note: we also expect this test to trim the trailing slash
@@ -418,185 +441,206 @@ describe("AutoDiscovery", function() {
         ]);
     });
 
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (missing base_url)", function() {
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " + "is wrong (missing base_url)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    not_base_url: "https://identity.example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes.
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " + "is wrong (empty base_url)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    base_url: "",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes.
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
+                            base_url: null,
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
+            "is wrong (validation error: 404)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/_matrix/identity/api/v1").respond(404, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    base_url: "https://identity.example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes.
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
+                            base_url: "https://identity.example.org",
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it(
+        "should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
+            "is wrong (validation error: 500)",
+        function () {
+            const httpBackend = getHttpBackend();
+            httpBackend
+                .when("GET", "/_matrix/client/versions")
+                .check((req) => {
+                    expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+                })
+                .respond(200, {
+                    versions: ["r0.0.1"],
+                });
+            httpBackend.when("GET", "/_matrix/identity/api/v1").respond(500, {});
+            httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
+                "m.homeserver": {
+                    // Note: we also expect this test to trim the trailing slash
+                    base_url: "https://chat.example.org/",
+                },
+                "m.identity_server": {
+                    base_url: "https://identity.example.org",
+                },
+            });
+            return Promise.all([
+                httpBackend.flushAllExpected(),
+                AutoDiscovery.findClientConfig("example.org").then((conf) => {
+                    const expected = {
+                        "m.homeserver": {
+                            state: "SUCCESS",
+                            error: null,
+
+                            // We still expect the base_url to be here for debugging purposes
+                            base_url: "https://chat.example.org",
+                        },
+                        "m.identity_server": {
+                            state: "FAIL_PROMPT",
+                            error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
+                            base_url: "https://identity.example.org",
+                        },
+                    };
+
+                    expect(conf).toEqual(expected);
+                }),
+            ]);
+        },
+    );
+
+    it("should return SUCCESS when the identity server configuration is " + "verifiably accurate", function () {
         const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                not_base_url: "https://identity.example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes.
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (empty base_url)", function() {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes.
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IS_BASE_URL,
-                        base_url: null,
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (validation error: 404)", function() {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").respond(404, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "https://identity.example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes.
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-                        base_url: "https://identity.example.org",
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS / FAIL_PROMPT when the identity server configuration " +
-        "is wrong (validation error: 500)", function() {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").respond(500, {});
-        httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
-            "m.homeserver": {
-                // Note: we also expect this test to trim the trailing slash
-                base_url: "https://chat.example.org/",
-            },
-            "m.identity_server": {
-                base_url: "https://identity.example.org",
-            },
-        });
-        return Promise.all([
-            httpBackend.flushAllExpected(),
-            AutoDiscovery.findClientConfig("example.org").then((conf) => {
-                const expected = {
-                    "m.homeserver": {
-                        state: "SUCCESS",
-                        error: null,
-
-                        // We still expect the base_url to be here for debugging purposes
-                        base_url: "https://chat.example.org",
-                    },
-                    "m.identity_server": {
-                        state: "FAIL_PROMPT",
-                        error: AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER,
-                        base_url: "https://identity.example.org",
-                    },
-                };
-
-                expect(conf).toEqual(expected);
-            }),
-        ]);
-    });
-
-    it("should return SUCCESS when the identity server configuration is " +
-        "verifiably accurate", function() {
-        const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").check((req) => {
-            expect(req.path)
-                .toEqual("https://identity.example.org/_matrix/identity/api/v1");
-        }).respond(200, {});
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
+        httpBackend
+            .when("GET", "/_matrix/identity/api/v1")
+            .check((req) => {
+                expect(req.path).toEqual("https://identity.example.org/_matrix/identity/api/v1");
+            })
+            .respond(200, {});
         httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
             "m.homeserver": {
                 // Note: we also expect this test to trim the trailing slash
@@ -627,19 +671,22 @@ describe("AutoDiscovery", function() {
         ]);
     });
 
-    it("should return SUCCESS and preserve non-standard keys from the " +
-        ".well-known response", function() {
+    it("should return SUCCESS and preserve non-standard keys from the " + ".well-known response", function () {
         const httpBackend = getHttpBackend();
-        httpBackend.when("GET", "/_matrix/client/versions").check((req) => {
-            expect(req.path)
-                .toEqual("https://chat.example.org/_matrix/client/versions");
-        }).respond(200, {
-            versions: ["r0.0.1"],
-        });
-        httpBackend.when("GET", "/_matrix/identity/api/v1").check((req) => {
-            expect(req.path)
-                .toEqual("https://identity.example.org/_matrix/identity/api/v1");
-        }).respond(200, {});
+        httpBackend
+            .when("GET", "/_matrix/client/versions")
+            .check((req) => {
+                expect(req.path).toEqual("https://chat.example.org/_matrix/client/versions");
+            })
+            .respond(200, {
+                versions: ["r0.0.1"],
+            });
+        httpBackend
+            .when("GET", "/_matrix/identity/api/v1")
+            .check((req) => {
+                expect(req.path).toEqual("https://identity.example.org/_matrix/identity/api/v1");
+            })
+            .respond(200, {});
         httpBackend.when("GET", "/.well-known/matrix/client").respond(200, {
             "m.homeserver": {
                 // Note: we also expect this test to trim the trailing slash
diff --git a/spec/unit/content-helpers.spec.ts b/spec/unit/content-helpers.spec.ts
index 35971600715..9a5ddb143c0 100644
--- a/spec/unit/content-helpers.spec.ts
+++ b/spec/unit/content-helpers.spec.ts
@@ -26,23 +26,18 @@ import {
     parseTopicContent,
 } from "../../src/content-helpers";
 
-describe('Beacon content helpers', () => {
-    describe('makeBeaconInfoContent()', () => {
+describe("Beacon content helpers", () => {
+    describe("makeBeaconInfoContent()", () => {
         const mockDateNow = 123456789;
         beforeEach(() => {
-            jest.spyOn(global.Date, 'now').mockReturnValue(mockDateNow);
+            jest.spyOn(global.Date, "now").mockReturnValue(mockDateNow);
         });
         afterAll(() => {
-            jest.spyOn(global.Date, 'now').mockRestore();
+            jest.spyOn(global.Date, "now").mockRestore();
         });
-        it('create fully defined event content', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-            )).toEqual({
-                description: 'nice beacon_info',
+        it("create fully defined event content", () => {
+            expect(makeBeaconInfoContent(1234, true, "nice beacon_info", LocationAssetType.Pin)).toEqual({
+                description: "nice beacon_info",
                 timeout: 1234,
                 live: true,
                 [M_TIMESTAMP.name]: mockDateNow,
@@ -52,78 +47,72 @@ describe('Beacon content helpers', () => {
             });
         });
 
-        it('defaults timestamp to current time', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-            )).toEqual(expect.objectContaining({
-                [M_TIMESTAMP.name]: mockDateNow,
-            }));
+        it("defaults timestamp to current time", () => {
+            expect(makeBeaconInfoContent(1234, true, "nice beacon_info", LocationAssetType.Pin)).toEqual(
+                expect.objectContaining({
+                    [M_TIMESTAMP.name]: mockDateNow,
+                }),
+            );
         });
 
-        it('uses timestamp when provided', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                LocationAssetType.Pin,
-                99999,
-            )).toEqual(expect.objectContaining({
-                [M_TIMESTAMP.name]: 99999,
-            }));
+        it("uses timestamp when provided", () => {
+            expect(makeBeaconInfoContent(1234, true, "nice beacon_info", LocationAssetType.Pin, 99999)).toEqual(
+                expect.objectContaining({
+                    [M_TIMESTAMP.name]: 99999,
+                }),
+            );
         });
 
-        it('defaults asset type to self when not set', () => {
-            expect(makeBeaconInfoContent(
-                1234,
-                true,
-                'nice beacon_info',
-                // no assetType passed
-            )).toEqual(expect.objectContaining({
-                [M_ASSET.name]: {
-                    type: LocationAssetType.Self,
-                },
-            }));
+        it("defaults asset type to self when not set", () => {
+            expect(
+                makeBeaconInfoContent(
+                    1234,
+                    true,
+                    "nice beacon_info",
+                    // no assetType passed
+                ),
+            ).toEqual(
+                expect.objectContaining({
+                    [M_ASSET.name]: {
+                        type: LocationAssetType.Self,
+                    },
+                }),
+            );
         });
     });
 
-    describe('makeBeaconContent()', () => {
-        it('creates event content without description', () => {
-            expect(makeBeaconContent(
-                'geo:foo',
-                123,
-                '$1234',
-                // no description
-            )).toEqual({
+    describe("makeBeaconContent()", () => {
+        it("creates event content without description", () => {
+            expect(
+                makeBeaconContent(
+                    "geo:foo",
+                    123,
+                    "$1234",
+                    // no description
+                ),
+            ).toEqual({
                 [M_LOCATION.name]: {
                     description: undefined,
-                    uri: 'geo:foo',
+                    uri: "geo:foo",
                 },
                 [M_TIMESTAMP.name]: 123,
                 "m.relates_to": {
                     rel_type: REFERENCE_RELATION.name,
-                    event_id: '$1234',
+                    event_id: "$1234",
                 },
             });
         });
 
-        it('creates event content with description', () => {
-            expect(makeBeaconContent(
-                'geo:foo',
-                123,
-                '$1234',
-                'test description',
-            )).toEqual({
+        it("creates event content with description", () => {
+            expect(makeBeaconContent("geo:foo", 123, "$1234", "test description")).toEqual({
                 [M_LOCATION.name]: {
-                    description: 'test description',
-                    uri: 'geo:foo',
+                    description: "test description",
+                    uri: "geo:foo",
                 },
                 [M_TIMESTAMP.name]: 123,
                 "m.relates_to": {
                     rel_type: REFERENCE_RELATION.name,
-                    event_id: '$1234',
+                    event_id: "$1234",
                 },
             });
         });
@@ -190,64 +179,81 @@ describe('Beacon content helpers', () => {
     });
 });
 
-describe('Topic content helpers', () => {
-    describe('makeTopicContent()', () => {
-        it('creates fully defined event content without html', () => {
+describe("Topic content helpers", () => {
+    describe("makeTopicContent()", () => {
+        it("creates fully defined event content without html", () => {
             expect(makeTopicContent("pizza")).toEqual({
                 topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }],
+                [M_TOPIC.name]: [
+                    {
+                        body: "pizza",
+                        mimetype: "text/plain",
+                    },
+                ],
             });
         });
 
-        it('creates fully defined event content with html', () => {
+        it("creates fully defined event content with html", () => {
             expect(makeTopicContent("pizza", "<b>pizza</b>")).toEqual({
                 topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }, {
-                    body: "<b>pizza</b>",
-                    mimetype: "text/html",
-                }],
+                [M_TOPIC.name]: [
+                    {
+                        body: "pizza",
+                        mimetype: "text/plain",
+                    },
+                    {
+                        body: "<b>pizza</b>",
+                        mimetype: "text/html",
+                    },
+                ],
             });
         });
     });
 
-    describe('parseTopicContent()', () => {
-        it('parses event content with plain text topic without mimetype', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                }],
-            })).toEqual({
+    describe("parseTopicContent()", () => {
+        it("parses event content with plain text topic without mimetype", () => {
+            expect(
+                parseTopicContent({
+                    topic: "pizza",
+                    [M_TOPIC.name]: [
+                        {
+                            body: "pizza",
+                        },
+                    ],
+                }),
+            ).toEqual({
                 text: "pizza",
             });
         });
 
-        it('parses event content with plain text topic', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "pizza",
-                    mimetype: "text/plain",
-                }],
-            })).toEqual({
+        it("parses event content with plain text topic", () => {
+            expect(
+                parseTopicContent({
+                    topic: "pizza",
+                    [M_TOPIC.name]: [
+                        {
+                            body: "pizza",
+                            mimetype: "text/plain",
+                        },
+                    ],
+                }),
+            ).toEqual({
                 text: "pizza",
             });
         });
 
-        it('parses event content with html topic', () => {
-            expect(parseTopicContent({
-                topic: "pizza",
-                [M_TOPIC.name]: [{
-                    body: "<b>pizza</b>",
-                    mimetype: "text/html",
-                }],
-            })).toEqual({
+        it("parses event content with html topic", () => {
+            expect(
+                parseTopicContent({
+                    topic: "pizza",
+                    [M_TOPIC.name]: [
+                        {
+                            body: "<b>pizza</b>",
+                            mimetype: "text/html",
+                        },
+                    ],
+                }),
+            ).toEqual({
                 text: "pizza",
                 html: "<b>pizza</b>",
             });
diff --git a/spec/unit/content-repo.spec.ts b/spec/unit/content-repo.spec.ts
index 27e7fbc9966..2cbd361239e 100644
--- a/spec/unit/content-repo.spec.ts
+++ b/spec/unit/content-repo.spec.ts
@@ -16,60 +16,50 @@ limitations under the License.
 
 import { getHttpUriForMxc } from "../../src/content-repo";
 
-describe("ContentRepo", function() {
+describe("ContentRepo", function () {
     const baseUrl = "https://my.home.server";
 
-    describe("getHttpUriForMxc", function() {
-        it("should do nothing to HTTP URLs when allowing direct links", function() {
+    describe("getHttpUriForMxc", function () {
+        it("should do nothing to HTTP URLs when allowing direct links", function () {
             const httpUrl = "http://example.com/image.jpeg";
-            expect(
-                getHttpUriForMxc(
-                    baseUrl, httpUrl, undefined, undefined, undefined, true,
-                ),
-            ).toEqual(httpUrl);
+            expect(getHttpUriForMxc(baseUrl, httpUrl, undefined, undefined, undefined, true)).toEqual(httpUrl);
         });
 
-        it("should return the empty string HTTP URLs by default", function() {
+        it("should return the empty string HTTP URLs by default", function () {
             const httpUrl = "http://example.com/image.jpeg";
             expect(getHttpUriForMxc(baseUrl, httpUrl)).toEqual("");
         });
 
-        it("should return a download URL if no width/height/resize are specified",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid";
-                expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
-                    baseUrl + "/_matrix/media/r0/download/server.name/resourceid",
-                );
-            });
+        it("should return a download URL if no width/height/resize are specified", function () {
+            const mxcUri = "mxc://server.name/resourceid";
+            expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
+                baseUrl + "/_matrix/media/r0/download/server.name/resourceid",
+            );
+        });
 
-        it("should return the empty string for null input", function() {
-            expect(getHttpUriForMxc(null as any, '')).toEqual("");
+        it("should return the empty string for null input", function () {
+            expect(getHttpUriForMxc(null as any, "")).toEqual("");
         });
 
-        it("should return a thumbnail URL if a width/height/resize is specified",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid";
-                expect(getHttpUriForMxc(baseUrl, mxcUri, 32, 64, "crop")).toEqual(
-                    baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" +
-                "?width=32&height=64&method=crop",
-                );
-            });
+        it("should return a thumbnail URL if a width/height/resize is specified", function () {
+            const mxcUri = "mxc://server.name/resourceid";
+            expect(getHttpUriForMxc(baseUrl, mxcUri, 32, 64, "crop")).toEqual(
+                baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" + "?width=32&height=64&method=crop",
+            );
+        });
 
-        it("should put fragments from mxc:// URIs after any query parameters",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid#automade";
-                expect(getHttpUriForMxc(baseUrl, mxcUri, 32)).toEqual(
-                    baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" +
-                "?width=32#automade",
-                );
-            });
+        it("should put fragments from mxc:// URIs after any query parameters", function () {
+            const mxcUri = "mxc://server.name/resourceid#automade";
+            expect(getHttpUriForMxc(baseUrl, mxcUri, 32)).toEqual(
+                baseUrl + "/_matrix/media/r0/thumbnail/server.name/resourceid" + "?width=32#automade",
+            );
+        });
 
-        it("should put fragments from mxc:// URIs at the end of the HTTP URI",
-            function() {
-                const mxcUri = "mxc://server.name/resourceid#automade";
-                expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
-                    baseUrl + "/_matrix/media/r0/download/server.name/resourceid#automade",
-                );
-            });
+        it("should put fragments from mxc:// URIs at the end of the HTTP URI", function () {
+            const mxcUri = "mxc://server.name/resourceid#automade";
+            expect(getHttpUriForMxc(baseUrl, mxcUri)).toEqual(
+                baseUrl + "/_matrix/media/r0/download/server.name/resourceid#automade",
+            );
+        });
     });
 });
diff --git a/spec/unit/crypto.spec.ts b/spec/unit/crypto.spec.ts
index 51d57159d52..3b7689ca0ce 100644
--- a/spec/unit/crypto.spec.ts
+++ b/spec/unit/crypto.spec.ts
@@ -1,4 +1,4 @@
-import '../olm-loader';
+import "../olm-loader";
 // eslint-disable-next-line no-restricted-imports
 import { EventEmitter } from "events";
 
@@ -14,11 +14,11 @@ import * as olmlib from "../../src/crypto/olmlib";
 import { sleep } from "../../src/utils";
 import { CRYPTO_ENABLED } from "../../src/client";
 import { DeviceInfo } from "../../src/crypto/deviceinfo";
-import { logger } from '../../src/logger';
+import { logger } from "../../src/logger";
 import { MemoryStore } from "../../src";
-import { RoomKeyRequestState } from '../../src/crypto/OutgoingRoomKeyRequestManager';
-import { RoomMember } from '../../src/models/room-member';
-import { IStore } from '../../src/store';
+import { RoomKeyRequestState } from "../../src/crypto/OutgoingRoomKeyRequestManager";
+import { RoomMember } from "../../src/models/room-member";
+import { IStore } from "../../src/store";
 import { IRoomEncryption, RoomList } from "../../src/crypto/RoomList";
 
 const Olm = global.Olm;
@@ -75,10 +75,10 @@ function roomKeyEventForEvent(client: MatrixClient, event: MatrixEvent): MatrixE
         type: "m.room_key",
         sender: client.getUserId()!,
         content: {
-            "algorithm": olmlib.MEGOLM_ALGORITHM,
-            "room_id": roomId,
-            "session_id": eventContent.session_id,
-            "session_key": key.key,
+            algorithm: olmlib.MEGOLM_ALGORITHM,
+            room_id: roomId,
+            session_id: eventContent.session_id,
+            session_key: key.key,
         },
     });
     // make onRoomKeyEvent think this was an encrypted event
@@ -93,12 +93,12 @@ function roomKeyEventForEvent(client: MatrixClient, event: MatrixEvent): MatrixE
     return ksEvent;
 }
 
-describe("Crypto", function() {
+describe("Crypto", function () {
     if (!CRYPTO_ENABLED) {
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
@@ -106,34 +106,35 @@ describe("Crypto", function() {
         jest.useRealTimers();
     });
 
-    it("Crypto exposes the correct olm library version", function() {
+    it("Crypto exposes the correct olm library version", function () {
         expect(Crypto.getOlmVersion()[0]).toEqual(3);
     });
 
-    describe("encrypted events", function() {
-        it("provides encryption information", async function() {
-            const client = (new TestClient(
-                "@alice:example.com", "deviceid",
-            )).client;
+    describe("encrypted events", function () {
+        it("provides encryption information", async function () {
+            const client = new TestClient("@alice:example.com", "deviceid").client;
             await client.initCrypto();
 
             // unencrypted event
             const event = {
                 getId: () => "$event_id",
                 getSenderKey: () => null,
-                getWireContent: () => {return {};},
+                getWireContent: () => {
+                    return {};
+                },
             } as unknown as MatrixEvent;
 
             let encryptionInfo = client.getEventEncryptionInfo(event);
             expect(encryptionInfo.encrypted).toBeFalsy();
 
             // unknown sender (e.g. deleted device), forwarded megolm key (untrusted)
-            event.getSenderKey = () => 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI';
-            event.getWireContent = () => {return { algorithm: olmlib.MEGOLM_ALGORITHM };};
+            event.getSenderKey = () => "YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI";
+            event.getWireContent = () => {
+                return { algorithm: olmlib.MEGOLM_ALGORITHM };
+            };
             event.getForwardingCurve25519KeyChain = () => ["not empty"];
             event.isKeySourceUntrusted = () => true;
-            event.getClaimedEd25519Key =
-                () => 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+            event.getClaimedEd25519Key = () => "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
 
             encryptionInfo = client.getEventEncryptionInfo(event);
             expect(encryptionInfo.encrypted).toBeTruthy();
@@ -144,10 +145,8 @@ describe("Crypto", function() {
             event.getForwardingCurve25519KeyChain = () => [];
             event.isKeySourceUntrusted = () => true;
             const device = new DeviceInfo("FLIBBLE");
-            device.keys["curve25519:FLIBBLE"] =
-                'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI';
-            device.keys["ed25519:FLIBBLE"] =
-                'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+            device.keys["curve25519:FLIBBLE"] = "YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI";
+            device.keys["ed25519:FLIBBLE"] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
             client.crypto!.deviceList.getDeviceByIdentityKey = () => device;
 
             encryptionInfo = client.getEventEncryptionInfo(event);
@@ -158,8 +157,7 @@ describe("Crypto", function() {
 
             // known sender, trusted megolm key, but bad ed25519key
             event.isKeySourceUntrusted = () => false;
-            device.keys["ed25519:FLIBBLE"] =
-                'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB';
+            device.keys["ed25519:FLIBBLE"] = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
 
             encryptionInfo = client.getEventEncryptionInfo(event);
             expect(encryptionInfo.encrypted).toBeTruthy();
@@ -171,17 +169,17 @@ describe("Crypto", function() {
         });
     });
 
-    describe('Session management', function() {
+    describe("Session management", function () {
         const otkResponse: IClaimOTKsResult = {
             failures: {},
             one_time_keys: {
-                '@alice:home.server': {
+                "@alice:home.server": {
                     aliceDevice: {
-                        'signed_curve25519:FLIBBLE': {
-                            key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
+                        "signed_curve25519:FLIBBLE": {
+                            key: "YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI",
                             signatures: {
-                                '@alice:home.server': {
-                                    'ed25519:aliceDevice': 'totally a valid signature',
+                                "@alice:home.server": {
+                                    "ed25519:aliceDevice": "totally a valid signature",
                                 },
                             },
                         },
@@ -196,26 +194,29 @@ describe("Crypto", function() {
 
         let fakeEmitter: EventEmitter;
 
-        beforeEach(async function() {
+        beforeEach(async function () {
             const mockStorage = new MockStorageApi() as unknown as Storage;
             const clientStore = new MemoryStore({ localStorage: mockStorage }) as unknown as IStore;
             const cryptoStore = new MemoryCryptoStore();
 
-            cryptoStore.storeEndToEndDeviceData({
-                devices: {
-                    '@bob:home.server': {
-                        'BOBDEVICE': {
-                            algorithms: [],
-                            verified: 1,
-                            known: false,
-                            keys: {
-                                'curve25519:BOBDEVICE': 'this is a key',
+            cryptoStore.storeEndToEndDeviceData(
+                {
+                    devices: {
+                        "@bob:home.server": {
+                            BOBDEVICE: {
+                                algorithms: [],
+                                verified: 1,
+                                known: false,
+                                keys: {
+                                    "curve25519:BOBDEVICE": "this is a key",
+                                },
                             },
                         },
                     },
+                    trackingStatus: {},
                 },
-                trackingStatus: {},
-            }, {});
+                {},
+            );
 
             mockBaseApis = {
                 sendToDevice: jest.fn(),
@@ -239,76 +240,72 @@ describe("Crypto", function() {
             await crypto.init();
         });
 
-        afterEach(async function() {
+        afterEach(async function () {
             await crypto.stop();
         });
 
-        it("restarts wedged Olm sessions", async function() {
+        it("restarts wedged Olm sessions", async function () {
             const prom = new Promise<void>((resolve) => {
-                mockBaseApis.claimOneTimeKeys = function() {
+                mockBaseApis.claimOneTimeKeys = function () {
                     resolve();
                     return Promise.resolve(otkResponse);
                 };
             });
 
-            fakeEmitter.emit('toDeviceEvent', {
+            fakeEmitter.emit("toDeviceEvent", {
                 getId: jest.fn().mockReturnValue("$wedged"),
-                getType: jest.fn().mockReturnValue('m.room.message'),
+                getType: jest.fn().mockReturnValue("m.room.message"),
                 getContent: jest.fn().mockReturnValue({
-                    msgtype: 'm.bad.encrypted',
+                    msgtype: "m.bad.encrypted",
                 }),
                 getWireContent: jest.fn().mockReturnValue({
-                    algorithm: 'm.olm.v1.curve25519-aes-sha2',
-                    sender_key: 'this is a key',
+                    algorithm: "m.olm.v1.curve25519-aes-sha2",
+                    sender_key: "this is a key",
                 }),
-                getSender: jest.fn().mockReturnValue('@bob:home.server'),
+                getSender: jest.fn().mockReturnValue("@bob:home.server"),
             });
 
             await prom;
         });
     });
 
-    describe('Key requests', function() {
+    describe("Key requests", function () {
         let aliceClient: MatrixClient;
         let bobClient: MatrixClient;
         let claraClient: MatrixClient;
 
-        beforeEach(async function() {
-            aliceClient = (new TestClient(
-                "@alice:example.com", "alicedevice",
-            )).client;
-            bobClient = (new TestClient(
-                "@bob:example.com", "bobdevice",
-            )).client;
-            claraClient = (new TestClient(
-                "@clara:example.com", "claradevice",
-            )).client;
+        beforeEach(async function () {
+            aliceClient = new TestClient("@alice:example.com", "alicedevice").client;
+            bobClient = new TestClient("@bob:example.com", "bobdevice").client;
+            claraClient = new TestClient("@clara:example.com", "claradevice").client;
             await aliceClient.initCrypto();
             await bobClient.initCrypto();
             await claraClient.initCrypto();
         });
 
-        afterEach(async function() {
+        afterEach(async function () {
             aliceClient.stopClient();
             bobClient.stopClient();
             claraClient.stopClient();
         });
 
-        it("does not cancel keyshare requests until all messages are decrypted with trusted keys", async function() {
+        it("does not cancel keyshare requests until all messages are decrypted with trusted keys", async function () {
             const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
+                algorithm: "m.megolm.v1.aes-sha2",
             };
             const roomId = "!someroom";
             const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
             const bobRoom = new Room(roomId, bobClient, "@bob:example.com", {});
             // Make Bob invited by Alice so Bob will accept Alice's forwarded keys
-            bobRoom.currentState.setStateEvents([new MatrixEvent({
-                type: "m.room.member",
-                sender: "@alice:example.com",
-                room_id: roomId,
-                content: { membership: "invite" },
-                state_key: "@bob:example.com",
-            })]);
+            bobRoom.currentState.setStateEvents([
+                new MatrixEvent({
+                    type: "m.room.member",
+                    sender: "@alice:example.com",
+                    room_id: roomId,
+                    content: { membership: "invite" },
+                    state_key: "@bob:example.com",
+                }),
+            ]);
             aliceClient.store.storeRoom(aliceRoom);
             bobClient.store.storeRoom(bobRoom);
             await aliceClient.setRoomEncryption(roomId, encryptionCfg);
@@ -335,35 +332,37 @@ describe("Crypto", function() {
                     },
                 }),
             ];
-            await Promise.all(events.map(async (event) => {
-                // alice encrypts each event, and then bob tries to decrypt
-                // them without any keys, so that they'll be in pending
-                await aliceClient.crypto!.encryptEvent(event, aliceRoom);
-                // remove keys from the event
-                // @ts-ignore private properties
-                event.clearEvent = undefined;
-                // @ts-ignore private properties
-                event.senderCurve25519Key = null;
-                // @ts-ignore private properties
-                event.claimedEd25519Key = null;
-                try {
-                    await bobClient.crypto!.decryptEvent(event);
-                } catch (e) {
-                    // we expect this to fail because we don't have the
-                    // decryption keys yet
-                }
-            }));
+            await Promise.all(
+                events.map(async (event) => {
+                    // alice encrypts each event, and then bob tries to decrypt
+                    // them without any keys, so that they'll be in pending
+                    await aliceClient.crypto!.encryptEvent(event, aliceRoom);
+                    // remove keys from the event
+                    // @ts-ignore private properties
+                    event.clearEvent = undefined;
+                    // @ts-ignore private properties
+                    event.senderCurve25519Key = null;
+                    // @ts-ignore private properties
+                    event.claimedEd25519Key = null;
+                    try {
+                        await bobClient.crypto!.decryptEvent(event);
+                    } catch (e) {
+                        // we expect this to fail because we don't have the
+                        // decryption keys yet
+                    }
+                }),
+            );
 
             const device = new DeviceInfo(aliceClient.deviceId!);
             bobClient.crypto!.deviceList.getDeviceByIdentityKey = () => device;
 
-            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
+            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(roomId, olmlib.MEGOLM_ALGORITHM);
 
-            const decryptEventsPromise = Promise.all(events.map((ev) => {
-                return awaitEvent(ev, "Event.decrypted");
-            }));
+            const decryptEventsPromise = Promise.all(
+                events.map((ev) => {
+                    return awaitEvent(ev, "Event.decrypted");
+                }),
+            );
 
             // keyshare the session key starting at the second message, so
             // the first message can't be decrypted yet, but the second one
@@ -418,9 +417,9 @@ describe("Crypto", function() {
             expect(await cryptoStore.getOutgoingRoomKeyRequest(roomKeyRequestBody)).toBeFalsy();
         });
 
-        it("should error if a forwarded room key lacks a content.sender_key", async function() {
+        it("should error if a forwarded room key lacks a content.sender_key", async function () {
             const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
+                algorithm: "m.megolm.v1.aes-sha2",
             };
             const roomId = "!someroom";
             const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
@@ -459,9 +458,7 @@ describe("Crypto", function() {
             const device = new DeviceInfo(aliceClient.deviceId!);
             bobClient.crypto!.deviceList.getDeviceByIdentityKey = () => device;
 
-            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
+            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(roomId, olmlib.MEGOLM_ALGORITHM);
 
             const ksEvent = await keyshareEventForEvent(aliceClient, event, 1);
             ksEvent.getContent().sender_key = undefined; // test
@@ -470,7 +467,7 @@ describe("Crypto", function() {
             expect(bobClient.crypto!.olmDevice.addInboundGroupSession).not.toHaveBeenCalled();
         });
 
-        it("creates a new keyshare request if we request a keyshare", async function() {
+        it("creates a new keyshare request if we request a keyshare", async function () {
             // make sure that cancelAndResend... creates a new keyshare request
             // if there wasn't an already-existing one
             const event = new MatrixEvent({
@@ -490,11 +487,10 @@ describe("Crypto", function() {
                 session_id: "sessionid",
                 sender_key: "senderkey",
             };
-            expect(await cryptoStore.getOutgoingRoomKeyRequest(roomKeyRequestBody))
-                .toBeDefined();
+            expect(await cryptoStore.getOutgoingRoomKeyRequest(roomKeyRequestBody)).toBeDefined();
         });
 
-        it("uses a new txnid for re-requesting keys", async function() {
+        it("uses a new txnid for re-requesting keys", async function () {
             jest.useFakeTimers();
 
             const event = new MatrixEvent({
@@ -539,9 +535,9 @@ describe("Crypto", function() {
             expect(aliceSendToDevice.mock.calls[2][2]).not.toBe(txnId);
         });
 
-        it("should accept forwarded keys which it requested", async function() {
+        it("should accept forwarded keys which it requested", async function () {
             const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
+                algorithm: "m.megolm.v1.aes-sha2",
             };
             const roomId = "!someroom";
             const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
@@ -572,24 +568,26 @@ describe("Crypto", function() {
                     },
                 }),
             ];
-            await Promise.all(events.map(async (event) => {
-                // alice encrypts each event, and then bob tries to decrypt
-                // them without any keys, so that they'll be in pending
-                await aliceClient.crypto!.encryptEvent(event, aliceRoom);
-                // remove keys from the event
-                // @ts-ignore private properties
-                event.clearEvent = undefined;
-                // @ts-ignore private properties
-                event.senderCurve25519Key = null;
-                // @ts-ignore private properties
-                event.claimedEd25519Key = null;
-                try {
-                    await bobClient.crypto!.decryptEvent(event);
-                } catch (e) {
-                    // we expect this to fail because we don't have the
-                    // decryption keys yet
-                }
-            }));
+            await Promise.all(
+                events.map(async (event) => {
+                    // alice encrypts each event, and then bob tries to decrypt
+                    // them without any keys, so that they'll be in pending
+                    await aliceClient.crypto!.encryptEvent(event, aliceRoom);
+                    // remove keys from the event
+                    // @ts-ignore private properties
+                    event.clearEvent = undefined;
+                    // @ts-ignore private properties
+                    event.senderCurve25519Key = null;
+                    // @ts-ignore private properties
+                    event.claimedEd25519Key = null;
+                    try {
+                        await bobClient.crypto!.decryptEvent(event);
+                    } catch (e) {
+                        // we expect this to fail because we don't have the
+                        // decryption keys yet
+                    }
+                }),
+            );
 
             const device = new DeviceInfo(aliceClient.deviceId!);
             bobClient.crypto!.deviceList.getDeviceByIdentityKey = () => device;
@@ -607,18 +605,17 @@ describe("Crypto", function() {
             };
             const outgoingReq = await cryptoStore.getOutgoingRoomKeyRequest(roomKeyRequestBody);
             expect(outgoingReq).toBeDefined();
-            await cryptoStore.updateOutgoingRoomKeyRequest(
-                outgoingReq!.requestId, RoomKeyRequestState.Unsent,
-                { state: RoomKeyRequestState.Sent },
-            );
+            await cryptoStore.updateOutgoingRoomKeyRequest(outgoingReq!.requestId, RoomKeyRequestState.Unsent, {
+                state: RoomKeyRequestState.Sent,
+            });
 
-            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
+            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(roomId, olmlib.MEGOLM_ALGORITHM);
 
-            const decryptEventsPromise = Promise.all(events.map((ev) => {
-                return awaitEvent(ev, "Event.decrypted");
-            }));
+            const decryptEventsPromise = Promise.all(
+                events.map((ev) => {
+                    return awaitEvent(ev, "Event.decrypted");
+                }),
+            );
             const ksEvent = await keyshareEventForEvent(aliceClient, events[0], 0);
             await bobDecryptor.onRoomKeyEvent(ksEvent);
             const key = await bobClient.crypto!.olmDevice.getInboundGroupSessionKey(
@@ -632,22 +629,24 @@ describe("Crypto", function() {
             expect(events[1].getContent().msgtype).not.toBe("m.bad.encrypted");
         });
 
-        it("should accept forwarded keys from the user who invited it to the room", async function() {
+        it("should accept forwarded keys from the user who invited it to the room", async function () {
             const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
+                algorithm: "m.megolm.v1.aes-sha2",
             };
             const roomId = "!someroom";
             const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
             const bobRoom = new Room(roomId, bobClient, "@bob:example.com", {});
             const claraRoom = new Room(roomId, claraClient, "@clara:example.com", {});
             // Make Bob invited by Clara
-            bobRoom.currentState.setStateEvents([new MatrixEvent({
-                type: "m.room.member",
-                sender: "@clara:example.com",
-                room_id: roomId,
-                content: { membership: "invite" },
-                state_key: "@bob:example.com",
-            })]);
+            bobRoom.currentState.setStateEvents([
+                new MatrixEvent({
+                    type: "m.room.member",
+                    sender: "@clara:example.com",
+                    room_id: roomId,
+                    content: { membership: "invite" },
+                    state_key: "@bob:example.com",
+                }),
+            ]);
             aliceClient.store.storeRoom(aliceRoom);
             bobClient.store.storeRoom(bobRoom);
             claraClient.store.storeRoom(claraRoom);
@@ -676,36 +675,38 @@ describe("Crypto", function() {
                     },
                 }),
             ];
-            await Promise.all(events.map(async (event) => {
-                // alice encrypts each event, and then bob tries to decrypt
-                // them without any keys, so that they'll be in pending
-                await aliceClient.crypto!.encryptEvent(event, aliceRoom);
-                // remove keys from the event
-                // @ts-ignore private properties
-                event.clearEvent = undefined;
-                // @ts-ignore private properties
-                event.senderCurve25519Key = null;
-                // @ts-ignore private properties
-                event.claimedEd25519Key = null;
-                try {
-                    await bobClient.crypto!.decryptEvent(event);
-                } catch (e) {
-                    // we expect this to fail because we don't have the
-                    // decryption keys yet
-                }
-            }));
+            await Promise.all(
+                events.map(async (event) => {
+                    // alice encrypts each event, and then bob tries to decrypt
+                    // them without any keys, so that they'll be in pending
+                    await aliceClient.crypto!.encryptEvent(event, aliceRoom);
+                    // remove keys from the event
+                    // @ts-ignore private properties
+                    event.clearEvent = undefined;
+                    // @ts-ignore private properties
+                    event.senderCurve25519Key = null;
+                    // @ts-ignore private properties
+                    event.claimedEd25519Key = null;
+                    try {
+                        await bobClient.crypto!.decryptEvent(event);
+                    } catch (e) {
+                        // we expect this to fail because we don't have the
+                        // decryption keys yet
+                    }
+                }),
+            );
 
             const device = new DeviceInfo(claraClient.deviceId!);
             bobClient.crypto!.deviceList.getDeviceByIdentityKey = () => device;
             bobClient.crypto!.deviceList.getUserByIdentityKey = () => "@clara:example.com";
 
-            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
+            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(roomId, olmlib.MEGOLM_ALGORITHM);
 
-            const decryptEventsPromise = Promise.all(events.map((ev) => {
-                return awaitEvent(ev, "Event.decrypted");
-            }));
+            const decryptEventsPromise = Promise.all(
+                events.map((ev) => {
+                    return awaitEvent(ev, "Event.decrypted");
+                }),
+            );
             const ksEvent = await keyshareEventForEvent(aliceClient, events[0], 0);
             ksEvent.event.sender = claraClient.getUserId()!;
             ksEvent.sender = new RoomMember(roomId, claraClient.getUserId()!);
@@ -721,9 +722,9 @@ describe("Crypto", function() {
             expect(events[1].getContent().msgtype).not.toBe("m.bad.encrypted");
         });
 
-        it("should accept forwarded keys from one of its own user's other devices", async function() {
+        it("should accept forwarded keys from one of its own user's other devices", async function () {
             const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
+                algorithm: "m.megolm.v1.aes-sha2",
             };
             const roomId = "!someroom";
             const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
@@ -754,37 +755,39 @@ describe("Crypto", function() {
                     },
                 }),
             ];
-            await Promise.all(events.map(async (event) => {
-                // alice encrypts each event, and then bob tries to decrypt
-                // them without any keys, so that they'll be in pending
-                await aliceClient.crypto!.encryptEvent(event, aliceRoom);
-                // remove keys from the event
-                // @ts-ignore private properties
-                event.clearEvent = undefined;
-                // @ts-ignore private properties
-                event.senderCurve25519Key = null;
-                // @ts-ignore private properties
-                event.claimedEd25519Key = null;
-                try {
-                    await bobClient.crypto!.decryptEvent(event);
-                } catch (e) {
-                    // we expect this to fail because we don't have the
-                    // decryption keys yet
-                }
-            }));
+            await Promise.all(
+                events.map(async (event) => {
+                    // alice encrypts each event, and then bob tries to decrypt
+                    // them without any keys, so that they'll be in pending
+                    await aliceClient.crypto!.encryptEvent(event, aliceRoom);
+                    // remove keys from the event
+                    // @ts-ignore private properties
+                    event.clearEvent = undefined;
+                    // @ts-ignore private properties
+                    event.senderCurve25519Key = null;
+                    // @ts-ignore private properties
+                    event.claimedEd25519Key = null;
+                    try {
+                        await bobClient.crypto!.decryptEvent(event);
+                    } catch (e) {
+                        // we expect this to fail because we don't have the
+                        // decryption keys yet
+                    }
+                }),
+            );
 
             const device = new DeviceInfo(claraClient.deviceId!);
             device.verified = DeviceInfo.DeviceVerification.VERIFIED;
             bobClient.crypto!.deviceList.getDeviceByIdentityKey = () => device;
             bobClient.crypto!.deviceList.getUserByIdentityKey = () => "@bob:example.com";
 
-            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
+            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(roomId, olmlib.MEGOLM_ALGORITHM);
 
-            const decryptEventsPromise = Promise.all(events.map((ev) => {
-                return awaitEvent(ev, "Event.decrypted");
-            }));
+            const decryptEventsPromise = Promise.all(
+                events.map((ev) => {
+                    return awaitEvent(ev, "Event.decrypted");
+                }),
+            );
             const ksEvent = await keyshareEventForEvent(aliceClient, events[0], 0);
             ksEvent.event.sender = bobClient.getUserId()!;
             ksEvent.sender = new RoomMember(roomId, bobClient.getUserId()!);
@@ -800,9 +803,9 @@ describe("Crypto", function() {
             expect(events[1].getContent().msgtype).not.toBe("m.bad.encrypted");
         });
 
-        it("should not accept unexpected forwarded keys for a room it's in", async function() {
+        it("should not accept unexpected forwarded keys for a room it's in", async function () {
             const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
+                algorithm: "m.megolm.v1.aes-sha2",
             };
             const roomId = "!someroom";
             const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
@@ -836,32 +839,32 @@ describe("Crypto", function() {
                     },
                 }),
             ];
-            await Promise.all(events.map(async (event) => {
-                // alice encrypts each event, and then bob tries to decrypt
-                // them without any keys, so that they'll be in pending
-                await aliceClient.crypto!.encryptEvent(event, aliceRoom);
-                // remove keys from the event
-                // @ts-ignore private properties
-                event.clearEvent = undefined;
-                // @ts-ignore private properties
-                event.senderCurve25519Key = null;
-                // @ts-ignore private properties
-                event.claimedEd25519Key = null;
-                try {
-                    await bobClient.crypto!.decryptEvent(event);
-                } catch (e) {
-                    // we expect this to fail because we don't have the
-                    // decryption keys yet
-                }
-            }));
+            await Promise.all(
+                events.map(async (event) => {
+                    // alice encrypts each event, and then bob tries to decrypt
+                    // them without any keys, so that they'll be in pending
+                    await aliceClient.crypto!.encryptEvent(event, aliceRoom);
+                    // remove keys from the event
+                    // @ts-ignore private properties
+                    event.clearEvent = undefined;
+                    // @ts-ignore private properties
+                    event.senderCurve25519Key = null;
+                    // @ts-ignore private properties
+                    event.claimedEd25519Key = null;
+                    try {
+                        await bobClient.crypto!.decryptEvent(event);
+                    } catch (e) {
+                        // we expect this to fail because we don't have the
+                        // decryption keys yet
+                    }
+                }),
+            );
 
             const device = new DeviceInfo(claraClient.deviceId!);
             bobClient.crypto!.deviceList.getDeviceByIdentityKey = () => device;
             bobClient.crypto!.deviceList.getUserByIdentityKey = () => "@alice:example.com";
 
-            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
+            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(roomId, olmlib.MEGOLM_ALGORITHM);
 
             const ksEvent = await keyshareEventForEvent(aliceClient, events[0], 0);
             ksEvent.event.sender = claraClient.getUserId()!;
@@ -875,9 +878,9 @@ describe("Crypto", function() {
             expect(key).toBeNull();
         });
 
-        it("should park forwarded keys for a room it's not in", async function() {
+        it("should park forwarded keys for a room it's not in", async function () {
             const encryptionCfg = {
-                "algorithm": "m.megolm.v1.aes-sha2",
+                algorithm: "m.megolm.v1.aes-sha2",
             };
             const roomId = "!someroom";
             const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
@@ -905,26 +908,26 @@ describe("Crypto", function() {
                     },
                 }),
             ];
-            await Promise.all(events.map(async (event) => {
-                // alice encrypts each event, and then bob tries to decrypt
-                // them without any keys, so that they'll be in pending
-                await aliceClient.crypto!.encryptEvent(event, aliceRoom);
-                // remove keys from the event
-                // @ts-ignore private properties
-                event.clearEvent = undefined;
-                // @ts-ignore private properties
-                event.senderCurve25519Key = null;
-                // @ts-ignore private properties
-                event.claimedEd25519Key = null;
-            }));
+            await Promise.all(
+                events.map(async (event) => {
+                    // alice encrypts each event, and then bob tries to decrypt
+                    // them without any keys, so that they'll be in pending
+                    await aliceClient.crypto!.encryptEvent(event, aliceRoom);
+                    // remove keys from the event
+                    // @ts-ignore private properties
+                    event.clearEvent = undefined;
+                    // @ts-ignore private properties
+                    event.senderCurve25519Key = null;
+                    // @ts-ignore private properties
+                    event.claimedEd25519Key = null;
+                }),
+            );
 
             const device = new DeviceInfo(aliceClient.deviceId!);
             bobClient.crypto!.deviceList.getDeviceByIdentityKey = () => device;
             bobClient.crypto!.deviceList.getUserByIdentityKey = () => "@alice:example.com";
 
-            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(
-                roomId, olmlib.MEGOLM_ALGORITHM,
-            );
+            const bobDecryptor = bobClient.crypto!.getRoomDecryptor(roomId, olmlib.MEGOLM_ALGORITHM);
 
             const content = events[0].getWireContent();
 
@@ -943,22 +946,24 @@ describe("Crypto", function() {
                 content.session_id,
             );
             const parked = await bobClient.crypto!.cryptoStore.takeParkedSharedHistory(roomId);
-            expect(parked).toEqual([{
-                senderId: aliceClient.getUserId(),
-                senderKey: content.sender_key,
-                sessionId: content.session_id,
-                sessionKey: aliceKey!.key,
-                keysClaimed: { ed25519: aliceKey!.sender_claimed_ed25519_key },
-                forwardingCurve25519KeyChain: ["akey"],
-            }]);
+            expect(parked).toEqual([
+                {
+                    senderId: aliceClient.getUserId(),
+                    senderKey: content.sender_key,
+                    sessionId: content.session_id,
+                    sessionKey: aliceKey!.key,
+                    keysClaimed: { ed25519: aliceKey!.sender_claimed_ed25519_key },
+                    forwardingCurve25519KeyChain: ["akey"],
+                },
+            ]);
         });
     });
 
-    describe('Secret storage', function() {
-        it("creates secret storage even if there is no keyInfo", async function() {
-            jest.spyOn(logger, 'log').mockImplementation(() => {});
+    describe("Secret storage", function () {
+        it("creates secret storage even if there is no keyInfo", async function () {
+            jest.spyOn(logger, "log").mockImplementation(() => {});
             jest.setTimeout(10000);
-            const client = (new TestClient("@a:example.com", "dev")).client;
+            const client = new TestClient("@a:example.com", "dev").client;
             await client.initCrypto();
             client.crypto!.getSecretStorageKey = jest.fn().mockResolvedValue(null);
             client.crypto!.isCrossSigningReady = async () => false;
@@ -990,7 +995,7 @@ describe("Crypto", function() {
             ensureOlmSessionsForDevices = jest.spyOn(olmlib, "ensureOlmSessionsForDevices");
             ensureOlmSessionsForDevices.mockResolvedValue({});
             encryptMessageForDevice = jest.spyOn(olmlib, "encryptMessageForDevice");
-            encryptMessageForDevice.mockImplementation(async (...[result,,,,,, payload]) => {
+            encryptMessageForDevice.mockImplementation(async (...[result, , , , , , payload]) => {
                 result.plaintext = { type: 0, body: JSON.stringify(payload) };
             });
 
@@ -998,10 +1003,7 @@ describe("Crypto", function() {
 
             // running initCrypto should trigger a key upload
             client.httpBackend.when("POST", "/keys/upload").respond(200, {});
-            await Promise.all([
-                client.client.initCrypto(),
-                client.httpBackend.flush("/keys/upload", 1),
-            ]);
+            await Promise.all([client.client.initCrypto(), client.httpBackend.flush("/keys/upload", 1)]);
 
             encryptedPayload = {
                 algorithm: "m.olm.v1.curve25519-aes-sha2",
@@ -1035,7 +1037,8 @@ describe("Crypto", function() {
                             },
                         },
                     });
-                }).respond(200, {});
+                })
+                .respond(200, {});
 
             await Promise.all([
                 client.client.encryptAndSendToDevices(
@@ -1051,7 +1054,7 @@ describe("Crypto", function() {
         });
 
         it("sends nothing to devices that couldn't be encrypted to", async () => {
-            encryptMessageForDevice.mockImplementation(async (...[result,,,, userId, device, payload]) => {
+            encryptMessageForDevice.mockImplementation(async (...[result, , , , userId, device, payload]) => {
                 // Refuse to encrypt to Carol's desktop device
                 if (userId === "@carol:example.org" && device.deviceId === "caroldesktop") return;
                 result.plaintext = { type: 0, body: JSON.stringify(payload) };
@@ -1111,10 +1114,13 @@ describe("Crypto", function() {
 
         it("should free PkDecryption", () => {
             const free = jest.fn();
-            jest.spyOn(Olm, "PkDecryption").mockImplementation(() => ({
-                init_with_private_key: jest.fn(),
-                free,
-            }) as unknown as PkDecryption);
+            jest.spyOn(Olm, "PkDecryption").mockImplementation(
+                () =>
+                    ({
+                        init_with_private_key: jest.fn(),
+                        free,
+                    } as unknown as PkDecryption),
+            );
             client.client.checkSecretStoragePrivateKey(new Uint8Array(), "");
             expect(free).toHaveBeenCalled();
         });
@@ -1134,10 +1140,13 @@ describe("Crypto", function() {
 
         it("should free PkSigning", () => {
             const free = jest.fn();
-            jest.spyOn(Olm, "PkSigning").mockImplementation(() => ({
-                init_with_seed: jest.fn(),
-                free,
-            }) as unknown as PkSigning);
+            jest.spyOn(Olm, "PkSigning").mockImplementation(
+                () =>
+                    ({
+                        init_with_seed: jest.fn(),
+                        free,
+                    } as unknown as PkSigning),
+            );
             client.client.checkCrossSigningPrivateKey(new Uint8Array(), "");
             expect(free).toHaveBeenCalled();
         });
@@ -1151,7 +1160,7 @@ describe("Crypto", function() {
             await client.client.initCrypto();
         });
 
-        afterEach(async function() {
+        afterEach(async function () {
             await client!.stop();
         });
 
@@ -1167,7 +1176,7 @@ describe("Crypto", function() {
         let clientStore: IStore;
         let crypto: Crypto;
 
-        beforeEach(async function() {
+        beforeEach(async function () {
             mockClient = {} as MatrixClient;
             const mockStorage = new MockStorageApi() as unknown as Storage;
             clientStore = new MemoryStore({ localStorage: mockStorage }) as unknown as IStore;
diff --git a/spec/unit/crypto/CrossSigningInfo.spec.ts b/spec/unit/crypto/CrossSigningInfo.spec.ts
index ad02fb217e7..090a2a10ea9 100644
--- a/spec/unit/crypto/CrossSigningInfo.spec.ts
+++ b/spec/unit/crypto/CrossSigningInfo.spec.ts
@@ -14,28 +14,21 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
-import {
-    CrossSigningInfo,
-    createCryptoStoreCacheCallbacks,
-} from '../../../src/crypto/CrossSigning';
-import {
-    IndexedDBCryptoStore,
-} from '../../../src/crypto/store/indexeddb-crypto-store';
-import { MemoryCryptoStore } from '../../../src/crypto/store/memory-crypto-store';
-import 'fake-indexeddb/auto';
-import 'jest-localstorage-mock';
+import "../../olm-loader";
+import { CrossSigningInfo, createCryptoStoreCacheCallbacks } from "../../../src/crypto/CrossSigning";
+import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
+import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
+import "fake-indexeddb/auto";
+import "jest-localstorage-mock";
 import { OlmDevice } from "../../../src/crypto/OlmDevice";
-import { logger } from '../../../src/logger';
+import { logger } from "../../../src/logger";
 
 const userId = "@alice:example.com";
 
 // Private key for tests only
 const testKey = new Uint8Array([
-    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82,
-    0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef,
-    0xae, 0xb1, 0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6,
-    0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
+    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82, 0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef, 0xae, 0xb1, 0x05,
+    0xc1, 0xe7, 0x62, 0x78, 0xa6, 0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
 ]);
 
 const types = [
@@ -50,13 +43,13 @@ badKey[0] ^= 1;
 
 const masterKeyPub = "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk";
 
-describe("CrossSigningInfo.getCrossSigningKey", function() {
+describe("CrossSigningInfo.getCrossSigningKey", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn("Not running megolm backup unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
@@ -65,13 +58,12 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
         await expect(info.getCrossSigningKey("master")).rejects.toThrow();
     });
 
-    it.each(types)("should throw if the callback returns falsey",
-        async ({ type, shouldCache }) => {
-            const info = new CrossSigningInfo(userId, {
-                getCrossSigningKey: async () => false as unknown as Uint8Array,
-            });
-            await expect(info.getCrossSigningKey(type)).rejects.toThrow("falsey");
+    it.each(types)("should throw if the callback returns falsey", async ({ type, shouldCache }) => {
+        const info = new CrossSigningInfo(userId, {
+            getCrossSigningKey: async () => false as unknown as Uint8Array,
         });
+        await expect(info.getCrossSigningKey(type)).rejects.toThrow("falsey");
+    });
 
     it("should throw if the expected key doesn't come back", async () => {
         const info = new CrossSigningInfo(userId, {
@@ -96,10 +88,49 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
         }
     });
 
-    it.each(types)("should request a key from the cache callback (if set)" +
-                   " and does not call app if one is found" +
-                   " %o",
-    async ({ type, shouldCache }) => {
+    it.each(types)(
+        "should request a key from the cache callback (if set)" + " and does not call app if one is found" + " %o",
+        async ({ type, shouldCache }) => {
+            const getCrossSigningKey = jest.fn().mockImplementation(() => {
+                if (shouldCache) {
+                    return Promise.reject(new Error("Regular callback called"));
+                } else {
+                    return Promise.resolve(testKey);
+                }
+            });
+            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
+            const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { getCrossSigningKeyCache });
+            const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
+            expect(pubKey).toEqual(masterKeyPub);
+            expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
+            if (shouldCache) {
+                expect(getCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
+            }
+        },
+    );
+
+    it.each(types)("should store a key with the cache callback (if set)", async ({ type, shouldCache }) => {
+        const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
+        const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
+        const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { storeCrossSigningKeyCache });
+        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
+        expect(pubKey).toEqual(masterKeyPub);
+        expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(shouldCache ? 1 : 0);
+        if (shouldCache) {
+            expect(storeCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
+            expect(storeCrossSigningKeyCache.mock.calls[0][1]).toBe(testKey);
+        }
+    });
+
+    it.each(types)("does not store a bad key to the cache", async ({ type, shouldCache }) => {
+        const getCrossSigningKey = jest.fn().mockResolvedValue(badKey);
+        const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
+        const info = new CrossSigningInfo(userId, { getCrossSigningKey }, { storeCrossSigningKeyCache });
+        await expect(info.getCrossSigningKey(type, masterKeyPub)).rejects.toThrow();
+        expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(0);
+    });
+
+    it.each(types)("does not store a value to the cache if it came from the cache", async ({ type, shouldCache }) => {
         const getCrossSigningKey = jest.fn().mockImplementation(() => {
             if (shouldCache) {
                 return Promise.reject(new Error("Regular callback called"));
@@ -108,110 +139,58 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
             }
         });
         const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
+        const storeCrossSigningKeyCache = jest.fn().mockRejectedValue(new Error("Tried to store a value from cache"));
         const info = new CrossSigningInfo(
             userId,
             { getCrossSigningKey },
-            { getCrossSigningKeyCache },
+            { getCrossSigningKeyCache, storeCrossSigningKeyCache },
         );
+        expect(storeCrossSigningKeyCache.mock.calls.length).toBe(0);
         const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
         expect(pubKey).toEqual(masterKeyPub);
-        expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-        if (shouldCache) {
-            expect(getCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
-        }
     });
 
-    it.each(types)("should store a key with the cache callback (if set)",
+    it.each(types)(
+        "requests a key from the cache callback (if set) and then calls app" + " if one is not found",
         async ({ type, shouldCache }) => {
             const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-            const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
+            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
+            const storeCrossSigningKeyCache = jest.fn();
             const info = new CrossSigningInfo(
                 userId,
                 { getCrossSigningKey },
-                { storeCrossSigningKeyCache },
+                { getCrossSigningKeyCache, storeCrossSigningKeyCache },
             );
             const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
             expect(pubKey).toEqual(masterKeyPub);
-            expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(shouldCache ? 1 : 0);
-            if (shouldCache) {
-                expect(storeCrossSigningKeyCache.mock.calls[0][0]).toBe(type);
-                expect(storeCrossSigningKeyCache.mock.calls[0][1]).toBe(testKey);
-            }
-        });
+            expect(getCrossSigningKey.mock.calls.length).toBe(1);
+            expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
 
-    it.each(types)("does not store a bad key to the cache",
-        async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockResolvedValue(badKey);
-            const storeCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-            const info = new CrossSigningInfo(
-                userId,
-                { getCrossSigningKey },
-                { storeCrossSigningKeyCache },
-            );
-            await expect(info.getCrossSigningKey(type, masterKeyPub)).rejects.toThrow();
-            expect(storeCrossSigningKeyCache.mock.calls.length).toEqual(0);
-        });
+            /* Also expect that the cache gets updated */
+            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
+        },
+    );
 
-    it.each(types)("does not store a value to the cache if it came from the cache",
+    it.each(types)(
+        "requests a key from the cache callback (if set) and then" + " calls app if that key doesn't match",
         async ({ type, shouldCache }) => {
-            const getCrossSigningKey = jest.fn().mockImplementation(() => {
-                if (shouldCache) {
-                    return Promise.reject(new Error("Regular callback called"));
-                } else {
-                    return Promise.resolve(testKey);
-                }
-            });
-            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(testKey);
-            const storeCrossSigningKeyCache = jest.fn().mockRejectedValue(
-                new Error("Tried to store a value from cache"),
-            );
+            const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
+            const getCrossSigningKeyCache = jest.fn().mockResolvedValue(badKey);
+            const storeCrossSigningKeyCache = jest.fn();
             const info = new CrossSigningInfo(
                 userId,
                 { getCrossSigningKey },
                 { getCrossSigningKeyCache, storeCrossSigningKeyCache },
             );
-            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(0);
             const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
             expect(pubKey).toEqual(masterKeyPub);
-        });
-
-    it.each(types)("requests a key from the cache callback (if set) and then calls app" +
-        " if one is not found", async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-        const getCrossSigningKeyCache = jest.fn().mockResolvedValue(undefined);
-        const storeCrossSigningKeyCache = jest.fn();
-        const info = new CrossSigningInfo(
-            userId,
-            { getCrossSigningKey },
-            { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-        );
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        expect(getCrossSigningKey.mock.calls.length).toBe(1);
-        expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-
-        /* Also expect that the cache gets updated */
-        expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-    });
-
-    it.each(types)("requests a key from the cache callback (if set) and then" +
-        " calls app if that key doesn't match", async ({ type, shouldCache }) => {
-        const getCrossSigningKey = jest.fn().mockResolvedValue(testKey);
-        const getCrossSigningKeyCache = jest.fn().mockResolvedValue(badKey);
-        const storeCrossSigningKeyCache = jest.fn();
-        const info = new CrossSigningInfo(
-            userId,
-            { getCrossSigningKey },
-            { getCrossSigningKeyCache, storeCrossSigningKeyCache },
-        );
-        const [pubKey] = await info.getCrossSigningKey(type, masterKeyPub);
-        expect(pubKey).toEqual(masterKeyPub);
-        expect(getCrossSigningKey.mock.calls.length).toBe(1);
-        expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
+            expect(getCrossSigningKey.mock.calls.length).toBe(1);
+            expect(getCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
 
-        /* Also expect that the cache gets updated */
-        expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
-    });
+            /* Also expect that the cache gets updated */
+            expect(storeCrossSigningKeyCache.mock.calls.length).toBe(shouldCache ? 1 : 0);
+        },
+    );
 });
 
 /*
@@ -219,19 +198,20 @@ describe("CrossSigningInfo.getCrossSigningKey", function() {
  * it's not possible to get one in normal execution unless you hack as we do here.
  */
 describe.each([
-    ["IndexedDBCryptoStore",
-        () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
-    ["LocalStorageCryptoStore",
-        () => new IndexedDBCryptoStore(undefined!, "tests")],
-    ["MemoryCryptoStore", () => {
-        const store = new IndexedDBCryptoStore(undefined!, "tests");
-        // @ts-ignore set private properties
-        store._backend = new MemoryCryptoStore();
-        // @ts-ignore
-        store._backendPromise = Promise.resolve(store._backend);
-        return store;
-    }],
-])("CrossSigning > createCryptoStoreCacheCallbacks [%s]", function(name, dbFactory) {
+    ["IndexedDBCryptoStore", () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
+    ["LocalStorageCryptoStore", () => new IndexedDBCryptoStore(undefined!, "tests")],
+    [
+        "MemoryCryptoStore",
+        () => {
+            const store = new IndexedDBCryptoStore(undefined!, "tests");
+            // @ts-ignore set private properties
+            store._backend = new MemoryCryptoStore();
+            // @ts-ignore
+            store._backendPromise = Promise.resolve(store._backend);
+            return store;
+        },
+    ],
+])("CrossSigning > createCryptoStoreCacheCallbacks [%s]", function (name, dbFactory) {
     let store: IndexedDBCryptoStore;
 
     beforeAll(() => {
@@ -245,8 +225,10 @@ describe.each([
     it("should cache data to the store and retrieve it", async () => {
         await store.startup();
         const olmDevice = new OlmDevice(store);
-        const { getCrossSigningKeyCache, storeCrossSigningKeyCache } =
-              createCryptoStoreCacheCallbacks(store, olmDevice);
+        const { getCrossSigningKeyCache, storeCrossSigningKeyCache } = createCryptoStoreCacheCallbacks(
+            store,
+            olmDevice,
+        );
         await storeCrossSigningKeyCache!("self_signing", testKey);
 
         // If we've not saved anything, don't expect anything
diff --git a/spec/unit/crypto/DeviceList.spec.ts b/spec/unit/crypto/DeviceList.spec.ts
index 38c0e2df89a..39ba036a252 100644
--- a/spec/unit/crypto/DeviceList.spec.ts
+++ b/spec/unit/crypto/DeviceList.spec.ts
@@ -25,31 +25,26 @@ import { OlmDevice } from "../../../src/crypto/OlmDevice";
 import { CryptoStore } from "../../../src/crypto/store/base";
 
 const signedDeviceList: IDownloadKeyResult = {
-    "failures": {},
-    "device_keys": {
+    failures: {},
+    device_keys: {
         "@test1:sw1v.org": {
-            "HGKAWHRVJQ": {
-                "signatures": {
+            HGKAWHRVJQ: {
+                signatures: {
                     "@test1:sw1v.org": {
                         "ed25519:HGKAWHRVJQ":
                             "8PB450fxKDn5s8IiRZ2N2t6MiueQYVRLHFEzqIi1eLdxx1w" +
                             "XEPC1/1Uz9T4gwnKlMVAKkhB5hXQA/3kjaeLABw",
                     },
                 },
-                "user_id": "@test1:sw1v.org",
-                "keys": {
-                    "ed25519:HGKAWHRVJQ":
-                        "0gI/T6C+mn1pjtvnnW2yB2l1IIBb/5ULlBXi/LXFSEQ",
-                    "curve25519:HGKAWHRVJQ":
-                        "mbIZED1dBsgIgkgzxDpxKkJmsr4hiWlGzQTvUnQe3RY",
+                user_id: "@test1:sw1v.org",
+                keys: {
+                    "ed25519:HGKAWHRVJQ": "0gI/T6C+mn1pjtvnnW2yB2l1IIBb/5ULlBXi/LXFSEQ",
+                    "curve25519:HGKAWHRVJQ": "mbIZED1dBsgIgkgzxDpxKkJmsr4hiWlGzQTvUnQe3RY",
                 },
-                "algorithms": [
-                    "m.olm.v1.curve25519-aes-sha2",
-                    "m.megolm.v1.aes-sha2",
-                ],
-                "device_id": "HGKAWHRVJQ",
-                "unsigned": {
-                    "device_display_name": "",
+                algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+                device_id: "HGKAWHRVJQ",
+                unsigned: {
+                    device_display_name: "",
                 },
             },
         },
@@ -57,50 +52,45 @@ const signedDeviceList: IDownloadKeyResult = {
 };
 
 const signedDeviceList2: IDownloadKeyResult = {
-    "failures": {},
-    "device_keys": {
+    failures: {},
+    device_keys: {
         "@test2:sw1v.org": {
-            "QJVRHWAKGH": {
-                "signatures": {
+            QJVRHWAKGH: {
+                signatures: {
                     "@test2:sw1v.org": {
                         "ed25519:QJVRHWAKGH":
                             "w1xxdLe1iIqzEFHLRVYQeuiM6t2N2ZRiI8s5nDKxf054BP8" +
                             "1CPEX/AQXh5BhkKAVMlKnwg4T9zU1/wBALeajk3",
                     },
                 },
-                "user_id": "@test2:sw1v.org",
-                "keys": {
-                    "ed25519:QJVRHWAKGH":
-                        "Ig0/C6T+bBII1l2By2Wnnvtjp1nm/iXBlLU5/QESFXL",
-                    "curve25519:QJVRHWAKGH":
-                        "YR3eQnUvTQzGlWih4rsmJkKxpDxzgkgIgsBd1DEZIbm",
+                user_id: "@test2:sw1v.org",
+                keys: {
+                    "ed25519:QJVRHWAKGH": "Ig0/C6T+bBII1l2By2Wnnvtjp1nm/iXBlLU5/QESFXL",
+                    "curve25519:QJVRHWAKGH": "YR3eQnUvTQzGlWih4rsmJkKxpDxzgkgIgsBd1DEZIbm",
                 },
-                "algorithms": [
-                    "m.olm.v1.curve25519-aes-sha2",
-                    "m.megolm.v1.aes-sha2",
-                ],
-                "device_id": "QJVRHWAKGH",
-                "unsigned": {
-                    "device_display_name": "",
+                algorithms: ["m.olm.v1.curve25519-aes-sha2", "m.megolm.v1.aes-sha2"],
+                device_id: "QJVRHWAKGH",
+                unsigned: {
+                    device_display_name: "",
                 },
             },
         },
     },
 };
 
-describe('DeviceList', function() {
+describe("DeviceList", function () {
     let downloadSpy: jest.Mock;
     let cryptoStore: CryptoStore;
     let deviceLists: DeviceList[] = [];
 
-    beforeEach(function() {
+    beforeEach(function () {
         deviceLists = [];
 
         downloadSpy = jest.fn();
         cryptoStore = new MemoryCryptoStore();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         for (const dl of deviceLists) {
             dl.stop();
         }
@@ -109,94 +99,96 @@ describe('DeviceList', function() {
     function createTestDeviceList(keyDownloadChunkSize = 250) {
         const baseApis = {
             downloadKeysForUsers: downloadSpy,
-            getUserId: () => '@test1:sw1v.org',
-            deviceId: 'HGKAWHRVJQ',
+            getUserId: () => "@test1:sw1v.org",
+            deviceId: "HGKAWHRVJQ",
         } as unknown as MatrixClient;
         const mockOlm = {
-            verifySignature: function(key: string, message: string, signature: string) {},
+            verifySignature: function (key: string, message: string, signature: string) {},
         } as unknown as OlmDevice;
         const dl = new DeviceList(baseApis, cryptoStore, mockOlm, keyDownloadChunkSize);
         deviceLists.push(dl);
         return dl;
     }
 
-    it("should successfully download and store device keys", function() {
+    it("should successfully download and store device keys", function () {
         const dl = createTestDeviceList();
 
-        dl.startTrackingDeviceList('@test1:sw1v.org');
+        dl.startTrackingDeviceList("@test1:sw1v.org");
 
         const queryDefer1 = utils.defer<IDownloadKeyResult>();
         downloadSpy.mockReturnValue(queryDefer1.promise);
 
         const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
+        expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
         queryDefer1.resolve(utils.deepCopy(signedDeviceList));
 
         return prom1.then(() => {
-            const storedKeys = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
-            expect(Object.keys(storedKeys)).toEqual(['HGKAWHRVJQ']);
+            const storedKeys = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
+            expect(Object.keys(storedKeys)).toEqual(["HGKAWHRVJQ"]);
             dl.stop();
         });
     });
 
-    it("should have an outdated devicelist on an invalidation while an " +
-       "update is in progress", function() {
+    it("should have an outdated devicelist on an invalidation while an " + "update is in progress", function () {
         const dl = createTestDeviceList();
 
-        dl.startTrackingDeviceList('@test1:sw1v.org');
+        dl.startTrackingDeviceList("@test1:sw1v.org");
 
         const queryDefer1 = utils.defer<IDownloadKeyResult>();
         downloadSpy.mockReturnValue(queryDefer1.promise);
 
         const prom1 = dl.refreshOutdatedDeviceLists();
-        expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
+        expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
         downloadSpy.mockReset();
 
         // outdated notif arrives while the request is in flight.
         const queryDefer2 = utils.defer();
         downloadSpy.mockReturnValue(queryDefer2.promise);
 
-        dl.invalidateUserDeviceList('@test1:sw1v.org');
+        dl.invalidateUserDeviceList("@test1:sw1v.org");
         dl.refreshOutdatedDeviceLists();
 
-        dl.saveIfDirty().then(() => {
-            // the first request completes
-            queryDefer1.resolve({
-                failures: {},
-                device_keys: {
-                    '@test1:sw1v.org': {},
-                },
+        dl.saveIfDirty()
+            .then(() => {
+                // the first request completes
+                queryDefer1.resolve({
+                    failures: {},
+                    device_keys: {
+                        "@test1:sw1v.org": {},
+                    },
+                });
+                return prom1;
+            })
+            .then(() => {
+                // uh-oh; user restarts before second request completes. The new instance
+                // should know we never got a complete device list.
+                logger.log("Creating new devicelist to simulate app reload");
+                downloadSpy.mockReset();
+                const dl2 = createTestDeviceList();
+                const queryDefer3 = utils.defer<IDownloadKeyResult>();
+                downloadSpy.mockReturnValue(queryDefer3.promise);
+
+                const prom3 = dl2.refreshOutdatedDeviceLists();
+                expect(downloadSpy).toHaveBeenCalledWith(["@test1:sw1v.org"], {});
+                dl2.stop();
+
+                queryDefer3.resolve(utils.deepCopy(signedDeviceList));
+
+                // allow promise chain to complete
+                return prom3;
+            })
+            .then(() => {
+                const storedKeys = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
+                expect(Object.keys(storedKeys)).toEqual(["HGKAWHRVJQ"]);
+                dl.stop();
             });
-            return prom1;
-        }).then(() => {
-            // uh-oh; user restarts before second request completes. The new instance
-            // should know we never got a complete device list.
-            logger.log("Creating new devicelist to simulate app reload");
-            downloadSpy.mockReset();
-            const dl2 = createTestDeviceList();
-            const queryDefer3 = utils.defer<IDownloadKeyResult>();
-            downloadSpy.mockReturnValue(queryDefer3.promise);
-
-            const prom3 = dl2.refreshOutdatedDeviceLists();
-            expect(downloadSpy).toHaveBeenCalledWith(['@test1:sw1v.org'], {});
-            dl2.stop();
-
-            queryDefer3.resolve(utils.deepCopy(signedDeviceList));
-
-            // allow promise chain to complete
-            return prom3;
-        }).then(() => {
-            const storedKeys = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
-            expect(Object.keys(storedKeys)).toEqual(['HGKAWHRVJQ']);
-            dl.stop();
-        });
     });
 
-    it("should download device keys in batches", function() {
+    it("should download device keys in batches", function () {
         const dl = createTestDeviceList(1);
 
-        dl.startTrackingDeviceList('@test1:sw1v.org');
-        dl.startTrackingDeviceList('@test2:sw1v.org');
+        dl.startTrackingDeviceList("@test1:sw1v.org");
+        dl.startTrackingDeviceList("@test2:sw1v.org");
 
         const queryDefer1 = utils.defer<IDownloadKeyResult>();
         downloadSpy.mockReturnValueOnce(queryDefer1.promise);
@@ -205,16 +197,16 @@ describe('DeviceList', function() {
 
         const prom1 = dl.refreshOutdatedDeviceLists();
         expect(downloadSpy).toBeCalledTimes(2);
-        expect(downloadSpy).toHaveBeenNthCalledWith(1, ['@test1:sw1v.org'], {});
-        expect(downloadSpy).toHaveBeenNthCalledWith(2, ['@test2:sw1v.org'], {});
+        expect(downloadSpy).toHaveBeenNthCalledWith(1, ["@test1:sw1v.org"], {});
+        expect(downloadSpy).toHaveBeenNthCalledWith(2, ["@test2:sw1v.org"], {});
         queryDefer1.resolve(utils.deepCopy(signedDeviceList));
         queryDefer2.resolve(utils.deepCopy(signedDeviceList2));
 
         return prom1.then(() => {
-            const storedKeys1 = dl.getRawStoredDevicesForUser('@test1:sw1v.org');
-            expect(Object.keys(storedKeys1)).toEqual(['HGKAWHRVJQ']);
-            const storedKeys2 = dl.getRawStoredDevicesForUser('@test2:sw1v.org');
-            expect(Object.keys(storedKeys2)).toEqual(['QJVRHWAKGH']);
+            const storedKeys1 = dl.getRawStoredDevicesForUser("@test1:sw1v.org");
+            expect(Object.keys(storedKeys1)).toEqual(["HGKAWHRVJQ"]);
+            const storedKeys2 = dl.getRawStoredDevicesForUser("@test2:sw1v.org");
+            expect(Object.keys(storedKeys2)).toEqual(["QJVRHWAKGH"]);
             dl.stop();
         });
     });
diff --git a/spec/unit/crypto/algorithms/megolm.spec.ts b/spec/unit/crypto/algorithms/megolm.spec.ts
index 48bdbc4ad0c..5b00466d826 100644
--- a/spec/unit/crypto/algorithms/megolm.spec.ts
+++ b/spec/unit/crypto/algorithms/megolm.spec.ts
@@ -14,9 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { mocked, MockedObject } from 'jest-mock';
+import { mocked, MockedObject } from "jest-mock";
 
-import '../../../olm-loader';
+import "../../../olm-loader";
 import type { OutboundGroupSession } from "@matrix-org/olm";
 import * as algorithms from "../../../../src/crypto/algorithms";
 import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
@@ -28,26 +28,26 @@ import { MatrixEvent } from "../../../../src/models/event";
 import { TestClient } from "../../../TestClient";
 import { Room } from "../../../../src/models/room";
 import * as olmlib from "../../../../src/crypto/olmlib";
-import { TypedEventEmitter } from '../../../../src/models/typed-event-emitter';
-import { ClientEvent, MatrixClient, RoomMember } from '../../../../src';
-import { DeviceInfo, IDevice } from '../../../../src/crypto/deviceinfo';
-import { DeviceTrustLevel } from '../../../../src/crypto/CrossSigning';
+import { TypedEventEmitter } from "../../../../src/models/typed-event-emitter";
+import { ClientEvent, MatrixClient, RoomMember } from "../../../../src";
+import { DeviceInfo, IDevice } from "../../../../src/crypto/deviceinfo";
+import { DeviceTrustLevel } from "../../../../src/crypto/CrossSigning";
 import { MegolmEncryption as MegolmEncryptionClass } from "../../../../src/crypto/algorithms/megolm";
 
-const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
-const MegolmEncryption = algorithms.ENCRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
+const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get("m.megolm.v1.aes-sha2")!;
+const MegolmEncryption = algorithms.ENCRYPTION_CLASSES.get("m.megolm.v1.aes-sha2")!;
 
-const ROOM_ID = '!ROOM:ID';
+const ROOM_ID = "!ROOM:ID";
 
 const Olm = global.Olm;
 
-describe("MegolmDecryption", function() {
+describe("MegolmDecryption", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm unit tests: libolm not present');
+        logger.warn("Not running megolm unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
@@ -56,8 +56,8 @@ describe("MegolmDecryption", function() {
     let mockCrypto: MockedObject<Crypto>;
     let mockBaseApis: MockedObject<MatrixClient>;
 
-    beforeEach(async function() {
-        mockCrypto = testUtils.mock(Crypto, 'Crypto') as MockedObject<Crypto>;
+    beforeEach(async function () {
+        mockCrypto = testUtils.mock(Crypto, "Crypto") as MockedObject<Crypto>;
         mockBaseApis = {
             claimOneTimeKeys: jest.fn(),
             sendToDevice: jest.fn(),
@@ -69,7 +69,7 @@ describe("MegolmDecryption", function() {
         const olmDevice = new OlmDevice(cryptoStore);
 
         megolmDecryption = new MegolmDecryption({
-            userId: '@user:id',
+            userId: "@user:id",
             crypto: mockCrypto,
             olmDevice: olmDevice,
             baseApis: mockBaseApis,
@@ -88,22 +88,22 @@ describe("MegolmDecryption", function() {
         jest.clearAllMocks();
     });
 
-    describe('receives some keys:', function() {
+    describe("receives some keys:", function () {
         let groupSession: OutboundGroupSession;
-        beforeEach(async function() {
+        beforeEach(async function () {
             groupSession = new global.Olm.OutboundGroupSession();
             groupSession.create();
 
             // construct a fake decrypted key event via the use of a mocked
             // 'crypto' implementation.
             const event = new MatrixEvent({
-                type: 'm.room.encrypted',
+                type: "m.room.encrypted",
             });
             const decryptedData = {
                 clearEvent: {
-                    type: 'm.room_key',
+                    type: "m.room_key",
                     content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
+                        algorithm: "m.megolm.v1.aes-sha2",
                         room_id: ROOM_ID,
                         session_id: groupSession.session_id(),
                         session_key: groupSession.session_key(),
@@ -120,7 +120,7 @@ describe("MegolmDecryption", function() {
             };
 
             const mockCrypto = {
-                decryptEvent: function() {
+                decryptEvent: function () {
                     return Promise.resolve(decryptedData);
                 },
             } as unknown as Crypto;
@@ -130,106 +130,113 @@ describe("MegolmDecryption", function() {
             });
         });
 
-        it('can decrypt an event', function() {
+        it("can decrypt an event", function () {
             const event = new MatrixEvent({
-                type: 'm.room.encrypted',
+                type: "m.room.encrypted",
                 room_id: ROOM_ID,
                 content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
+                    algorithm: "m.megolm.v1.aes-sha2",
                     sender_key: "SENDER_CURVE25519",
                     session_id: groupSession.session_id(),
-                    ciphertext: groupSession.encrypt(JSON.stringify({
-                        room_id: ROOM_ID,
-                        content: 'testytest',
-                    })),
+                    ciphertext: groupSession.encrypt(
+                        JSON.stringify({
+                            room_id: ROOM_ID,
+                            content: "testytest",
+                        }),
+                    ),
                 },
             });
 
             return megolmDecryption.decryptEvent(event).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
+                expect(res.clearEvent.content).toEqual("testytest");
             });
         });
 
-        it('can respond to a key request event', function() {
+        it("can respond to a key request event", function () {
             const keyRequest: IncomingRoomKeyRequest = {
-                requestId: '123',
+                requestId: "123",
                 share: jest.fn(),
-                userId: '@alice:foo',
-                deviceId: 'alidevice',
+                userId: "@alice:foo",
+                deviceId: "alidevice",
                 requestBody: {
-                    algorithm: '',
+                    algorithm: "",
                     room_id: ROOM_ID,
                     sender_key: "SENDER_CURVE25519",
                     session_id: groupSession.session_id(),
                 },
             };
 
-            return megolmDecryption.hasKeysForKeyRequest(
-                keyRequest,
-            ).then((hasKeys) => {
-                expect(hasKeys).toBe(true);
+            return megolmDecryption
+                .hasKeysForKeyRequest(keyRequest)
+                .then((hasKeys) => {
+                    expect(hasKeys).toBe(true);
 
-                // set up some pre-conditions for the share call
-                const deviceInfo = {} as DeviceInfo;
-                mockCrypto.getStoredDevice.mockReturnValue(deviceInfo);
+                    // set up some pre-conditions for the share call
+                    const deviceInfo = {} as DeviceInfo;
+                    mockCrypto.getStoredDevice.mockReturnValue(deviceInfo);
 
-                mockOlmLib.ensureOlmSessionsForDevices.mockResolvedValue({
-                    '@alice:foo': { 'alidevice': {
-                        sessionId: 'alisession',
-                        device: new DeviceInfo('alidevice'),
-                    } },
-                });
+                    mockOlmLib.ensureOlmSessionsForDevices.mockResolvedValue({
+                        "@alice:foo": {
+                            alidevice: {
+                                sessionId: "alisession",
+                                device: new DeviceInfo("alidevice"),
+                            },
+                        },
+                    });
 
-                const awaitEncryptForDevice = new Promise<void>((res, rej) => {
-                    mockOlmLib.encryptMessageForDevice.mockImplementation(() => {
-                        res();
-                        return Promise.resolve();
+                    const awaitEncryptForDevice = new Promise<void>((res, rej) => {
+                        mockOlmLib.encryptMessageForDevice.mockImplementation(() => {
+                            res();
+                            return Promise.resolve();
+                        });
                     });
-                });
 
-                mockBaseApis.sendToDevice.mockReset();
-                mockBaseApis.queueToDevice.mockReset();
+                    mockBaseApis.sendToDevice.mockReset();
+                    mockBaseApis.queueToDevice.mockReset();
 
-                // do the share
-                megolmDecryption.shareKeysWithDevice(keyRequest);
+                    // do the share
+                    megolmDecryption.shareKeysWithDevice(keyRequest);
 
-                // it's asynchronous, so we have to wait a bit
-                return awaitEncryptForDevice;
-            }).then(() => {
-                // check that it called encryptMessageForDevice with
-                // appropriate args.
-                expect(mockOlmLib.encryptMessageForDevice).toBeCalledTimes(1);
+                    // it's asynchronous, so we have to wait a bit
+                    return awaitEncryptForDevice;
+                })
+                .then(() => {
+                    // check that it called encryptMessageForDevice with
+                    // appropriate args.
+                    expect(mockOlmLib.encryptMessageForDevice).toBeCalledTimes(1);
 
-                const call = mockOlmLib.encryptMessageForDevice.mock.calls[0];
-                const payload = call[6];
+                    const call = mockOlmLib.encryptMessageForDevice.mock.calls[0];
+                    const payload = call[6];
 
-                expect(payload.type).toEqual("m.forwarded_room_key");
-                expect(payload.content).toMatchObject({
-                    sender_key: "SENDER_CURVE25519",
-                    sender_claimed_ed25519_key: "SENDER_ED25519",
-                    session_id: groupSession.session_id(),
-                    chain_index: 0,
-                    forwarding_curve25519_key_chain: [],
+                    expect(payload.type).toEqual("m.forwarded_room_key");
+                    expect(payload.content).toMatchObject({
+                        sender_key: "SENDER_CURVE25519",
+                        sender_claimed_ed25519_key: "SENDER_ED25519",
+                        session_id: groupSession.session_id(),
+                        chain_index: 0,
+                        forwarding_curve25519_key_chain: [],
+                    });
+                    expect(payload.content.session_key).toBeDefined();
                 });
-                expect(payload.content.session_key).toBeDefined();
-            });
         });
 
-        it("can detect replay attacks", function() {
+        it("can detect replay attacks", function () {
             // trying to decrypt two different messages (marked by different
             // event IDs or timestamps) using the same (sender key, session id,
             // message index) triple should result in an exception being thrown
             // as it should be detected as a replay attack.
             const sessionId = groupSession.session_id();
-            const cipherText = groupSession.encrypt(JSON.stringify({
-                room_id: ROOM_ID,
-                content: 'testytest',
-            }));
+            const cipherText = groupSession.encrypt(
+                JSON.stringify({
+                    room_id: ROOM_ID,
+                    content: "testytest",
+                }),
+            );
             const event1 = new MatrixEvent({
-                type: 'm.room.encrypted',
+                type: "m.room.encrypted",
                 room_id: ROOM_ID,
                 content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
+                    algorithm: "m.megolm.v1.aes-sha2",
                     sender_key: "SENDER_CURVE25519",
                     session_id: sessionId,
                     ciphertext: cipherText,
@@ -240,49 +247,50 @@ describe("MegolmDecryption", function() {
 
             const successHandler = jest.fn();
             const failureHandler = jest.fn((err) => {
-                expect(err.toString()).toMatch(
-                    /Duplicate message index, possible replay attack/,
-                );
+                expect(err.toString()).toMatch(/Duplicate message index, possible replay attack/);
             });
 
-            return megolmDecryption.decryptEvent(event1).then((res) => {
-                const event2 = new MatrixEvent({
-                    type: 'm.room.encrypted',
-                    room_id: ROOM_ID,
-                    content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
-                        sender_key: "SENDER_CURVE25519",
-                        session_id: sessionId,
-                        ciphertext: cipherText,
-                    },
-                    event_id: "$event2",
-                    origin_server_ts: 1507754149000,
-                });
+            return megolmDecryption
+                .decryptEvent(event1)
+                .then((res) => {
+                    const event2 = new MatrixEvent({
+                        type: "m.room.encrypted",
+                        room_id: ROOM_ID,
+                        content: {
+                            algorithm: "m.megolm.v1.aes-sha2",
+                            sender_key: "SENDER_CURVE25519",
+                            session_id: sessionId,
+                            ciphertext: cipherText,
+                        },
+                        event_id: "$event2",
+                        origin_server_ts: 1507754149000,
+                    });
 
-                return megolmDecryption.decryptEvent(event2);
-            }).then(
-                successHandler,
-                failureHandler,
-            ).then(() => {
-                expect(successHandler).not.toHaveBeenCalled();
-                expect(failureHandler).toHaveBeenCalled();
-            });
+                    return megolmDecryption.decryptEvent(event2);
+                })
+                .then(successHandler, failureHandler)
+                .then(() => {
+                    expect(successHandler).not.toHaveBeenCalled();
+                    expect(failureHandler).toHaveBeenCalled();
+                });
         });
 
-        it("allows re-decryption of the same event", function() {
+        it("allows re-decryption of the same event", function () {
             // in contrast with the previous test, if the event ID and
             // timestamp are the same, then it should not be considered a
             // replay attack
             const sessionId = groupSession.session_id();
-            const cipherText = groupSession.encrypt(JSON.stringify({
-                room_id: ROOM_ID,
-                content: 'testytest',
-            }));
+            const cipherText = groupSession.encrypt(
+                JSON.stringify({
+                    room_id: ROOM_ID,
+                    content: "testytest",
+                }),
+            );
             const event = new MatrixEvent({
-                type: 'm.room.encrypted',
+                type: "m.room.encrypted",
                 room_id: ROOM_ID,
                 content: {
-                    algorithm: 'm.megolm.v1.aes-sha2',
+                    algorithm: "m.megolm.v1.aes-sha2",
                     sender_key: "SENDER_CURVE25519",
                     session_id: sessionId,
                     ciphertext: cipherText,
@@ -319,13 +327,13 @@ describe("MegolmDecryption", function() {
                 mockBaseApis.claimOneTimeKeys.mockResolvedValue({
                     failures: {},
                     one_time_keys: {
-                        '@alice:home.server': {
+                        "@alice:home.server": {
                             aliceDevice: {
-                                'signed_curve25519:flooble': {
-                                    key: 'YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI',
+                                "signed_curve25519:flooble": {
+                                    key: "YmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmI",
                                     signatures: {
-                                        '@alice:home.server': {
-                                            'ed25519:aliceDevice': 'totally valid',
+                                        "@alice:home.server": {
+                                            "ed25519:aliceDevice": "totally valid",
                                         },
                                     },
                                 },
@@ -337,34 +345,34 @@ describe("MegolmDecryption", function() {
                 mockBaseApis.queueToDevice.mockResolvedValue(undefined);
 
                 aliceDeviceInfo = {
-                    deviceId: 'aliceDevice',
+                    deviceId: "aliceDevice",
                     isBlocked: jest.fn().mockReturnValue(false),
                     isUnverified: jest.fn().mockReturnValue(false),
-                    getIdentityKey: jest.fn().mockReturnValue(
-                        'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE',
-                    ),
-                    getFingerprint: jest.fn().mockReturnValue(''),
+                    getIdentityKey: jest.fn().mockReturnValue("YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE"),
+                    getFingerprint: jest.fn().mockReturnValue(""),
                 } as unknown as DeviceInfo;
 
-                mockCrypto.downloadKeys.mockReturnValue(Promise.resolve({
-                    '@alice:home.server': {
-                        aliceDevice: aliceDeviceInfo,
-                    },
-                }));
+                mockCrypto.downloadKeys.mockReturnValue(
+                    Promise.resolve({
+                        "@alice:home.server": {
+                            aliceDevice: aliceDeviceInfo,
+                        },
+                    }),
+                );
 
                 mockCrypto.checkDeviceTrust.mockReturnValue({
                     isVerified: () => false,
                 } as DeviceTrustLevel);
 
                 megolmEncryption = new MegolmEncryption({
-                    userId: '@user:id',
-                    deviceId: '12345',
+                    userId: "@user:id",
+                    deviceId: "12345",
                     crypto: mockCrypto,
                     olmDevice: olmDevice,
                     baseApis: mockBaseApis,
                     roomId: ROOM_ID,
                     config: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
+                        algorithm: "m.megolm.v1.aes-sha2",
                         rotation_period_ms: rotationPeriodMs,
                     },
                 }) as MegolmEncryptionClass;
@@ -379,9 +387,7 @@ describe("MegolmDecryption", function() {
                 mockCrypto.baseApis = mockBaseApis;
 
                 mockRoom = {
-                    getEncryptionTargetMembers: jest.fn().mockReturnValue(
-                        [{ userId: "@alice:home.server" }],
-                    ),
+                    getEncryptionTargetMembers: jest.fn().mockReturnValue([{ userId: "@alice:home.server" }]),
                     getBlacklistUnverifiedDevices: jest.fn().mockReturnValue(false),
                 } as unknown as Room;
             });
@@ -394,7 +400,9 @@ describe("MegolmDecryption", function() {
                 expect(mockRoom.getEncryptionTargetMembers).toHaveBeenCalled();
 
                 expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 10000,
+                    [["@alice:home.server", "aliceDevice"]],
+                    "signed_curve25519",
+                    10000,
                 );
             });
 
@@ -414,7 +422,7 @@ describe("MegolmDecryption", function() {
                 expect(prepareNewSessionSpy).toHaveBeenCalledTimes(1);
             });
 
-            it("re-uses sessions for sequential messages", async function() {
+            it("re-uses sessions for sequential messages", async function () {
                 const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
                     body: "Some text",
                 });
@@ -422,14 +430,16 @@ describe("MegolmDecryption", function() {
 
                 // this should have claimed a key for alice as it's starting a new session
                 expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
-                );
-                expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(
-                    ['@alice:home.server'], false,
+                    [["@alice:home.server", "aliceDevice"]],
+                    "signed_curve25519",
+                    2000,
                 );
+                expect(mockCrypto.downloadKeys).toHaveBeenCalledWith(["@alice:home.server"], false);
                 expect(mockBaseApis.queueToDevice).toHaveBeenCalled();
                 expect(mockBaseApis.claimOneTimeKeys).toHaveBeenCalledWith(
-                    [['@alice:home.server', 'aliceDevice']], 'signed_curve25519', 2000,
+                    [["@alice:home.server", "aliceDevice"]],
+                    "signed_curve25519",
+                    2000,
                 );
 
                 mockBaseApis.claimOneTimeKeys.mockReset();
@@ -445,7 +455,7 @@ describe("MegolmDecryption", function() {
                 expect(ct2.session_id).toEqual(ct1.session_id);
             });
 
-            it("re-shares keys to devices it's already sent to", async function() {
+            it("re-shares keys to devices it's already sent to", async function () {
                 const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
                     body: "Some text",
                 });
@@ -454,27 +464,27 @@ describe("MegolmDecryption", function() {
                 await megolmEncryption.reshareKeyWithDevice!(
                     olmDevice.deviceCurve25519Key!,
                     ct1.session_id,
-                    '@alice:home.server',
+                    "@alice:home.server",
                     aliceDeviceInfo,
                 );
 
                 expect(mockBaseApis.sendToDevice).toHaveBeenCalled();
             });
 
-            it("does not re-share keys to devices whose keys have changed", async function() {
+            it("does not re-share keys to devices whose keys have changed", async function () {
                 const ct1 = await megolmEncryption.encryptMessage(mockRoom, "a.fake.type", {
                     body: "Some text",
                 });
 
-                aliceDeviceInfo.getIdentityKey = jest.fn().mockReturnValue(
-                    'YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWI',
-                );
+                aliceDeviceInfo.getIdentityKey = jest
+                    .fn()
+                    .mockReturnValue("YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWI");
 
                 mockBaseApis.queueToDevice.mockClear();
                 await megolmEncryption.reshareKeyWithDevice!(
                     olmDevice.deviceCurve25519Key!,
                     ct1.session_id,
-                    '@alice:home.server',
+                    "@alice:home.server",
                     aliceDeviceInfo,
                 );
 
@@ -483,33 +493,23 @@ describe("MegolmDecryption", function() {
         });
     });
 
-    it("notifies devices that have been blocked", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient1 = (new TestClient(
-            "@bob:example.com", "bobdevice1",
-        )).client;
-        const bobClient2 = (new TestClient(
-            "@bob:example.com", "bobdevice2",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient1.initCrypto(),
-            bobClient2.initCrypto(),
-        ]);
+    it("notifies devices that have been blocked", async function () {
+        const aliceClient = new TestClient("@alice:example.com", "alicedevice").client;
+        const bobClient1 = new TestClient("@bob:example.com", "bobdevice1").client;
+        const bobClient2 = new TestClient("@bob:example.com", "bobdevice2").client;
+        await Promise.all([aliceClient.initCrypto(), bobClient1.initCrypto(), bobClient2.initCrypto()]);
         const aliceDevice = aliceClient.crypto!.olmDevice;
         const bobDevice1 = bobClient1.crypto!.olmDevice;
         const bobDevice2 = bobClient2.crypto!.olmDevice;
 
         const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
+            algorithm: "m.megolm.v1.aes-sha2",
         };
         const roomId = "!someroom";
         const room = new Room(roomId, aliceClient, "@alice:example.com", {});
 
         const bobMember = new RoomMember(roomId, "@bob:example.com");
-        room.getEncryptionTargetMembers = async function() {
+        room.getEncryptionTargetMembers = async function () {
             return [bobMember];
         };
         room.setBlacklistUnverifiedDevices(true);
@@ -537,10 +537,8 @@ describe("MegolmDecryption", function() {
             },
         };
 
-        aliceClient.crypto!.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto!.deviceList.downloadKeys = async function(userIds) {
+        aliceClient.crypto!.deviceList.storeDevicesForUser("@bob:example.com", BOB_DEVICES);
+        aliceClient.crypto!.deviceList.downloadKeys = async function (userIds) {
             // @ts-ignore short-circuiting private method
             return this.getDevicesFromStore(userIds);
         };
@@ -567,20 +565,19 @@ describe("MegolmDecryption", function() {
         delete contentMap["@bob:example.com"].bobdevice2.session_id;
         delete contentMap["@bob:example.com"].bobdevice2["org.matrix.msgid"];
         expect(contentMap).toStrictEqual({
-            '@bob:example.com': {
+            "@bob:example.com": {
                 bobdevice1: {
                     algorithm: "m.megolm.v1.aes-sha2",
                     room_id: roomId,
-                    code: 'm.unverified',
-                    reason:
-                    'The sender has disabled encrypting to unverified devices.',
+                    code: "m.unverified",
+                    reason: "The sender has disabled encrypting to unverified devices.",
                     sender_key: aliceDevice.deviceCurve25519Key,
                 },
                 bobdevice2: {
                     algorithm: "m.megolm.v1.aes-sha2",
                     room_id: roomId,
-                    code: 'm.blacklisted',
-                    reason: 'The sender has blocked you.',
+                    code: "m.blacklisted",
+                    reason: "The sender has blocked you.",
                     sender_key: aliceDevice.deviceCurve25519Key,
                 },
             },
@@ -591,27 +588,20 @@ describe("MegolmDecryption", function() {
         bobClient2.stopClient();
     });
 
-    it("does not block unverified devices when sending verification events", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
+    it("does not block unverified devices when sending verification events", async function () {
+        const aliceClient = new TestClient("@alice:example.com", "alicedevice").client;
+        const bobClient = new TestClient("@bob:example.com", "bobdevice").client;
+        await Promise.all([aliceClient.initCrypto(), bobClient.initCrypto()]);
         const bobDevice = bobClient.crypto!.olmDevice;
 
         const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
+            algorithm: "m.megolm.v1.aes-sha2",
         };
         const roomId = "!someroom";
         const room = new Room(roomId, aliceClient, "@alice:example.com", {});
 
         const bobMember = new RoomMember(roomId, "@bob:example.com");
-        room.getEncryptionTargetMembers = async function() {
+        room.getEncryptionTargetMembers = async function () {
             return [bobMember];
         };
         room.setBlacklistUnverifiedDevices(true);
@@ -630,17 +620,15 @@ describe("MegolmDecryption", function() {
             },
         };
 
-        aliceClient.crypto!.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto!.deviceList.downloadKeys = async function(userIds) {
+        aliceClient.crypto!.deviceList.storeDevicesForUser("@bob:example.com", BOB_DEVICES);
+        aliceClient.crypto!.deviceList.downloadKeys = async function (userIds) {
             // @ts-ignore private
             return this.getDevicesFromStore(userIds);
         };
 
         await bobDevice.generateOneTimeKeys(1);
         const oneTimeKeys = await bobDevice.getOneTimeKeys();
-        const signedOneTimeKeys: Record<string, { key: string, signatures: object }> = {};
+        const signedOneTimeKeys: Record<string, { key: string; signatures: object }> = {};
         for (const keyId in oneTimeKeys.curve25519) {
             if (oneTimeKeys.curve25519.hasOwnProperty(keyId)) {
                 const k = {
@@ -655,7 +643,7 @@ describe("MegolmDecryption", function() {
 
         aliceClient.claimOneTimeKeys = jest.fn().mockResolvedValue({
             one_time_keys: {
-                '@bob:example.com': {
+                "@bob:example.com": {
                     bobdevice: signedOneTimeKeys,
                 },
             },
@@ -685,22 +673,15 @@ describe("MegolmDecryption", function() {
         bobClient.stopClient();
     });
 
-    it("notifies devices when unable to create olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
+    it("notifies devices when unable to create olm session", async function () {
+        const aliceClient = new TestClient("@alice:example.com", "alicedevice").client;
+        const bobClient = new TestClient("@bob:example.com", "bobdevice").client;
+        await Promise.all([aliceClient.initCrypto(), bobClient.initCrypto()]);
         const aliceDevice = aliceClient.crypto!.olmDevice;
         const bobDevice = bobClient.crypto!.olmDevice;
 
         const encryptionCfg = {
-            "algorithm": "m.megolm.v1.aes-sha2",
+            algorithm: "m.megolm.v1.aes-sha2",
         };
         const roomId = "!someroom";
         const aliceRoom = new Room(roomId, aliceClient, "@alice:example.com", {});
@@ -734,10 +715,8 @@ describe("MegolmDecryption", function() {
             },
         };
 
-        aliceClient.crypto!.deviceList.storeDevicesForUser(
-            "@bob:example.com", BOB_DEVICES,
-        );
-        aliceClient.crypto!.deviceList.downloadKeys = async function(userIds) {
+        aliceClient.crypto!.deviceList.storeDevicesForUser("@bob:example.com", BOB_DEVICES);
+        aliceClient.crypto!.deviceList.downloadKeys = async function (userIds) {
             // @ts-ignore private
             return this.getDevicesFromStore(userIds);
         };
@@ -764,11 +743,11 @@ describe("MegolmDecryption", function() {
         expect(msgtype).toMatch(/^(org.matrix|m).room_key.withheld$/);
         delete contentMap["@bob:example.com"]["bobdevice"]["org.matrix.msgid"];
         expect(contentMap).toStrictEqual({
-            '@bob:example.com': {
+            "@bob:example.com": {
                 bobdevice: {
                     algorithm: "m.megolm.v1.aes-sha2",
-                    code: 'm.no_olm',
-                    reason: 'Unable to establish a secure channel.',
+                    code: "m.no_olm",
+                    reason: "Unable to establish a secure channel.",
                     sender_key: aliceDevice.deviceCurve25519Key,
                 },
             },
@@ -778,17 +757,10 @@ describe("MegolmDecryption", function() {
         bobClient.stopClient();
     });
 
-    it("throws an error describing why it doesn't have a key", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
+    it("throws an error describing why it doesn't have a key", async function () {
+        const aliceClient = new TestClient("@alice:example.com", "alicedevice").client;
+        const bobClient = new TestClient("@bob:example.com", "bobdevice").client;
+        await Promise.all([aliceClient.initCrypto(), bobClient.initCrypto()]);
         const bobDevice = bobClient.crypto!.olmDevice;
 
         const aliceEventEmitter = new TypedEventEmitter<ClientEvent.ToDeviceEvent, any>();
@@ -796,74 +768,81 @@ describe("MegolmDecryption", function() {
 
         const roomId = "!someroom";
 
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id1",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.blacklisted",
-                reason: "You have been blocked",
-            },
-        }));
-
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id1",
-            },
-        }))).rejects.toThrow("The sender has blocked you.");
+        aliceEventEmitter.emit(
+            ClientEvent.ToDeviceEvent,
+            new MatrixEvent({
+                type: "m.room_key.withheld",
+                sender: "@bob:example.com",
+                content: {
+                    algorithm: "m.megolm.v1.aes-sha2",
+                    room_id: roomId,
+                    session_id: "session_id1",
+                    sender_key: bobDevice.deviceCurve25519Key,
+                    code: "m.blacklisted",
+                    reason: "You have been blocked",
+                },
+            }),
+        );
 
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id2",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.blacklisted",
-                reason: "You have been blocked",
-            },
-        }));
+        await expect(
+            aliceClient.crypto!.decryptEvent(
+                new MatrixEvent({
+                    type: "m.room.encrypted",
+                    sender: "@bob:example.com",
+                    event_id: "$event",
+                    room_id: roomId,
+                    content: {
+                        algorithm: "m.megolm.v1.aes-sha2",
+                        ciphertext: "blablabla",
+                        device_id: "bobdevice",
+                        sender_key: bobDevice.deviceCurve25519Key,
+                        session_id: "session_id1",
+                    },
+                }),
+            ),
+        ).rejects.toThrow("The sender has blocked you.");
+
+        aliceEventEmitter.emit(
+            ClientEvent.ToDeviceEvent,
+            new MatrixEvent({
+                type: "m.room_key.withheld",
+                sender: "@bob:example.com",
+                content: {
+                    algorithm: "m.megolm.v1.aes-sha2",
+                    room_id: roomId,
+                    session_id: "session_id2",
+                    sender_key: bobDevice.deviceCurve25519Key,
+                    code: "m.blacklisted",
+                    reason: "You have been blocked",
+                },
+            }),
+        );
 
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id2",
-            },
-        }))).rejects.toThrow("The sender has blocked you.");
+        await expect(
+            aliceClient.crypto!.decryptEvent(
+                new MatrixEvent({
+                    type: "m.room.encrypted",
+                    sender: "@bob:example.com",
+                    event_id: "$event",
+                    room_id: roomId,
+                    content: {
+                        algorithm: "m.megolm.v1.aes-sha2",
+                        ciphertext: "blablabla",
+                        device_id: "bobdevice",
+                        sender_key: bobDevice.deviceCurve25519Key,
+                        session_id: "session_id2",
+                    },
+                }),
+            ),
+        ).rejects.toThrow("The sender has blocked you.");
         aliceClient.stopClient();
         bobClient.stopClient();
     });
 
-    it("throws an error describing the lack of an olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
+    it("throws an error describing the lack of an olm session", async function () {
+        const aliceClient = new TestClient("@alice:example.com", "alicedevice").client;
+        const bobClient = new TestClient("@bob:example.com", "bobdevice").client;
+        await Promise.all([aliceClient.initCrypto(), bobClient.initCrypto()]);
 
         const aliceEventEmitter = new TypedEventEmitter<ClientEvent.ToDeviceEvent, any>();
         aliceClient.crypto!.registerEventHandlers(aliceEventEmitter);
@@ -875,84 +854,91 @@ describe("MegolmDecryption", function() {
 
         const now = Date.now();
 
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id1",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.no_olm",
-                reason: "Unable to establish a secure channel.",
-            },
-        }));
+        aliceEventEmitter.emit(
+            ClientEvent.ToDeviceEvent,
+            new MatrixEvent({
+                type: "m.room_key.withheld",
+                sender: "@bob:example.com",
+                content: {
+                    algorithm: "m.megolm.v1.aes-sha2",
+                    room_id: roomId,
+                    session_id: "session_id1",
+                    sender_key: bobDevice.deviceCurve25519Key,
+                    code: "m.no_olm",
+                    reason: "Unable to establish a secure channel.",
+                },
+            }),
+        );
 
         await new Promise((resolve) => {
             setTimeout(resolve, 100);
         });
 
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id1",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The sender was unable to establish a secure channel.");
-
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room_key.withheld",
-            sender: "@bob:example.com",
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                room_id: roomId,
-                session_id: "session_id2",
-                sender_key: bobDevice.deviceCurve25519Key,
-                code: "m.no_olm",
-                reason: "Unable to establish a secure channel.",
-            },
-        }));
+        await expect(
+            aliceClient.crypto!.decryptEvent(
+                new MatrixEvent({
+                    type: "m.room.encrypted",
+                    sender: "@bob:example.com",
+                    event_id: "$event",
+                    room_id: roomId,
+                    content: {
+                        algorithm: "m.megolm.v1.aes-sha2",
+                        ciphertext: "blablabla",
+                        device_id: "bobdevice",
+                        sender_key: bobDevice.deviceCurve25519Key,
+                        session_id: "session_id1",
+                    },
+                    origin_server_ts: now,
+                }),
+            ),
+        ).rejects.toThrow("The sender was unable to establish a secure channel.");
+
+        aliceEventEmitter.emit(
+            ClientEvent.ToDeviceEvent,
+            new MatrixEvent({
+                type: "m.room_key.withheld",
+                sender: "@bob:example.com",
+                content: {
+                    algorithm: "m.megolm.v1.aes-sha2",
+                    room_id: roomId,
+                    session_id: "session_id2",
+                    sender_key: bobDevice.deviceCurve25519Key,
+                    code: "m.no_olm",
+                    reason: "Unable to establish a secure channel.",
+                },
+            }),
+        );
 
         await new Promise((resolve) => {
             setTimeout(resolve, 100);
         });
 
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id2",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The sender was unable to establish a secure channel.");
+        await expect(
+            aliceClient.crypto!.decryptEvent(
+                new MatrixEvent({
+                    type: "m.room.encrypted",
+                    sender: "@bob:example.com",
+                    event_id: "$event",
+                    room_id: roomId,
+                    content: {
+                        algorithm: "m.megolm.v1.aes-sha2",
+                        ciphertext: "blablabla",
+                        device_id: "bobdevice",
+                        sender_key: bobDevice.deviceCurve25519Key,
+                        session_id: "session_id2",
+                    },
+                    origin_server_ts: now,
+                }),
+            ),
+        ).rejects.toThrow("The sender was unable to establish a secure channel.");
         aliceClient.stopClient();
         bobClient.stopClient();
     });
 
-    it("throws an error to indicate a wedged olm session", async function() {
-        const aliceClient = (new TestClient(
-            "@alice:example.com", "alicedevice",
-        )).client;
-        const bobClient = (new TestClient(
-            "@bob:example.com", "bobdevice",
-        )).client;
-        await Promise.all([
-            aliceClient.initCrypto(),
-            bobClient.initCrypto(),
-        ]);
+    it("throws an error to indicate a wedged olm session", async function () {
+        const aliceClient = new TestClient("@alice:example.com", "alicedevice").client;
+        const bobClient = new TestClient("@bob:example.com", "bobdevice").client;
+        await Promise.all([aliceClient.initCrypto(), bobClient.initCrypto()]);
         const aliceEventEmitter = new TypedEventEmitter<ClientEvent.ToDeviceEvent, any>();
         aliceClient.crypto!.registerEventHandlers(aliceEventEmitter);
 
@@ -964,35 +950,42 @@ describe("MegolmDecryption", function() {
         const now = Date.now();
 
         // pretend we got an event that we can't decrypt
-        aliceEventEmitter.emit(ClientEvent.ToDeviceEvent, new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            content: {
-                msgtype: "m.bad.encrypted",
-                algorithm: "m.megolm.v1.aes-sha2",
-                session_id: "session_id",
-                sender_key: bobDevice.deviceCurve25519Key,
-            },
-        }));
+        aliceEventEmitter.emit(
+            ClientEvent.ToDeviceEvent,
+            new MatrixEvent({
+                type: "m.room.encrypted",
+                sender: "@bob:example.com",
+                content: {
+                    msgtype: "m.bad.encrypted",
+                    algorithm: "m.megolm.v1.aes-sha2",
+                    session_id: "session_id",
+                    sender_key: bobDevice.deviceCurve25519Key,
+                },
+            }),
+        );
 
         await new Promise((resolve) => {
             setTimeout(resolve, 100);
         });
 
-        await expect(aliceClient.crypto!.decryptEvent(new MatrixEvent({
-            type: "m.room.encrypted",
-            sender: "@bob:example.com",
-            event_id: "$event",
-            room_id: roomId,
-            content: {
-                algorithm: "m.megolm.v1.aes-sha2",
-                ciphertext: "blablabla",
-                device_id: "bobdevice",
-                sender_key: bobDevice.deviceCurve25519Key,
-                session_id: "session_id",
-            },
-            origin_server_ts: now,
-        }))).rejects.toThrow("The secure channel with the sender was corrupted.");
+        await expect(
+            aliceClient.crypto!.decryptEvent(
+                new MatrixEvent({
+                    type: "m.room.encrypted",
+                    sender: "@bob:example.com",
+                    event_id: "$event",
+                    room_id: roomId,
+                    content: {
+                        algorithm: "m.megolm.v1.aes-sha2",
+                        ciphertext: "blablabla",
+                        device_id: "bobdevice",
+                        sender_key: bobDevice.deviceCurve25519Key,
+                        session_id: "session_id",
+                    },
+                    origin_server_ts: now,
+                }),
+            ),
+        ).rejects.toThrow("The secure channel with the sender was corrupted.");
         aliceClient.stopClient();
         bobClient.stopClient();
     });
diff --git a/spec/unit/crypto/algorithms/olm.spec.ts b/spec/unit/crypto/algorithms/olm.spec.ts
index 932fb8016b4..6099ccceb6c 100644
--- a/spec/unit/crypto/algorithms/olm.spec.ts
+++ b/spec/unit/crypto/algorithms/olm.spec.ts
@@ -15,15 +15,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MockedObject } from 'jest-mock';
+import { MockedObject } from "jest-mock";
 
-import '../../../olm-loader';
+import "../../../olm-loader";
 import { MemoryCryptoStore } from "../../../../src/crypto/store/memory-crypto-store";
 import { logger } from "../../../../src/logger";
 import { OlmDevice } from "../../../../src/crypto/OlmDevice";
 import * as olmlib from "../../../../src/crypto/olmlib";
 import { DeviceInfo } from "../../../../src/crypto/deviceinfo";
-import { MatrixClient } from '../../../../src';
+import { MatrixClient } from "../../../../src";
 
 function makeOlmDevice() {
     const cryptoStore = new MemoryCryptoStore();
@@ -34,7 +34,7 @@ function makeOlmDevice() {
 async function setupSession(initiator: OlmDevice, opponent: OlmDevice) {
     await opponent.generateOneTimeKeys(1);
     const keys = await opponent.getOneTimeKeys();
-    const firstKey = Object.values(keys['curve25519'])[0];
+    const firstKey = Object.values(keys["curve25519"])[0];
 
     const sid = await initiator.createOutboundSession(opponent.deviceCurve25519Key!, firstKey);
     return sid;
@@ -46,62 +46,57 @@ function alwaysSucceed<T>(promise: Promise<T>): Promise<T | void> {
     return promise.catch(() => {});
 }
 
-describe("OlmDevice", function() {
+describe("OlmDevice", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm unit tests: libolm not present');
+        logger.warn("Not running megolm unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
     let aliceOlmDevice: OlmDevice;
     let bobOlmDevice: OlmDevice;
 
-    beforeEach(async function() {
+    beforeEach(async function () {
         aliceOlmDevice = makeOlmDevice();
         bobOlmDevice = makeOlmDevice();
         await aliceOlmDevice.init();
         await bobOlmDevice.init();
     });
 
-    describe('olm', function() {
-        it("can decrypt messages", async function() {
+    describe("olm", function () {
+        it("can decrypt messages", async function () {
             const sid = await setupSession(aliceOlmDevice, bobOlmDevice);
 
-            const ciphertext = await aliceOlmDevice.encryptMessage(
+            const ciphertext = (await aliceOlmDevice.encryptMessage(
                 bobOlmDevice.deviceCurve25519Key!,
                 sid,
                 "The olm or proteus is an aquatic salamander in the family Proteidae",
-            ) as any; // OlmDevice.encryptMessage has incorrect return type
+            )) as any; // OlmDevice.encryptMessage has incorrect return type
 
             const result = await bobOlmDevice.createInboundSession(
                 aliceOlmDevice.deviceCurve25519Key!,
                 ciphertext.type,
                 ciphertext.body,
             );
-            expect(result.payload).toEqual(
-                "The olm or proteus is an aquatic salamander in the family Proteidae",
-            );
+            expect(result.payload).toEqual("The olm or proteus is an aquatic salamander in the family Proteidae");
         });
 
-        it('exports picked account and olm sessions', async function() {
+        it("exports picked account and olm sessions", async function () {
             const sessionId = await setupSession(aliceOlmDevice, bobOlmDevice);
 
             const exported = await bobOlmDevice.export();
             // At this moment only Alice (the “initiator” in setupSession) has a session
             expect(exported.sessions).toEqual([]);
 
-            const MESSAGE = (
-                "The olm or proteus is an aquatic salamander"
-                + " in the family Proteidae"
-            );
-            const ciphertext = await aliceOlmDevice.encryptMessage(
+            const MESSAGE = "The olm or proteus is an aquatic salamander" + " in the family Proteidae";
+            const ciphertext = (await aliceOlmDevice.encryptMessage(
                 bobOlmDevice.deviceCurve25519Key!,
                 sessionId,
                 MESSAGE,
-            ) as any; // OlmDevice.encryptMessage has incorrect return type
+            )) as any; // OlmDevice.encryptMessage has incorrect return type
 
             const bobRecreatedOlmDevice = makeOlmDevice();
             bobRecreatedOlmDevice.init({ fromExportedDevice: exported });
@@ -117,15 +112,12 @@ describe("OlmDevice", function() {
             // this time we expect Bob to have a session to export
             expect(exportedAgain.sessions).toHaveLength(1);
 
-            const MESSAGE_2 = (
-                "In contrast to most amphibians,"
-                + " the olm is entirely aquatic"
-            );
-            const ciphertext2 = await aliceOlmDevice.encryptMessage(
+            const MESSAGE_2 = "In contrast to most amphibians," + " the olm is entirely aquatic";
+            const ciphertext2 = (await aliceOlmDevice.encryptMessage(
                 bobOlmDevice.deviceCurve25519Key!,
                 sessionId,
                 MESSAGE_2,
-            ) as any; // OlmDevice.encryptMessage has incorrect return type
+            )) as any; // OlmDevice.encryptMessage has incorrect return type
 
             const bobRecreatedAgainOlmDevice = makeOlmDevice();
             bobRecreatedAgainOlmDevice.init({ fromExportedDevice: exportedAgain });
@@ -140,7 +132,7 @@ describe("OlmDevice", function() {
             expect(decrypted2).toEqual(MESSAGE_2);
         });
 
-        it("creates only one session at a time", async function() {
+        it("creates only one session at a time", async function () {
             // if we call ensureOlmSessionsForDevices multiple times, it should
             // only try to create one session at a time, even if the server is
             // slow
@@ -156,22 +148,21 @@ describe("OlmDevice", function() {
             } as unknown as MockedObject<MatrixClient>;
             const devicesByUser = {
                 "@bob:example.com": [
-                    DeviceInfo.fromStorage({
-                        keys: {
-                            "curve25519:ABCDEFG": "akey",
+                    DeviceInfo.fromStorage(
+                        {
+                            keys: {
+                                "curve25519:ABCDEFG": "akey",
+                            },
                         },
-                    }, "ABCDEFG"),
+                        "ABCDEFG",
+                    ),
                 ],
             };
 
             // start two tasks that try to ensure that there's an olm session
             const promises = Promise.all([
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                    aliceOlmDevice, baseApis, devicesByUser,
-                )),
-                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                    aliceOlmDevice, baseApis, devicesByUser,
-                )),
+                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUser)),
+                alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUser)),
             ]);
 
             await new Promise((resolve) => {
@@ -191,7 +182,7 @@ describe("OlmDevice", function() {
             expect(count).toBe(2);
         });
 
-        it("avoids deadlocks when two tasks are ensuring the same devices", async function() {
+        it("avoids deadlocks when two tasks are ensuring the same devices", async function () {
             // This test checks whether `ensureOlmSessionsForDevices` properly
             // handles multiple tasks in flight ensuring some set of devices in
             // common without deadlocks.
@@ -207,54 +198,47 @@ describe("OlmDevice", function() {
                 },
             } as unknown as MockedObject<MatrixClient>;
 
-            const deviceBobA = DeviceInfo.fromStorage({
-                keys: {
-                    "curve25519:BOB-A": "akey",
+            const deviceBobA = DeviceInfo.fromStorage(
+                {
+                    keys: {
+                        "curve25519:BOB-A": "akey",
+                    },
                 },
-            }, "BOB-A");
-            const deviceBobB = DeviceInfo.fromStorage({
-                keys: {
-                    "curve25519:BOB-B": "bkey",
+                "BOB-A",
+            );
+            const deviceBobB = DeviceInfo.fromStorage(
+                {
+                    keys: {
+                        "curve25519:BOB-B": "bkey",
+                    },
                 },
-            }, "BOB-B");
+                "BOB-B",
+            );
 
             // There's no required ordering of devices per user, so here we
             // create two different orderings so that each task reserves a
             // device the other task needs before continuing.
             const devicesByUserAB = {
-                "@bob:example.com": [
-                    deviceBobA,
-                    deviceBobB,
-                ],
+                "@bob:example.com": [deviceBobA, deviceBobB],
             };
             const devicesByUserBA = {
-                "@bob:example.com": [
-                    deviceBobB,
-                    deviceBobA,
-                ],
+                "@bob:example.com": [deviceBobB, deviceBobA],
             };
 
-            const task1 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                aliceOlmDevice, baseApis, devicesByUserAB,
-            ));
+            const task1 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUserAB));
 
             // After a single tick through the first task, it should have
             // claimed ownership of all devices to avoid deadlocking others.
             expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
 
-            const task2 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(
-                aliceOlmDevice, baseApis, devicesByUserBA,
-            ));
+            const task2 = alwaysSucceed(olmlib.ensureOlmSessionsForDevices(aliceOlmDevice, baseApis, devicesByUserBA));
 
             // The second task should not have changed the ownership count, as
             // it's waiting on the first task.
             expect(Object.keys(aliceOlmDevice.sessionsInProgress).length).toBe(2);
 
             // Track the tasks, but don't await them yet.
-            const promises = Promise.all([
-                task1,
-                task2,
-            ]);
+            const promises = Promise.all([task1, task2]);
 
             await new Promise((resolve) => {
                 setTimeout(resolve, 200);
diff --git a/spec/unit/crypto/backup.spec.ts b/spec/unit/crypto/backup.spec.ts
index bd1c71f02a3..4c1be8672bd 100644
--- a/spec/unit/crypto/backup.spec.ts
+++ b/spec/unit/crypto/backup.spec.ts
@@ -15,7 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
+import "../../olm-loader";
 import { logger } from "../../../src/logger";
 import * as olmlib from "../../../src/crypto/olmlib";
 import { MatrixClient } from "../../../src/client";
@@ -28,30 +28,31 @@ import { Crypto } from "../../../src/crypto";
 import { resetCrossSigningKeys } from "./crypto-utils";
 import { BackupManager } from "../../../src/crypto/backup";
 import { StubStore } from "../../../src/store/stub";
-import { IndexedDBCryptoStore, MatrixScheduler } from '../../../src';
+import { IndexedDBCryptoStore, MatrixScheduler } from "../../../src";
 import { CryptoStore } from "../../../src/crypto/store/base";
 import { MegolmDecryption as MegolmDecryptionClass } from "../../../src/crypto/algorithms/megolm";
 import { IKeyBackupInfo } from "../../../src/crypto/keybackup";
 
 const Olm = global.Olm;
 
-const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get('m.megolm.v1.aes-sha2')!;
+const MegolmDecryption = algorithms.DECRYPTION_CLASSES.get("m.megolm.v1.aes-sha2")!;
 
-const ROOM_ID = '!ROOM:ID';
+const ROOM_ID = "!ROOM:ID";
 
-const SESSION_ID = 'o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc';
+const SESSION_ID = "o+21hSjP+mgEmcfdslPsQdvzWnkdt0Wyo00Kp++R8Kc";
 const ENCRYPTED_EVENT = new MatrixEvent({
-    type: 'm.room.encrypted',
-    room_id: '!ROOM:ID',
+    type: "m.room.encrypted",
+    room_id: "!ROOM:ID",
     content: {
-        algorithm: 'm.megolm.v1.aes-sha2',
-        sender_key: 'SENDER_CURVE25519',
+        algorithm: "m.megolm.v1.aes-sha2",
+        sender_key: "SENDER_CURVE25519",
         session_id: SESSION_ID,
-        ciphertext: 'AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N'
-            + 'CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl'
-            + 'mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs',
+        ciphertext:
+            "AwgAEjD+VwXZ7PoGPRS/H4kwpAsMp/g+WPvJVtPEKE8fmM9IcT/N" +
+            "CiwPb8PehecDKP0cjm1XO88k6Bw3D17aGiBHr5iBoP7oSw8CXULXAMTkBl" +
+            "mkufRQq2+d0Giy1s4/Cg5n13jSVrSb2q7VTSv1ZHAFjUCsLSfR0gxqcQs",
     },
-    event_id: '$event1',
+    event_id: "$event1",
     origin_server_ts: 1507753886000,
 });
 
@@ -60,19 +61,20 @@ const CURVE25519_KEY_BACKUP_DATA = {
     forwarded_count: 0,
     is_verified: false,
     session_data: {
-        ciphertext: '2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw'
-            + '6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ'
-            + 'Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9'
-            + 'SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy'
-            + 'Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF'
-            + 'ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV'
-            + '4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv'
-            + 'C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe'
-            + 'Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf'
-            + 'QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy'
-            + 'iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg',
-        mac: '5lxYBHQU80M',
-        ephemeral: '/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14',
+        ciphertext:
+            "2z2M7CZ+azAiTHN1oFzZ3smAFFt+LEOYY6h3QO3XXGdw" +
+            "6YpNn/gpHDO6I/rgj1zNd4FoTmzcQgvKdU8kN20u5BWRHxaHTZ" +
+            "Slne5RxE6vUdREsBgZePglBNyG0AogR/PVdcrv/v18Y6rLM5O9" +
+            "SELmwbV63uV9Kuu/misMxoqbuqEdG7uujyaEKtjlQsJ5MGPQOy" +
+            "Syw7XrnesSwF6XWRMxcPGRV0xZr3s9PI350Wve3EncjRgJ9IGF" +
+            "ru1bcptMqfXgPZkOyGvrphHoFfoK7nY3xMEHUiaTRfRIjq8HNV" +
+            "4o8QY1qmWGnxNBQgOlL8MZlykjg3ULmQ3DtFfQPj/YYGS3jzxv" +
+            "C+EBjaafmsg+52CTeK3Rswu72PX450BnSZ1i3If4xWAUKvjTpe" +
+            "Ug5aDLqttOv1pITolTJDw5W/SD+b5rjEKg1CFCHGEGE9wwV3Nf" +
+            "QHVCQL+dfpd7Or0poy4dqKMAi3g0o3Tg7edIF8d5rREmxaALPy" +
+            "iie8PHD8mj/5Y0GLqrac4CD6+Mop7eUTzVovprjg",
+        mac: "5lxYBHQU80M",
+        ephemeral: "/Bn0A4UMFwJaDDvh0aEk1XZj3k1IfgCxgFY9P9a0b14",
     },
 };
 
@@ -81,23 +83,24 @@ const AES256_KEY_BACKUP_DATA = {
     forwarded_count: 0,
     is_verified: false,
     session_data: {
-        iv: 'b3Jqqvm5S9QdmXrzssspLQ',
-        ciphertext: 'GOOASO3E9ThogkG0zMjEduGLM3u9jHZTkS7AvNNbNj3q1znwk4OlaVKXce'
-            + '7ynofiiYIiS865VlOqrKEEXv96XzRyUpgn68e3WsicwYl96EtjIEh/iY003PG2Qd'
-            + 'EluT899Ax7PydpUHxEktbWckMppYomUR5q8x1KI1SsOQIiJaIGThmIMPANRCFiK0'
-            + 'WQj+q+dnhzx4lt9AFqU5bKov8qKnw2qGYP7/+6RmJ0Kpvs8tG6lrcNDEHtFc2r0r'
-            + 'KKubDypo0Vc8EWSwsAHdKa36ewRavpreOuE8Z9RLfY0QIR1ecXrMqW0CdGFr7H3P'
-            + 'vcjF8sjwvQAavzxEKT1WMGizSMLeKWo2mgZ5cKnwV5HGUAw596JQvKs9laG2U89K'
-            + 'YrT0sH30vi62HKzcBLcDkWkUSNYPz7UiZ1MM0L380UA+1ZOXSOmtBA9xxzzbc8Xd'
-            + 'fRimVgklGdxrxjzuNLYhL2BvVH4oPWonD9j0bvRwE6XkimdbGQA8HB7UmXXjE8WA'
-            + 'RgaDHkfzoA3g3aeQ',
-        mac: 'uR988UYgGL99jrvLLPX3V1ows+UYbktTmMxPAo2kxnU',
+        iv: "b3Jqqvm5S9QdmXrzssspLQ",
+        ciphertext:
+            "GOOASO3E9ThogkG0zMjEduGLM3u9jHZTkS7AvNNbNj3q1znwk4OlaVKXce" +
+            "7ynofiiYIiS865VlOqrKEEXv96XzRyUpgn68e3WsicwYl96EtjIEh/iY003PG2Qd" +
+            "EluT899Ax7PydpUHxEktbWckMppYomUR5q8x1KI1SsOQIiJaIGThmIMPANRCFiK0" +
+            "WQj+q+dnhzx4lt9AFqU5bKov8qKnw2qGYP7/+6RmJ0Kpvs8tG6lrcNDEHtFc2r0r" +
+            "KKubDypo0Vc8EWSwsAHdKa36ewRavpreOuE8Z9RLfY0QIR1ecXrMqW0CdGFr7H3P" +
+            "vcjF8sjwvQAavzxEKT1WMGizSMLeKWo2mgZ5cKnwV5HGUAw596JQvKs9laG2U89K" +
+            "YrT0sH30vi62HKzcBLcDkWkUSNYPz7UiZ1MM0L380UA+1ZOXSOmtBA9xxzzbc8Xd" +
+            "fRimVgklGdxrxjzuNLYhL2BvVH4oPWonD9j0bvRwE6XkimdbGQA8HB7UmXXjE8WA" +
+            "RgaDHkfzoA3g3aeQ",
+        mac: "uR988UYgGL99jrvLLPX3V1ows+UYbktTmMxPAo2kxnU",
     },
 };
 
 const CURVE25519_BACKUP_INFO = {
     algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-    version: '1',
+    version: "1",
     auth_data: {
         public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
     },
@@ -105,7 +108,7 @@ const CURVE25519_BACKUP_INFO = {
 
 const AES256_BACKUP_INFO: IKeyBackupInfo = {
     algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-    version: '1',
+    version: "1",
     auth_data: {} as IKeyBackupInfo["auth_data"],
 };
 
@@ -120,15 +123,13 @@ function saveCrossSigningKeys(k: Record<string, Uint8Array>) {
 }
 
 function makeTestScheduler(): MatrixScheduler {
-    return ([
-        "getQueueForEvent",
-        "queueEvent",
-        "removeEventFromQueue",
-        "setProcessFunction",
-    ] as const).reduce((r, k) => {
-        r[k] = jest.fn();
-        return r;
-    }, {} as MatrixScheduler);
+    return (["getQueueForEvent", "queueEvent", "removeEventFromQueue", "setProcessFunction"] as const).reduce(
+        (r, k) => {
+            r[k] = jest.fn();
+            return r;
+        },
+        {} as MatrixScheduler,
+    );
 }
 
 function makeTestClient(cryptoStore: CryptoStore) {
@@ -153,13 +154,13 @@ function makeTestClient(cryptoStore: CryptoStore) {
     return client;
 }
 
-describe("MegolmBackup", function() {
+describe("MegolmBackup", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn("Not running megolm backup unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
@@ -168,8 +169,8 @@ describe("MegolmBackup", function() {
     let mockCrypto: Crypto;
     let cryptoStore: CryptoStore;
     let megolmDecryption: MegolmDecryptionClass;
-    beforeEach(async function() {
-        mockCrypto = testUtils.mock(Crypto, 'Crypto');
+    beforeEach(async function () {
+        mockCrypto = testUtils.mock(Crypto, "Crypto");
         // @ts-ignore making mock
         mockCrypto.backupManager = testUtils.mock(BackupManager, "BackupManager");
         mockCrypto.backupManager.backupInfo = CURVE25519_BACKUP_INFO;
@@ -181,18 +182,17 @@ describe("MegolmBackup", function() {
         // we stub out the olm encryption bits
         mockOlmLib = {} as unknown as typeof olmlib;
         mockOlmLib.ensureOlmSessionsForDevices = jest.fn();
-        mockOlmLib.encryptMessageForDevice =
-            jest.fn().mockResolvedValue(undefined);
+        mockOlmLib.encryptMessageForDevice = jest.fn().mockResolvedValue(undefined);
     });
 
-    describe("backup", function() {
+    describe("backup", function () {
         let mockBaseApis: MatrixClient;
 
-        beforeEach(function() {
+        beforeEach(function () {
             mockBaseApis = {} as unknown as MatrixClient;
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: mockBaseApis,
@@ -206,23 +206,23 @@ describe("MegolmBackup", function() {
             // ideally we would use lolex, but we have no oportunity
             // to tick the clock between the first try and the retry.
             const realSetTimeout = global.setTimeout;
-            jest.spyOn(global, 'setTimeout').mockImplementation(function(f, n) {
-                return realSetTimeout(f!, n!/100);
+            jest.spyOn(global, "setTimeout").mockImplementation(function (f, n) {
+                return realSetTimeout(f!, n! / 100);
             });
         });
 
-        afterEach(function() {
-            jest.spyOn(global, 'setTimeout').mockRestore();
+        afterEach(function () {
+            jest.spyOn(global, "setTimeout").mockRestore();
         });
 
-        it('automatically calls the key back up', function() {
+        it("automatically calls the key back up", function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
 
             // construct a fake decrypted key event via the use of a mocked
             // 'crypto' implementation.
             const event = new MatrixEvent({
-                type: 'm.room.encrypted',
+                type: "m.room.encrypted",
             });
             event.getWireType = () => "m.room.encrypted";
             event.getWireContent = () => {
@@ -232,9 +232,9 @@ describe("MegolmBackup", function() {
             };
             const decryptedData = {
                 clearEvent: {
-                    type: 'm.room_key',
+                    type: "m.room_key",
                     content: {
-                        algorithm: 'm.megolm.v1.aes-sha2',
+                        algorithm: "m.megolm.v1.aes-sha2",
                         room_id: ROOM_ID,
                         session_id: groupSession.session_id(),
                         session_key: groupSession.session_key(),
@@ -244,24 +244,27 @@ describe("MegolmBackup", function() {
                 claimedEd25519Key: "SENDER_ED25519",
             };
 
-            mockCrypto.decryptEvent = function() {
+            mockCrypto.decryptEvent = function () {
                 return Promise.resolve(decryptedData);
             };
-            mockCrypto.cancelRoomKeyRequest = function() {};
+            mockCrypto.cancelRoomKeyRequest = function () {};
 
             // @ts-ignore readonly field write
             mockCrypto.backupManager = {
                 backupGroupSession: jest.fn(),
             };
 
-            return event.attemptDecryption(mockCrypto).then(() => {
-                return megolmDecryption.onRoomKeyEvent(event);
-            }).then(() => {
-                expect(mockCrypto.backupManager.backupGroupSession).toHaveBeenCalled();
-            });
+            return event
+                .attemptDecryption(mockCrypto)
+                .then(() => {
+                    return megolmDecryption.onRoomKeyEvent(event);
+                })
+                .then(() => {
+                    expect(mockCrypto.backupManager.backupGroupSession).toHaveBeenCalled();
+                });
         });
 
-        it('sends backups to the server (Curve25519 version)', function() {
+        it("sends backups to the server (Curve25519 version)", function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -270,7 +273,7 @@ describe("MegolmBackup", function() {
             const client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
@@ -280,39 +283,36 @@ describe("MegolmBackup", function() {
             // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
-            return client.initCrypto()
+            return client
+                .initCrypto()
                 .then(() => {
-                    return cryptoStore.doTxn(
-                        "readwrite",
-                        [IndexedDBCryptoStore.STORE_SESSIONS],
-                        (txn) => {
-                            cryptoStore.addEndToEndInboundGroupSession(
-                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                                groupSession.session_id(),
-                                {
-                                    forwardingCurve25519KeyChain: undefined!,
-                                    keysClaimed: {
-                                        ed25519: "SENDER_ED25519",
-                                    },
-                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
+                    return cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
+                        cryptoStore.addEndToEndInboundGroupSession(
+                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                            groupSession.session_id(),
+                            {
+                                forwardingCurve25519KeyChain: undefined!,
+                                keysClaimed: {
+                                    ed25519: "SENDER_ED25519",
                                 },
-                                txn);
-                        });
+                                room_id: ROOM_ID,
+                                session: ibGroupSession.pickle(olmDevice.pickleKey),
+                            },
+                            txn,
+                        );
+                    });
                 })
                 .then(async () => {
                     await client.enableKeyBackup({
                         algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                        version: '1',
+                        version: "1",
                         auth_data: {
                             public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
                         },
                     });
                     let numCalls = 0;
                     return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function(
-                            method, path, queryParams, data, opts,
-                        ): any {
+                        client.http.authedRequest = function (method, path, queryParams, data, opts): any {
                             ++numCalls;
                             expect(numCalls).toBeLessThanOrEqual(1);
                             if (numCalls >= 2) {
@@ -322,7 +322,7 @@ describe("MegolmBackup", function() {
                             }
                             expect(method).toBe("PUT");
                             expect(path).toBe("/room_keys/keys");
-                            expect(queryParams?.version).toBe('1');
+                            expect(queryParams?.version).toBe("1");
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                                 groupSession.session_id(),
@@ -341,7 +341,7 @@ describe("MegolmBackup", function() {
                 });
         });
 
-        it('sends backups to the server (AES-256 version)', function() {
+        it("sends backups to the server (AES-256 version)", function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -350,7 +350,7 @@ describe("MegolmBackup", function() {
             const client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
@@ -360,33 +360,32 @@ describe("MegolmBackup", function() {
             // @ts-ignore private field access
             megolmDecryption.olmlib = mockOlmLib;
 
-            return client.initCrypto()
+            return client
+                .initCrypto()
                 .then(() => {
                     return client.crypto!.storeSessionBackupPrivateKey(new Uint8Array(32));
                 })
                 .then(() => {
-                    return cryptoStore.doTxn(
-                        "readwrite",
-                        [IndexedDBCryptoStore.STORE_SESSIONS],
-                        (txn) => {
-                            cryptoStore.addEndToEndInboundGroupSession(
-                                "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                                groupSession.session_id(),
-                                {
-                                    forwardingCurve25519KeyChain: undefined!,
-                                    keysClaimed: {
-                                        ed25519: "SENDER_ED25519",
-                                    },
-                                    room_id: ROOM_ID,
-                                    session: ibGroupSession.pickle(olmDevice.pickleKey),
+                    return cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
+                        cryptoStore.addEndToEndInboundGroupSession(
+                            "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                            groupSession.session_id(),
+                            {
+                                forwardingCurve25519KeyChain: undefined!,
+                                keysClaimed: {
+                                    ed25519: "SENDER_ED25519",
                                 },
-                                txn);
-                        });
+                                room_id: ROOM_ID,
+                                session: ibGroupSession.pickle(olmDevice.pickleKey),
+                            },
+                            txn,
+                        );
+                    });
                 })
                 .then(async () => {
                     await client.enableKeyBackup({
                         algorithm: "org.matrix.msc3270.v1.aes-hmac-sha2",
-                        version: '1',
+                        version: "1",
                         auth_data: {
                             iv: "PsCAtR7gMc4xBd9YS3A9Ow",
                             mac: "ZSDsTFEZK7QzlauCLMleUcX96GQZZM7UNtk4sripSqQ",
@@ -394,9 +393,7 @@ describe("MegolmBackup", function() {
                     });
                     let numCalls = 0;
                     return new Promise<void>((resolve, reject) => {
-                        client.http.authedRequest = function(
-                            method, path, queryParams, data, opts,
-                        ): any {
+                        client.http.authedRequest = function (method, path, queryParams, data, opts): any {
                             ++numCalls;
                             expect(numCalls).toBeLessThanOrEqual(1);
                             if (numCalls >= 2) {
@@ -406,7 +403,7 @@ describe("MegolmBackup", function() {
                             }
                             expect(method).toBe("PUT");
                             expect(path).toBe("/room_keys/keys");
-                            expect(queryParams?.version).toBe('1');
+                            expect(queryParams?.version).toBe("1");
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
                             expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                                 groupSession.session_id(),
@@ -425,7 +422,7 @@ describe("MegolmBackup", function() {
                 });
         });
 
-        it('signs backups with the cross-signing master key', async function() {
+        it("signs backups with the cross-signing master key", async function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -434,7 +431,7 @@ describe("MegolmBackup", function() {
             const client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
@@ -445,16 +442,18 @@ describe("MegolmBackup", function() {
             megolmDecryption.olmlib = mockOlmLib;
 
             await client.initCrypto();
-            client.uploadDeviceSigningKeys = async function(e) {return {};};
-            client.uploadKeySignatures = async function(e) {return { failures: {} };};
+            client.uploadDeviceSigningKeys = async function (e) {
+                return {};
+            };
+            client.uploadKeySignatures = async function (e) {
+                return { failures: {} };
+            };
             await resetCrossSigningKeys(client);
             let numCalls = 0;
             await Promise.all([
                 new Promise<void>((resolve, reject) => {
                     let backupInfo: Record<string, any> | BodyInit | undefined;
-                    client.http.authedRequest = function(
-                        method, path, queryParams, data, opts,
-                    ): any {
+                    client.http.authedRequest = function (method, path, queryParams, data, opts): any {
                         ++numCalls;
                         expect(numCalls).toBeLessThanOrEqual(2);
                         if (numCalls === 1) {
@@ -463,7 +462,9 @@ describe("MegolmBackup", function() {
                             try {
                                 // make sure auth_data is signed by the master key
                                 olmlib.pkVerify(
-                                    (data as Record<string, any>).auth_data, client.getCrossSigningId()!, "@alice:bar",
+                                    (data as Record<string, any>).auth_data,
+                                    client.getCrossSigningId()!,
+                                    "@alice:bar",
                                 );
                             } catch (e) {
                                 reject(e);
@@ -494,7 +495,7 @@ describe("MegolmBackup", function() {
             client.stopClient();
         });
 
-        it('retries when a backup fails', async function() {
+        it("retries when a backup fails", async function () {
             const groupSession = new Olm.OutboundGroupSession();
             groupSession.create();
             const ibGroupSession = new Olm.InboundGroupSession();
@@ -517,7 +518,7 @@ describe("MegolmBackup", function() {
             client.uploadKeysRequest = jest.fn();
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
@@ -528,27 +529,25 @@ describe("MegolmBackup", function() {
             megolmDecryption.olmlib = mockOlmLib;
 
             await client.initCrypto();
-            await cryptoStore.doTxn(
-                "readwrite",
-                [IndexedDBCryptoStore.STORE_SESSIONS],
-                (txn) => {
-                    cryptoStore.addEndToEndInboundGroupSession(
-                        "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
-                        groupSession.session_id(),
-                        {
-                            forwardingCurve25519KeyChain: undefined!,
-                            keysClaimed: {
-                                ed25519: "SENDER_ED25519",
-                            },
-                            room_id: ROOM_ID,
-                            session: ibGroupSession.pickle(olmDevice.pickleKey),
+            await cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_SESSIONS], (txn) => {
+                cryptoStore.addEndToEndInboundGroupSession(
+                    "F0Q2NmyJNgUVj9DGsb4ZQt3aVxhVcUQhg7+gvW0oyKI",
+                    groupSession.session_id(),
+                    {
+                        forwardingCurve25519KeyChain: undefined!,
+                        keysClaimed: {
+                            ed25519: "SENDER_ED25519",
                         },
-                        txn);
-                });
+                        room_id: ROOM_ID,
+                        session: ibGroupSession.pickle(olmDevice.pickleKey),
+                    },
+                    txn,
+                );
+            });
 
             await client.enableKeyBackup({
                 algorithm: olmlib.MEGOLM_BACKUP_ALGORITHM,
-                version: '1',
+                version: "1",
                 auth_data: {
                     public_key: "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo",
                 },
@@ -556,9 +555,7 @@ describe("MegolmBackup", function() {
             let numCalls = 0;
 
             await new Promise<void>((resolve, reject) => {
-                client.http.authedRequest = function(
-                    method, path, queryParams, data, opts,
-                ): any {
+                client.http.authedRequest = function (method, path, queryParams, data, opts): any {
                     ++numCalls;
                     expect(numCalls).toBeLessThanOrEqual(2);
                     if (numCalls >= 3) {
@@ -568,7 +565,7 @@ describe("MegolmBackup", function() {
                     }
                     expect(method).toBe("PUT");
                     expect(path).toBe("/room_keys/keys");
-                    expect(queryParams?.version).toBe('1');
+                    expect(queryParams?.version).toBe("1");
                     expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toBeDefined();
                     expect((data as Record<string, any>).rooms[ROOM_ID].sessions).toHaveProperty(
                         groupSession.session_id(),
@@ -577,9 +574,7 @@ describe("MegolmBackup", function() {
                         resolve();
                         return Promise.resolve({});
                     } else {
-                        return Promise.reject(
-                            new Error("this is an expected failure"),
-                        );
+                        return Promise.reject(new Error("this is an expected failure"));
                     }
                 };
                 return client.crypto!.backupManager.backupGroupSession(
@@ -592,14 +587,14 @@ describe("MegolmBackup", function() {
         });
     });
 
-    describe("restore", function() {
+    describe("restore", function () {
         let client: MatrixClient;
 
-        beforeEach(function() {
+        beforeEach(function () {
             client = makeTestClient(cryptoStore);
 
             megolmDecryption = new MegolmDecryption({
-                userId: '@user:id',
+                userId: "@user:id",
                 crypto: mockCrypto,
                 olmDevice: olmDevice,
                 baseApis: client,
@@ -612,46 +607,52 @@ describe("MegolmBackup", function() {
             return client.initCrypto();
         });
 
-        afterEach(function() {
+        afterEach(function () {
             client.stopClient();
         });
 
-        it('can restore from backup (Curve25519 version)', function() {
-            client.http.authedRequest = function() {
+        it("can restore from backup (Curve25519 version)", function () {
+            client.http.authedRequest = function () {
                 return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                CURVE25519_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-                expect(res.untrusted).toBeTruthy(); // keys from Curve25519 backup are untrusted
-            });
+            return client
+                .restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    ROOM_ID,
+                    SESSION_ID,
+                    CURVE25519_BACKUP_INFO,
+                )
+                .then(() => {
+                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+                })
+                .then((res) => {
+                    expect(res.clearEvent.content).toEqual("testytest");
+                    expect(res.untrusted).toBeTruthy(); // keys from Curve25519 backup are untrusted
+                });
         });
 
-        it('can restore from backup (AES-256 version)', function() {
-            client.http.authedRequest = function() {
+        it("can restore from backup (AES-256 version)", function () {
+            client.http.authedRequest = function () {
                 return Promise.resolve<any>(AES256_KEY_BACKUP_DATA);
             };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                AES256_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-                expect(res.untrusted).toBeFalsy(); // keys from AES backup are trusted
-            });
+            return client
+                .restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    ROOM_ID,
+                    SESSION_ID,
+                    AES256_BACKUP_INFO,
+                )
+                .then(() => {
+                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+                })
+                .then((res) => {
+                    expect(res.clearEvent.content).toEqual("testytest");
+                    expect(res.untrusted).toBeFalsy(); // keys from AES backup are trusted
+                });
         });
 
-        it('can restore backup by room (Curve25519 version)', function() {
-            client.http.authedRequest = function() {
+        it("can restore backup by room (Curve25519 version)", function () {
+            client.http.authedRequest = function () {
                 return Promise.resolve<any>({
                     rooms: {
                         [ROOM_ID]: {
@@ -662,27 +663,32 @@ describe("MegolmBackup", function() {
                     },
                 });
             };
-            return client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                null!, null!, CURVE25519_BACKUP_INFO,
-            ).then(() => {
-                return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
-            }).then((res) => {
-                expect(res.clearEvent.content).toEqual('testytest');
-            });
+            return client
+                .restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    null!,
+                    null!,
+                    CURVE25519_BACKUP_INFO,
+                )
+                .then(() => {
+                    return megolmDecryption.decryptEvent(ENCRYPTED_EVENT);
+                })
+                .then((res) => {
+                    expect(res.clearEvent.content).toEqual("testytest");
+                });
         });
 
-        it('has working cache functions', async function() {
+        it("has working cache functions", async function () {
             const key = Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]);
             await client.crypto!.storeSessionBackupPrivateKey(key);
             const result = await client.crypto!.getSessionBackupPrivateKey();
             expect(new Uint8Array(result!)).toEqual(key);
         });
 
-        it('caches session backup keys as it encounters them', async function() {
+        it("caches session backup keys as it encounters them", async function () {
             const cachedNull = await client.crypto!.getSessionBackupPrivateKey();
             expect(cachedNull).toBeNull();
-            client.http.authedRequest = function() {
+            client.http.authedRequest = function () {
                 return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
             await new Promise<void>((resolve) => {
@@ -698,20 +704,22 @@ describe("MegolmBackup", function() {
             expect(cachedKey).not.toBeNull();
         });
 
-        it("fails if an known algorithm is used", async function() {
+        it("fails if an known algorithm is used", async function () {
             const BAD_BACKUP_INFO = Object.assign({}, CURVE25519_BACKUP_INFO, {
                 algorithm: "this.algorithm.does.not.exist",
             });
-            client.http.authedRequest = function() {
+            client.http.authedRequest = function () {
                 return Promise.resolve<any>(CURVE25519_KEY_BACKUP_DATA);
             };
 
-            await expect(client.restoreKeyBackupWithRecoveryKey(
-                "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
-                ROOM_ID,
-                SESSION_ID,
-                BAD_BACKUP_INFO,
-            )).rejects.toThrow();
+            await expect(
+                client.restoreKeyBackupWithRecoveryKey(
+                    "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d",
+                    ROOM_ID,
+                    SESSION_ID,
+                    BAD_BACKUP_INFO,
+                ),
+            ).rejects.toThrow();
         });
     });
 
diff --git a/spec/unit/crypto/cross-signing.spec.ts b/spec/unit/crypto/cross-signing.spec.ts
index 99ad5d0dafe..6f15bdd09ab 100644
--- a/spec/unit/crypto/cross-signing.spec.ts
+++ b/spec/unit/crypto/cross-signing.spec.ts
@@ -15,18 +15,18 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
-import anotherjson from 'another-json';
-import { PkSigning } from '@matrix-org/olm';
+import "../../olm-loader";
+import anotherjson from "another-json";
+import { PkSigning } from "@matrix-org/olm";
 import HttpBackend from "matrix-mock-request";
 
 import * as olmlib from "../../../src/crypto/olmlib";
-import { MatrixError } from '../../../src/http-api';
-import { logger } from '../../../src/logger';
-import { ICrossSigningKey, ICreateClientOpts, ISignedKey, MatrixClient } from '../../../src/client';
-import { CryptoEvent, IBootstrapCrossSigningOpts } from '../../../src/crypto';
-import { IDevice } from '../../../src/crypto/deviceinfo';
-import { TestClient } from '../../TestClient';
+import { MatrixError } from "../../../src/http-api";
+import { logger } from "../../../src/logger";
+import { ICrossSigningKey, ICreateClientOpts, ISignedKey, MatrixClient } from "../../../src/client";
+import { CryptoEvent, IBootstrapCrossSigningOpts } from "../../../src/crypto";
+import { IDevice } from "../../../src/crypto/deviceinfo";
+import { TestClient } from "../../TestClient";
 import { resetCrossSigningKeys } from "./crypto-utils";
 
 const PUSH_RULES_RESPONSE: Response = {
@@ -35,7 +35,7 @@ const PUSH_RULES_RESPONSE: Response = {
     data: {},
 };
 
-const filterResponse = function(userId: string): Response {
+const filterResponse = function (userId: string): Response {
     const filterPath = "/user/" + encodeURIComponent(userId) + "/filter";
     return {
         method: "POST",
@@ -45,21 +45,19 @@ const filterResponse = function(userId: string): Response {
 };
 
 interface Response {
-    method: 'GET' | 'PUT' | 'POST' | 'DELETE';
+    method: "GET" | "PUT" | "POST" | "DELETE";
     path: string;
     data: object;
 }
 
 function setHttpResponses(httpBackend: HttpBackend, responses: Response[]) {
-    responses.forEach(response => {
-        httpBackend
-            .when(response.method, response.path)
-            .respond(200, response.data);
+    responses.forEach((response) => {
+        httpBackend.when(response.method, response.path).respond(200, response.data);
     });
 }
 
 async function makeTestClient(
-    userInfo: { userId: string, deviceId: string},
+    userInfo: { userId: string; deviceId: string },
     options: Partial<ICreateClientOpts> = {},
     keys: Record<string, Uint8Array> = {},
 ) {
@@ -72,11 +70,11 @@ async function makeTestClient(
     }
 
     options.cryptoCallbacks = Object.assign(
-        {}, { getCrossSigningKey, saveCrossSigningKeys }, options.cryptoCallbacks || {},
-    );
-    const testClient = new TestClient(
-        userInfo.userId, userInfo.deviceId, undefined, undefined, options,
+        {},
+        { getCrossSigningKey, saveCrossSigningKeys },
+        options.cryptoCallbacks || {},
     );
+    const testClient = new TestClient(userInfo.userId, userInfo.deviceId, undefined, undefined, options);
     const client = testClient.client;
 
     await client.initCrypto();
@@ -84,24 +82,25 @@ async function makeTestClient(
     return { client, httpBackend: testClient.httpBackend };
 }
 
-describe("Cross Signing", function() {
+describe("Cross Signing", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn("Not running megolm backup unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
-    it("should sign the master key with the device key", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should sign the master key with the device key", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = jest.fn().mockImplementation(async (auth, keys) => {
             await olmlib.verifySignature(
-                alice.crypto!.olmDevice, keys.master_key, "@alice:example.com",
-                "Osborne2", alice.crypto!.olmDevice.deviceEd25519Key!,
+                alice.crypto!.olmDevice,
+                keys.master_key,
+                "@alice:example.com",
+                "Osborne2",
+                alice.crypto!.olmDevice.deviceEd25519Key!,
             );
         });
         alice.uploadKeySignatures = async () => ({ failures: {} });
@@ -109,24 +108,22 @@ describe("Cross Signing", function() {
         alice.getAccountDataFromServer = async <T>() => ({} as T);
         // set Alice's cross-signing key
         await alice.bootstrapCrossSigning({
-            authUploadDeviceSigningKeys: async func => { await func({}); },
+            authUploadDeviceSigningKeys: async (func) => {
+                await func({});
+            },
         });
         expect(alice.uploadDeviceSigningKeys).toHaveBeenCalled();
         alice.stopClient();
     });
 
-    it("should abort bootstrap if device signing auth fails", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should abort bootstrap if device signing auth fails", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async (auth, keys) => {
             const errorResponse = {
                 session: "sessionId",
                 flows: [
                     {
-                        stages: [
-                            "m.login.password",
-                        ],
+                        stages: ["m.login.password"],
                     },
                 ],
                 params: {},
@@ -148,8 +145,8 @@ describe("Cross Signing", function() {
         };
         alice.uploadKeySignatures = async () => ({ failures: {} });
         alice.setAccountData = async () => ({});
-        alice.getAccountDataFromServer = async <T extends {[k: string]: any}>(): Promise<T | null> => ({} as T);
-        const authUploadDeviceSigningKeys: IBootstrapCrossSigningOpts["authUploadDeviceSigningKeys"] = async func => {
+        alice.getAccountDataFromServer = async <T extends { [k: string]: any }>(): Promise<T | null> => ({} as T);
+        const authUploadDeviceSigningKeys: IBootstrapCrossSigningOpts["authUploadDeviceSigningKeys"] = async (func) => {
             await func({});
         };
 
@@ -169,10 +166,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should upload a signature when a user is verified", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should upload a signature when a user is verified", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         // set Alice's cross-signing key
@@ -204,18 +199,14 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it.skip("should get cross-signing keys from sync", async function() {
+    it.skip("should get cross-signing keys from sync", async function () {
         const masterKey = new Uint8Array([
-            0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82,
-            0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef,
-            0xae, 0xb1, 0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6,
-            0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
+            0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82, 0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef, 0xae, 0xb1,
+            0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6, 0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
         ]);
         const selfSigningKey = new Uint8Array([
-            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66,
-            0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0,
-            0x17, 0xb5, 0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49,
-            0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
+            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66, 0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0, 0x17, 0xb5,
+            0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49, 0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
         ]);
 
         const { client: alice, httpBackend } = await makeTestClient(
@@ -223,8 +214,8 @@ describe("Cross Signing", function() {
             {
                 cryptoCallbacks: {
                     // will be called to sign our own device
-                    getCrossSigningKey: async type => {
-                        if (type === 'master') {
+                    getCrossSigningKey: async (type) => {
+                        if (type === "master") {
                             return masterKey;
                         } else {
                             return selfSigningKey;
@@ -248,11 +239,10 @@ describe("Cross Signing", function() {
                 try {
                     await olmlib.verifySignature(
                         alice.crypto!.olmDevice,
-                        content["@alice:example.com"][
-                            "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk"
-                        ],
+                        content["@alice:example.com"]["nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk"],
                         "@alice:example.com",
-                        "Osborne2", alice.crypto!.olmDevice.deviceEd25519Key!,
+                        "Osborne2",
+                        alice.crypto!.olmDevice.deviceEd25519Key!,
                     );
                     olmlib.pkVerify(
                         content["@alice:example.com"]["Osborne2"],
@@ -267,8 +257,7 @@ describe("Cross Signing", function() {
         });
 
         // @ts-ignore private property
-        const deviceInfo = alice.crypto!.deviceList.devices["@alice:example.com"]
-            .Osborne2;
+        const deviceInfo = alice.crypto!.deviceList.devices["@alice:example.com"].Osborne2;
         const aliceDevice = {
             user_id: "@alice:example.com",
             device_id: "Osborne2",
@@ -276,12 +265,7 @@ describe("Cross Signing", function() {
             algorithms: deviceInfo.algorithms,
         };
         await alice.crypto!.signObject(aliceDevice);
-        olmlib.pkSign(
-            aliceDevice as ISignedKey,
-            selfSigningKey as unknown as PkSigning,
-            "@alice:example.com",
-            '',
-        );
+        olmlib.pkSign(aliceDevice as ISignedKey, selfSigningKey as unknown as PkSigning, "@alice:example.com", "");
 
         // feed sync result that includes master key, ssk, device key
         const responses: Response[] = [
@@ -303,10 +287,7 @@ describe("Cross Signing", function() {
                 data: {
                     next_batch: "abcdefg",
                     device_lists: {
-                        changed: [
-                            "@alice:example.com",
-                            "@bob:example.com",
-                        ],
+                        changed: ["@alice:example.com", "@bob:example.com"],
                     },
                 },
             },
@@ -314,35 +295,35 @@ describe("Cross Signing", function() {
                 method: "POST",
                 path: "/keys/query",
                 data: {
-                    "failures": {},
-                    "device_keys": {
+                    failures: {},
+                    device_keys: {
                         "@alice:example.com": {
-                            "Osborne2": aliceDevice,
+                            Osborne2: aliceDevice,
                         },
                     },
-                    "master_keys": {
+                    master_keys: {
                         "@alice:example.com": {
                             user_id: "@alice:example.com",
                             usage: ["master"],
                             keys: {
                                 "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                                "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
+                                    "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
                             },
                         },
                     },
-                    "self_signing_keys": {
+                    self_signing_keys: {
                         "@alice:example.com": {
                             user_id: "@alice:example.com",
                             usage: ["self-signing"],
                             keys: {
                                 "ed25519:EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ":
-                                "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
+                                    "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
                             },
                             signatures: {
                                 "@alice:example.com": {
                                     "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                                    "Wqx/HXR851KIi8/u/UX+fbAMtq9Uj8sr8FsOcqrLfVYa6lAmbXs"
-                                    + "Vhfy4AlZ3dnEtjgZx0U0QDrghEn2eYBeOCA",
+                                        "Wqx/HXR851KIi8/u/UX+fbAMtq9Uj8sr8FsOcqrLfVYa6lAmbXs" +
+                                        "Vhfy4AlZ3dnEtjgZx0U0QDrghEn2eYBeOCA",
                                 },
                             },
                         },
@@ -382,10 +363,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should use trust chain to determine device verification", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should use trust chain to determine device verification", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         // set Alice's cross-signing key
@@ -472,7 +451,7 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it.skip("should trust signatures received from other devices", async function() {
+    it.skip("should trust signatures received from other devices", async function () {
         const aliceKeys: Record<string, Uint8Array> = {};
         const { client: alice, httpBackend } = await makeTestClient(
             { userId: "@alice:example.com", deviceId: "Osborne2" },
@@ -488,10 +467,8 @@ describe("Cross Signing", function() {
         await resetCrossSigningKeys(alice);
 
         const selfSigningKey = new Uint8Array([
-            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66,
-            0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0,
-            0x17, 0xb5, 0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49,
-            0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
+            0x1e, 0xf4, 0x01, 0x6d, 0x4f, 0xa1, 0x73, 0x66, 0x6b, 0xf8, 0x93, 0xf5, 0xb0, 0x4d, 0x17, 0xc0, 0x17, 0xb5,
+            0xa5, 0xf6, 0x59, 0x11, 0x8b, 0x49, 0x34, 0xf2, 0x4b, 0x64, 0x9b, 0x52, 0xf8, 0x5f,
         ]);
 
         const keyChangePromise = new Promise<void>((resolve, reject) => {
@@ -535,22 +512,16 @@ describe("Cross Signing", function() {
             verified: 0,
             known: false,
         };
-        olmlib.pkSign(
-            bobDevice,
-            selfSigningKey as unknown as PkSigning,
-            "@bob:example.com",
-            '',
-        );
+        olmlib.pkSign(bobDevice, selfSigningKey as unknown as PkSigning, "@bob:example.com", "");
 
         const bobMaster: ICrossSigningKey = {
             user_id: "@bob:example.com",
             usage: ["master"],
             keys: {
-                "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
+                "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk": "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
             },
         };
-        olmlib.pkSign(bobMaster, aliceKeys.user_signing, "@alice:example.com", '');
+        olmlib.pkSign(bobMaster, aliceKeys.user_signing, "@alice:example.com", "");
 
         // Alice downloads Bob's keys
         // - device key
@@ -576,9 +547,7 @@ describe("Cross Signing", function() {
                 data: {
                     next_batch: "abcdefg",
                     device_lists: {
-                        changed: [
-                            "@bob:example.com",
-                        ],
+                        changed: ["@bob:example.com"],
                     },
                 },
             },
@@ -586,31 +555,31 @@ describe("Cross Signing", function() {
                 method: "POST",
                 path: "/keys/query",
                 data: {
-                    "failures": {},
-                    "device_keys": {
+                    failures: {},
+                    device_keys: {
                         "@alice:example.com": {
-                            "Osborne2": aliceDevice,
+                            Osborne2: aliceDevice,
                         },
                         "@bob:example.com": {
-                            "Dynabook": bobDevice,
+                            Dynabook: bobDevice,
                         },
                     },
-                    "master_keys": {
+                    master_keys: {
                         "@bob:example.com": bobMaster,
                     },
-                    "self_signing_keys": {
+                    self_signing_keys: {
                         "@bob:example.com": {
                             user_id: "@bob:example.com",
                             usage: ["self-signing"],
                             keys: {
                                 "ed25519:EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ":
-                                "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
+                                    "EmkqvokUn8p+vQAGZitOk4PWjp7Ukp3txV2TbMPEiBQ",
                             },
                             signatures: {
                                 "@bob:example.com": {
                                     "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
-                                    "2KLiufImvEbfJuAFvsaZD+PsL8ELWl7N1u9yr/9hZvwRghBfQMB"
-                                    + "LAI86b1kDV9+Cq1lt85ykReeCEzmTEPY2BQ",
+                                        "2KLiufImvEbfJuAFvsaZD+PsL8ELWl7N1u9yr/9hZvwRghBfQMB" +
+                                        "LAI86b1kDV9+Cq1lt85ykReeCEzmTEPY2BQ",
                                 },
                             },
                         },
@@ -646,10 +615,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should dis-trust an unsigned device", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should dis-trust an unsigned device", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         // set Alice's cross-signing key
@@ -716,10 +683,8 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should dis-trust a user when their ssk changes", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should dis-trust a user when their ssk changes", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
         await resetCrossSigningKeys(alice);
@@ -860,7 +825,7 @@ describe("Cross Signing", function() {
         alice.stopClient();
     });
 
-    it("should offer to upgrade device verifications to cross-signing", async function() {
+    it("should offer to upgrade device verifications to cross-signing", async function () {
         let upgradeResolveFunc: Function;
 
         const { client: alice } = await makeTestClient(
@@ -874,11 +839,8 @@ describe("Cross Signing", function() {
                     },
                 },
             },
-
-        );
-        const { client: bob } = await makeTestClient(
-            { userId: "@bob:example.com", deviceId: "Dynabook" },
         );
+        const { client: bob } = await makeTestClient({ userId: "@bob:example.com", deviceId: "Dynabook" });
 
         bob.uploadDeviceSigningKeys = async () => ({});
         bob.uploadKeySignatures = async () => ({ failures: {} });
@@ -895,10 +857,7 @@ describe("Cross Signing", function() {
                 known: true,
             },
         });
-        alice.crypto!.deviceList.storeCrossSigningForUser(
-            "@bob:example.com",
-            bob.crypto!.crossSigningInfo.toStorage(),
-        );
+        alice.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", bob.crypto!.crossSigningInfo.toStorage());
 
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
@@ -917,8 +876,9 @@ describe("Cross Signing", function() {
         expect(bobTrust.isTofu()).toBeTruthy();
 
         // "forget" that Bob is trusted
-        delete alice.crypto!.deviceList.crossSigningInfo["@bob:example.com"]
-            .keys.master.signatures!["@alice:example.com"];
+        delete alice.crypto!.deviceList.crossSigningInfo["@bob:example.com"].keys.master.signatures![
+            "@alice:example.com"
+        ];
 
         const bobTrust2 = alice.checkUserTrust("@bob:example.com");
         expect(bobTrust2.isCrossSigningVerified()).toBeFalsy();
@@ -940,91 +900,83 @@ describe("Cross Signing", function() {
         bob.stopClient();
     });
 
-    it(
-        "should observe that our own device is cross-signed, even if this device doesn't trust the key",
-        async function() {
-            const { client: alice } = await makeTestClient(
-                { userId: "@alice:example.com", deviceId: "Osborne2" },
-            );
-            alice.uploadDeviceSigningKeys = async () => ({});
-            alice.uploadKeySignatures = async () => ({ failures: {} });
-
-            // Generate Alice's SSK etc
-            const aliceMasterSigning = new global.Olm.PkSigning();
-            const aliceMasterPrivkey = aliceMasterSigning.generate_seed();
-            const aliceMasterPubkey = aliceMasterSigning.init_with_seed(aliceMasterPrivkey);
-            const aliceSigning = new global.Olm.PkSigning();
-            const alicePrivkey = aliceSigning.generate_seed();
-            const alicePubkey = aliceSigning.init_with_seed(alicePrivkey);
-            const aliceSSK: ICrossSigningKey = {
-                user_id: "@alice:example.com",
-                usage: ["self_signing"],
-                keys: {
-                    ["ed25519:" + alicePubkey]: alicePubkey,
-                },
-            };
-            const sskSig = aliceMasterSigning.sign(anotherjson.stringify(aliceSSK));
-            aliceSSK.signatures = {
-                "@alice:example.com": {
-                    ["ed25519:" + aliceMasterPubkey]: sskSig,
-                },
-            };
+    it("should observe that our own device is cross-signed, even if this device doesn't trust the key", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
+        alice.uploadDeviceSigningKeys = async () => ({});
+        alice.uploadKeySignatures = async () => ({ failures: {} });
 
-            // Alice's device downloads the keys, but doesn't trust them yet
-            alice.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
-                keys: {
-                    master: {
-                        user_id: "@alice:example.com",
-                        usage: ["master"],
-                        keys: {
-                            ["ed25519:" + aliceMasterPubkey]: aliceMasterPubkey,
-                        },
+        // Generate Alice's SSK etc
+        const aliceMasterSigning = new global.Olm.PkSigning();
+        const aliceMasterPrivkey = aliceMasterSigning.generate_seed();
+        const aliceMasterPubkey = aliceMasterSigning.init_with_seed(aliceMasterPrivkey);
+        const aliceSigning = new global.Olm.PkSigning();
+        const alicePrivkey = aliceSigning.generate_seed();
+        const alicePubkey = aliceSigning.init_with_seed(alicePrivkey);
+        const aliceSSK: ICrossSigningKey = {
+            user_id: "@alice:example.com",
+            usage: ["self_signing"],
+            keys: {
+                ["ed25519:" + alicePubkey]: alicePubkey,
+            },
+        };
+        const sskSig = aliceMasterSigning.sign(anotherjson.stringify(aliceSSK));
+        aliceSSK.signatures = {
+            "@alice:example.com": {
+                ["ed25519:" + aliceMasterPubkey]: sskSig,
+            },
+        };
+
+        // Alice's device downloads the keys, but doesn't trust them yet
+        alice.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
+            keys: {
+                master: {
+                    user_id: "@alice:example.com",
+                    usage: ["master"],
+                    keys: {
+                        ["ed25519:" + aliceMasterPubkey]: aliceMasterPubkey,
                     },
-                    self_signing: aliceSSK,
                 },
-                firstUse: true,
-                crossSigningVerifiedBefore: false,
-            });
+                self_signing: aliceSSK,
+            },
+            firstUse: true,
+            crossSigningVerifiedBefore: false,
+        });
 
-            // Alice has a second device that's cross-signed
-            const aliceDeviceId = 'Dynabook';
-            const aliceUnsignedDevice = {
-                user_id: "@alice:example.com",
-                device_id: aliceDeviceId,
-                algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
-                keys: {
-                    "curve25519:Dynabook": "somePubkey",
-                    "ed25519:Dynabook": "someOtherPubkey",
+        // Alice has a second device that's cross-signed
+        const aliceDeviceId = "Dynabook";
+        const aliceUnsignedDevice = {
+            user_id: "@alice:example.com",
+            device_id: aliceDeviceId,
+            algorithms: ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
+            keys: {
+                "curve25519:Dynabook": "somePubkey",
+                "ed25519:Dynabook": "someOtherPubkey",
+            },
+        };
+        const sig = aliceSigning.sign(anotherjson.stringify(aliceUnsignedDevice));
+        const aliceCrossSignedDevice: IDevice = {
+            ...aliceUnsignedDevice,
+            verified: 0,
+            known: false,
+            signatures: {
+                "@alice:example.com": {
+                    ["ed25519:" + alicePubkey]: sig,
                 },
-            };
-            const sig = aliceSigning.sign(anotherjson.stringify(aliceUnsignedDevice));
-            const aliceCrossSignedDevice: IDevice = {
-                ...aliceUnsignedDevice,
-                verified: 0,
-                known: false,
-                signatures: {
-                    "@alice:example.com": {
-                        ["ed25519:" + alicePubkey]: sig,
-                    },
-                } };
-            alice.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
-                [aliceDeviceId]: aliceCrossSignedDevice,
-            });
+            },
+        };
+        alice.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
+            [aliceDeviceId]: aliceCrossSignedDevice,
+        });
 
-            // We don't trust the cross-signing keys yet...
-            expect(
-                alice.checkDeviceTrust("@alice:example.com", aliceDeviceId).isCrossSigningVerified(),
-            ).toBeFalsy();
-            // ... but we do acknowledge that the device is signed by them
-            expect(alice.checkIfOwnDeviceCrossSigned(aliceDeviceId)).toBeTruthy();
-            alice.stopClient();
-        },
-    );
+        // We don't trust the cross-signing keys yet...
+        expect(alice.checkDeviceTrust("@alice:example.com", aliceDeviceId).isCrossSigningVerified()).toBeFalsy();
+        // ... but we do acknowledge that the device is signed by them
+        expect(alice.checkIfOwnDeviceCrossSigned(aliceDeviceId)).toBeTruthy();
+        alice.stopClient();
+    });
 
-    it("should observe that our own device isn't cross-signed", async function() {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should observe that our own device isn't cross-signed", async function () {
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
 
@@ -1084,9 +1036,7 @@ describe("Cross Signing", function() {
     });
 
     it("checkIfOwnDeviceCrossSigned should sanely handle unknown devices", async () => {
-        const { client: alice } = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+        const { client: alice } = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
         alice.uploadDeviceSigningKeys = async () => ({});
         alice.uploadKeySignatures = async () => ({ failures: {} });
 
@@ -1138,7 +1088,7 @@ describe("Cross Signing", function() {
     });
 });
 
-describe("userHasCrossSigningKeys", function() {
+describe("userHasCrossSigningKeys", function () {
     if (!global.Olm) {
         return;
     }
@@ -1160,38 +1110,38 @@ describe("userHasCrossSigningKeys", function() {
     });
 
     it("should download devices and return true if one is a cross-signing key", async () => {
-        httpBackend
-            .when("POST", "/keys/query")
-            .respond(200, {
-                "master_keys": {
-                    "@alice:example.com": {
-                        user_id: "@alice:example.com",
-                        usage: ["master"],
-                        keys: {
-                            "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
+        httpBackend.when("POST", "/keys/query").respond(200, {
+            master_keys: {
+                "@alice:example.com": {
+                    user_id: "@alice:example.com",
+                    usage: ["master"],
+                    keys: {
+                        "ed25519:nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk":
                             "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk",
-                        },
                     },
                 },
-            });
+            },
+        });
 
         let result: boolean;
         await Promise.all([
             httpBackend.flush("/keys/query"),
-            aliceClient.userHasCrossSigningKeys().then((res) => {result = res;}),
+            aliceClient.userHasCrossSigningKeys().then((res) => {
+                result = res;
+            }),
         ]);
         expect(result!).toBeTruthy();
     });
 
     it("should download devices and return false if there is no cross-signing key", async () => {
-        httpBackend
-            .when("POST", "/keys/query")
-            .respond(200, {});
+        httpBackend.when("POST", "/keys/query").respond(200, {});
 
         let result: boolean;
         await Promise.all([
             httpBackend.flush("/keys/query"),
-            aliceClient.userHasCrossSigningKeys().then((res) => {result = res;}),
+            aliceClient.userHasCrossSigningKeys().then((res) => {
+                result = res;
+            }),
         ]);
         expect(result!).toBeFalsy();
     });
diff --git a/spec/unit/crypto/crypto-utils.ts b/spec/unit/crypto/crypto-utils.ts
index 76f2a083575..1dd0065de5c 100644
--- a/spec/unit/crypto/crypto-utils.ts
+++ b/spec/unit/crypto/crypto-utils.ts
@@ -1,6 +1,6 @@
-import { IRecoveryKey } from '../../../src/crypto/api';
-import { CrossSigningLevel } from '../../../src/crypto/CrossSigning';
-import { IndexedDBCryptoStore } from '../../../src/crypto/store/indexeddb-crypto-store';
+import { IRecoveryKey } from "../../../src/crypto/api";
+import { CrossSigningLevel } from "../../../src/crypto/CrossSigning";
+import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
 import { MatrixClient } from "../../../src";
 import { CryptoEvent } from "../../../src/crypto";
 
@@ -8,7 +8,7 @@ import { CryptoEvent } from "../../../src/crypto";
 // but that is doing too much extra stuff for it to be an easy transition.
 export async function resetCrossSigningKeys(
     client: MatrixClient,
-    { level }: { level?: CrossSigningLevel} = {},
+    { level }: { level?: CrossSigningLevel } = {},
 ): Promise<void> {
     const crypto = client.crypto!;
 
@@ -17,13 +17,9 @@ export async function resetCrossSigningKeys(
         await crypto.crossSigningInfo.resetKeys(level);
         await crypto.signObject(crypto.crossSigningInfo.keys.master);
         // write a copy locally so we know these are trusted keys
-        await crypto.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                crypto.cryptoStore.storeCrossSigningKeys(
-                    txn, crypto.crossSigningInfo.keys);
-            },
-        );
+        await crypto.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            crypto.cryptoStore.storeCrossSigningKeys(txn, crypto.crossSigningInfo.keys);
+        });
     } catch (e) {
         // If anything failed here, revert the keys so we know to try again from the start
         // next time.
diff --git a/spec/unit/crypto/dehydration.spec.ts b/spec/unit/crypto/dehydration.spec.ts
index 7d3227117c0..18b4b382806 100644
--- a/spec/unit/crypto/dehydration.spec.ts
+++ b/spec/unit/crypto/dehydration.spec.ts
@@ -14,33 +14,30 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
-import { TestClient } from '../../TestClient';
-import { logger } from '../../../src/logger';
-import { DEHYDRATION_ALGORITHM } from '../../../src/crypto/dehydration';
+import "../../olm-loader";
+import { TestClient } from "../../TestClient";
+import { logger } from "../../../src/logger";
+import { DEHYDRATION_ALGORITHM } from "../../../src/crypto/dehydration";
 
 const Olm = global.Olm;
 
 describe("Dehydration", () => {
     if (!global.Olm) {
-        logger.warn('Not running dehydration unit tests: libolm not present');
+        logger.warn("Not running dehydration unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
     it("should rehydrate a dehydrated device", async () => {
         const key = new Uint8Array([1, 2, 3]);
-        const alice = new TestClient(
-            "@alice:example.com", "Osborne2", undefined, undefined,
-            {
-                cryptoCallbacks: {
-                    getDehydrationKey: async t => key,
-                },
+        const alice = new TestClient("@alice:example.com", "Osborne2", undefined, undefined, {
+            cryptoCallbacks: {
+                getDehydrationKey: async (t) => key,
             },
-        );
+        });
 
         const dehydratedDevice = new Olm.Account();
         dehydratedDevice.create();
@@ -56,25 +53,20 @@ describe("Dehydration", () => {
             success: true,
         });
 
-        expect((await Promise.all([
-            alice.client.rehydrateDevice(),
-            alice.httpBackend.flushAllExpected(),
-        ]))[0])
-            .toEqual("ABCDEFG");
+        expect((await Promise.all([alice.client.rehydrateDevice(), alice.httpBackend.flushAllExpected()]))[0]).toEqual(
+            "ABCDEFG",
+        );
 
         expect(alice.client.getDeviceId()).toEqual("ABCDEFG");
     });
 
     it("should dehydrate a device", async () => {
         const key = new Uint8Array([1, 2, 3]);
-        const alice = new TestClient(
-            "@alice:example.com", "Osborne2", undefined, undefined,
-            {
-                cryptoCallbacks: {
-                    getDehydrationKey: async t => key,
-                },
+        const alice = new TestClient("@alice:example.com", "Osborne2", undefined, undefined, {
+            cryptoCallbacks: {
+                getDehydrationKey: async (t) => key,
             },
-        );
+        });
 
         await alice.client.initCrypto();
 
@@ -84,7 +76,8 @@ describe("Dehydration", () => {
 
         let pickledAccount = "";
 
-        alice.httpBackend.when("PUT", "/dehydrated_device")
+        alice.httpBackend
+            .when("PUT", "/dehydrated_device")
             .check((req) => {
                 expect(req.data.device_data).toMatchObject({
                     algorithm: DEHYDRATION_ALGORITHM,
@@ -95,7 +88,8 @@ describe("Dehydration", () => {
             .respond(200, {
                 device_id: "ABCDEFG",
             });
-        alice.httpBackend.when("POST", "/keys/upload/ABCDEFG")
+        alice.httpBackend
+            .when("POST", "/keys/upload/ABCDEFG")
             .check((req) => {
                 expect(req.data).toMatchObject({
                     "device_keys": expect.objectContaining({
@@ -119,11 +113,12 @@ describe("Dehydration", () => {
             .respond(200, {});
 
         try {
-            const deviceId =
-                (await Promise.all([
+            const deviceId = (
+                await Promise.all([
                     alice.client.createDehydratedDevice(new Uint8Array(key), {}),
                     alice.httpBackend.flushAllExpected(),
-                ]))[0];
+                ])
+            )[0];
 
             expect(deviceId).toEqual("ABCDEFG");
             expect(deviceId).not.toEqual("");
diff --git a/spec/unit/crypto/outgoing-room-key-requests.spec.ts b/spec/unit/crypto/outgoing-room-key-requests.spec.ts
index 049b7b7d365..f160efc0c9f 100644
--- a/spec/unit/crypto/outgoing-room-key-requests.spec.ts
+++ b/spec/unit/crypto/outgoing-room-key-requests.spec.ts
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { CryptoStore } from '../../../src/crypto/store/base';
-import { IndexedDBCryptoStore } from '../../../src/crypto/store/indexeddb-crypto-store';
-import { LocalStorageCryptoStore } from '../../../src/crypto/store/localStorage-crypto-store';
-import { MemoryCryptoStore } from '../../../src/crypto/store/memory-crypto-store';
-import { RoomKeyRequestState } from '../../../src/crypto/OutgoingRoomKeyRequestManager';
+import { CryptoStore } from "../../../src/crypto/store/base";
+import { IndexedDBCryptoStore } from "../../../src/crypto/store/indexeddb-crypto-store";
+import { LocalStorageCryptoStore } from "../../../src/crypto/store/localStorage-crypto-store";
+import { MemoryCryptoStore } from "../../../src/crypto/store/memory-crypto-store";
+import { RoomKeyRequestState } from "../../../src/crypto/OutgoingRoomKeyRequestManager";
 
-import 'fake-indexeddb/auto';
-import 'jest-localstorage-mock';
+import "fake-indexeddb/auto";
+import "jest-localstorage-mock";
 
 const requests = [
     {
@@ -46,54 +46,46 @@ const requests = [
         requestId: "C",
         requestBody: { session_id: "C", room_id: "C", sender_key: "B", algorithm: "m.megolm.v1.aes-sha2" },
         state: RoomKeyRequestState.Unsent,
-        recipients: [
-            { userId: "@becca:example.com", deviceId: "foobarbaz" },
-        ],
+        recipients: [{ userId: "@becca:example.com", deviceId: "foobarbaz" }],
     },
 ];
 
 describe.each([
-    ["IndexedDBCryptoStore",
-        () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
+    ["IndexedDBCryptoStore", () => new IndexedDBCryptoStore(global.indexedDB, "tests")],
     ["LocalStorageCryptoStore", () => new LocalStorageCryptoStore(localStorage)],
     ["MemoryCryptoStore", () => new MemoryCryptoStore()],
-])("Outgoing room key requests [%s]", function(name, dbFactory) {
+])("Outgoing room key requests [%s]", function (name, dbFactory) {
     let store: CryptoStore;
 
     beforeAll(async () => {
         store = dbFactory();
         await store.startup();
-        await Promise.all(requests.map((request) =>
-            store.getOrAddOutgoingRoomKeyRequest(request),
-        ));
+        await Promise.all(requests.map((request) => store.getOrAddOutgoingRoomKeyRequest(request)));
     });
 
-    it("getAllOutgoingRoomKeyRequestsByState retrieves all entries in a given state",
-        async () => {
-            const r = await
-            store.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
-            expect(r).toHaveLength(2);
-            requests.filter((e) => e.state === RoomKeyRequestState.Sent).forEach((e) => {
+    it("getAllOutgoingRoomKeyRequestsByState retrieves all entries in a given state", async () => {
+        const r = await store.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
+        expect(r).toHaveLength(2);
+        requests
+            .filter((e) => e.state === RoomKeyRequestState.Sent)
+            .forEach((e) => {
                 expect(r).toContainEqual(e);
             });
-        });
+    });
 
-    it("getOutgoingRoomKeyRequestsByTarget retrieves all entries with a given target",
-        async () => {
-            const r = await store.getOutgoingRoomKeyRequestsByTarget(
-                "@becca:example.com", "foobarbaz", [RoomKeyRequestState.Sent],
-            );
-            expect(r).toHaveLength(1);
-            expect(r[0]).toEqual(requests[0]);
-        });
+    it("getOutgoingRoomKeyRequestsByTarget retrieves all entries with a given target", async () => {
+        const r = await store.getOutgoingRoomKeyRequestsByTarget("@becca:example.com", "foobarbaz", [
+            RoomKeyRequestState.Sent,
+        ]);
+        expect(r).toHaveLength(1);
+        expect(r[0]).toEqual(requests[0]);
+    });
 
-    test("getOutgoingRoomKeyRequestByState retrieves any entry in a given state",
-        async () => {
-            const r =
-            await store.getOutgoingRoomKeyRequestByState([RoomKeyRequestState.Sent]);
-            expect(r).not.toBeNull();
-            expect(r).not.toBeUndefined();
-            expect(r!.state).toEqual(RoomKeyRequestState.Sent);
-            expect(requests).toContainEqual(r);
-        });
+    test("getOutgoingRoomKeyRequestByState retrieves any entry in a given state", async () => {
+        const r = await store.getOutgoingRoomKeyRequestByState([RoomKeyRequestState.Sent]);
+        expect(r).not.toBeNull();
+        expect(r).not.toBeUndefined();
+        expect(r!.state).toEqual(RoomKeyRequestState.Sent);
+        expect(requests).toContainEqual(r);
+    });
 });
diff --git a/spec/unit/crypto/secrets.spec.ts b/spec/unit/crypto/secrets.spec.ts
index 885f0f6c37d..dc86642578d 100644
--- a/spec/unit/crypto/secrets.spec.ts
+++ b/spec/unit/crypto/secrets.spec.ts
@@ -14,65 +14,70 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
+import "../../olm-loader";
 import * as olmlib from "../../../src/crypto/olmlib";
 import { IObject } from "../../../src/crypto/olmlib";
 import { SECRET_STORAGE_ALGORITHM_V1_AES } from "../../../src/crypto/SecretStorage";
 import { MatrixEvent } from "../../../src/models/event";
-import { TestClient } from '../../TestClient';
-import { makeTestClients } from './verification/util';
+import { TestClient } from "../../TestClient";
+import { makeTestClients } from "./verification/util";
 import { encryptAES } from "../../../src/crypto/aes";
 import { createSecretStorageKey, resetCrossSigningKeys } from "./crypto-utils";
-import { logger } from '../../../src/logger';
-import { ClientEvent, ICreateClientOpts, ICrossSigningKey, MatrixClient } from '../../../src/client';
-import { ISecretStorageKeyInfo } from '../../../src/crypto/api';
-import { DeviceInfo } from '../../../src/crypto/deviceinfo';
+import { logger } from "../../../src/logger";
+import { ClientEvent, ICreateClientOpts, ICrossSigningKey, MatrixClient } from "../../../src/client";
+import { ISecretStorageKeyInfo } from "../../../src/crypto/api";
+import { DeviceInfo } from "../../../src/crypto/deviceinfo";
 import { ISignatures } from "../../../src/@types/signed";
 import { ICurve25519AuthData } from "../../../src/crypto/keybackup";
 
-async function makeTestClient(userInfo: { userId: string, deviceId: string}, options: Partial<ICreateClientOpts> = {}) {
-    const client = (new TestClient(
-        userInfo.userId, userInfo.deviceId, undefined, undefined, options,
-    )).client;
+async function makeTestClient(
+    userInfo: { userId: string; deviceId: string },
+    options: Partial<ICreateClientOpts> = {},
+) {
+    const client = new TestClient(userInfo.userId, userInfo.deviceId, undefined, undefined, options).client;
 
     // Make it seem as if we've synced and thus the store can be trusted to
     // contain valid account data.
-    client.isInitialSyncComplete = function() {
+    client.isInitialSyncComplete = function () {
         return true;
     };
 
     await client.initCrypto();
 
     // No need to download keys for these tests
-    jest.spyOn(client.crypto!, 'downloadKeys').mockResolvedValue({});
+    jest.spyOn(client.crypto!, "downloadKeys").mockResolvedValue({});
 
     return client;
 }
 
 // Wrapper around pkSign to return a signed object. pkSign returns the
 // signature, rather than the signed object.
-function sign<T extends IObject | ICurve25519AuthData>(obj: T, key: Uint8Array, userId: string): T & {
+function sign<T extends IObject | ICurve25519AuthData>(
+    obj: T,
+    key: Uint8Array,
+    userId: string,
+): T & {
     signatures: ISignatures;
     unsigned?: object;
 } {
-    olmlib.pkSign(obj, key, userId, '');
+    olmlib.pkSign(obj, key, userId, "");
     return obj as T & {
         signatures: ISignatures;
         unsigned?: object;
     };
 }
 
-describe("Secrets", function() {
+describe("Secrets", function () {
     if (!global.Olm) {
-        logger.warn('Not running megolm backup unit tests: libolm not present');
+        logger.warn("Not running megolm backup unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
-    it("should store and retrieve a secret", async function() {
+    it("should store and retrieve a secret", async function () {
         const key = new Uint8Array(16);
         for (let i = 0; i < 16; i++) key[i] = i;
 
@@ -82,22 +87,22 @@ describe("Secrets", function() {
 
         const signingkeyInfo = {
             user_id: "@alice:example.com",
-            usage: ['master'],
+            usage: ["master"],
             keys: {
-                ['ed25519:' + signingPubKey]: signingPubKey,
+                ["ed25519:" + signingPubKey]: signingPubKey,
             },
         };
 
-        const getKey = jest.fn().mockImplementation(async e => {
+        const getKey = jest.fn().mockImplementation(async (e) => {
             expect(Object.keys(e.keys)).toEqual(["abc"]);
-            return ['abc', key];
+            return ["abc", key];
         });
 
         const alice = await makeTestClient(
             { userId: "@alice:example.com", deviceId: "Osborne2" },
             {
                 cryptoCallbacks: {
-                    getCrossSigningKey: async t => signingKey,
+                    getCrossSigningKey: async (t) => signingKey,
                     getSecretStorageKey: getKey,
                 },
             },
@@ -108,21 +113,20 @@ describe("Secrets", function() {
 
         const secretStorage = alice.crypto!.secretStorage;
 
-        jest.spyOn(alice, 'setAccountData').mockImplementation(
-            async function(eventType, contents) {
-                alice.store.storeAccountDataEvents([
-                    new MatrixEvent({
-                        type: eventType,
-                        content: contents,
-                    }),
-                ]);
-                return {};
-            });
+        jest.spyOn(alice, "setAccountData").mockImplementation(async function (eventType, contents) {
+            alice.store.storeAccountDataEvents([
+                new MatrixEvent({
+                    type: eventType,
+                    content: contents,
+                }),
+            ]);
+            return {};
+        });
 
         const keyAccountData = {
             algorithm: SECRET_STORAGE_ALGORITHM_V1_AES,
         };
-        await alice.crypto!.crossSigningInfo.signObject(keyAccountData, 'master');
+        await alice.crypto!.crossSigningInfo.signObject(keyAccountData, "master");
 
         alice.store.storeAccountDataEvents([
             new MatrixEvent({
@@ -142,38 +146,32 @@ describe("Secrets", function() {
         alice.stopClient();
     });
 
-    it("should throw if given a key that doesn't exist", async function() {
-        const alice = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should throw if given a key that doesn't exist", async function () {
+        const alice = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
 
         try {
             await alice.storeSecret("foo", "bar", ["this secret does not exist"]);
             // should be able to use expect(...).toThrow() but mocha still fails
             // the test even when it throws for reasons I have no inclination to debug
             expect(true).toBeFalsy();
-        } catch (e) {
-        }
+        } catch (e) {}
         alice.stopClient();
     });
 
-    it("should refuse to encrypt with zero keys", async function() {
-        const alice = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should refuse to encrypt with zero keys", async function () {
+        const alice = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
 
         try {
             await alice.storeSecret("foo", "bar", []);
             expect(true).toBeFalsy();
-        } catch (e) {
-        }
+        } catch (e) {}
         alice.stopClient();
     });
 
-    it("should encrypt with default key if keys is null", async function() {
+    it("should encrypt with default key if keys is null", async function () {
         const key = new Uint8Array(16);
         for (let i = 0; i < 16; i++) key[i] = i;
-        const getKey = jest.fn().mockImplementation(async e => {
+        const getKey = jest.fn().mockImplementation(async (e) => {
             expect(Object.keys(e.keys)).toEqual([newKeyId]);
             return [newKeyId, key];
         });
@@ -183,13 +181,13 @@ describe("Secrets", function() {
             { userId: "@alice:example.com", deviceId: "Osborne2" },
             {
                 cryptoCallbacks: {
-                    getCrossSigningKey: t => Promise.resolve(keys[t]),
-                    saveCrossSigningKeys: k => keys = k,
+                    getCrossSigningKey: (t) => Promise.resolve(keys[t]),
+                    saveCrossSigningKeys: (k) => (keys = k),
                     getSecretStorageKey: getKey,
                 },
             },
         );
-        alice.setAccountData = async function(eventType, contents) {
+        alice.setAccountData = async function (eventType, contents) {
             alice.store.storeAccountDataEvents([
                 new MatrixEvent({
                     type: eventType,
@@ -200,33 +198,31 @@ describe("Secrets", function() {
         };
         resetCrossSigningKeys(alice);
 
-        const { keyId: newKeyId } = await alice.addSecretStorageKey(
-            SECRET_STORAGE_ALGORITHM_V1_AES, { pubkey: undefined, key: undefined },
-        );
+        const { keyId: newKeyId } = await alice.addSecretStorageKey(SECRET_STORAGE_ALGORITHM_V1_AES, {
+            pubkey: undefined,
+            key: undefined,
+        });
         // we don't await on this because it waits for the event to come down the sync
         // which won't happen in the test setup
         alice.setDefaultSecretStorageKeyId(newKeyId);
         await alice.storeSecret("foo", "bar");
 
-        const accountData = alice.getAccountData('foo');
+        const accountData = alice.getAccountData("foo");
         expect(accountData!.getContent().encrypted).toBeTruthy();
         alice.stopClient();
     });
 
-    it("should refuse to encrypt if no keys given and no default key", async function() {
-        const alice = await makeTestClient(
-            { userId: "@alice:example.com", deviceId: "Osborne2" },
-        );
+    it("should refuse to encrypt if no keys given and no default key", async function () {
+        const alice = await makeTestClient({ userId: "@alice:example.com", deviceId: "Osborne2" });
 
         try {
             await alice.storeSecret("foo", "bar");
             expect(true).toBeFalsy();
-        } catch (e) {
-        }
+        } catch (e) {}
         alice.stopClient();
     });
 
-    it("should request secrets from other clients", async function() {
+    it("should request secrets from other clients", async function () {
         const [[osborne2, vax], clearTestClientTimeouts] = await makeTestClients(
             [
                 { userId: "@alice:example.com", deviceId: "Osborne2" },
@@ -247,7 +243,7 @@ describe("Secrets", function() {
         const secretStorage = osborne2.client.crypto!.secretStorage;
 
         osborne2.client.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
-            "VAX": {
+            VAX: {
                 known: false,
                 algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
                 keys: {
@@ -258,7 +254,7 @@ describe("Secrets", function() {
             },
         });
         vax.client.crypto!.deviceList.storeDevicesForUser("@alice:example.com", {
-            "Osborne2": {
+            Osborne2: {
                 algorithms: [olmlib.OLM_ALGORITHM, olmlib.MEGOLM_ALGORITHM],
                 verified: 0,
                 known: false,
@@ -289,30 +285,20 @@ describe("Secrets", function() {
         clearTestClientTimeouts();
     });
 
-    describe("bootstrap", function() {
+    describe("bootstrap", function () {
         // keys used in some of the tests
-        const XSK = new Uint8Array(
-            olmlib.decodeBase64("3lo2YdJugHjfE+Or7KJ47NuKbhE7AAGLgQ/dc19913Q="),
-        );
+        const XSK = new Uint8Array(olmlib.decodeBase64("3lo2YdJugHjfE+Or7KJ47NuKbhE7AAGLgQ/dc19913Q="));
         const XSPubKey = "DRb8pFVJyEJ9OWvXeUoM0jq/C2Wt+NxzBZVuk2nRb+0";
-        const USK = new Uint8Array(
-            olmlib.decodeBase64("lKWi3hJGUie5xxHgySoz8PHFnZv6wvNaud/p2shN9VU="),
-        );
+        const USK = new Uint8Array(olmlib.decodeBase64("lKWi3hJGUie5xxHgySoz8PHFnZv6wvNaud/p2shN9VU="));
         const USPubKey = "CUpoiTtHiyXpUmd+3ohb7JVxAlUaOG1NYs9Jlx8soQU";
-        const SSK = new Uint8Array(
-            olmlib.decodeBase64("1R6JVlXX99UcfUZzKuCDGQgJTw8ur1/ofgPD8pp+96M="),
-        );
+        const SSK = new Uint8Array(olmlib.decodeBase64("1R6JVlXX99UcfUZzKuCDGQgJTw8ur1/ofgPD8pp+96M="));
         const SSPubKey = "0DfNsRDzEvkCLA0gD3m7VAGJ5VClhjEsewI35xq873Q";
-        const SSSSKey = new Uint8Array(
-            olmlib.decodeBase64(
-                "XrmITOOdBhw6yY5Bh7trb/bgp1FRdIGyCUxxMP873R0=",
-            ),
-        );
+        const SSSSKey = new Uint8Array(olmlib.decodeBase64("XrmITOOdBhw6yY5Bh7trb/bgp1FRdIGyCUxxMP873R0="));
 
-        it("bootstraps when no storage or cross-signing keys locally", async function() {
+        it("bootstraps when no storage or cross-signing keys locally", async function () {
             const key = new Uint8Array(16);
             for (let i = 0; i < 16; i++) key[i] = i;
-            const getKey = jest.fn().mockImplementation(async e => {
+            const getKey = jest.fn().mockImplementation(async (e) => {
                 return [Object.keys(e.keys)[0], key];
             });
 
@@ -329,20 +315,20 @@ describe("Secrets", function() {
             );
             bob.uploadDeviceSigningKeys = async () => ({});
             bob.uploadKeySignatures = jest.fn().mockResolvedValue(undefined);
-            bob.setAccountData = async function(eventType, contents) {
+            bob.setAccountData = async function (eventType, contents) {
                 const event = new MatrixEvent({
                     type: eventType,
                     content: contents,
                 });
-                this.store.storeAccountDataEvents([
-                    event,
-                ]);
+                this.store.storeAccountDataEvents([event]);
                 this.emit(ClientEvent.AccountData, event);
                 return {};
             };
 
             await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async func => { await func({}); },
+                authUploadDeviceSigningKeys: async (func) => {
+                    await func({});
+                },
             });
             await bob.bootstrapSecretStorage({
                 createSecretStorageKey,
@@ -352,13 +338,12 @@ describe("Secrets", function() {
             const secretStorage = bob.crypto!.secretStorage;
 
             expect(crossSigning.getId()).toBeTruthy();
-            expect(await crossSigning.isStoredInSecretStorage(secretStorage))
-                .toBeTruthy();
+            expect(await crossSigning.isStoredInSecretStorage(secretStorage)).toBeTruthy();
             expect(await secretStorage.hasKey()).toBeTruthy();
             bob.stopClient();
         });
 
-        it("bootstraps when cross-signing keys in secret storage", async function() {
+        it("bootstraps when cross-signing keys in secret storage", async function () {
             const decryption = new global.Olm.PkDecryption();
             const storagePublicKey = decryption.generate_key();
             const storagePrivateKey = decryption.get_private_key();
@@ -370,7 +355,7 @@ describe("Secrets", function() {
                 },
                 {
                     cryptoCallbacks: {
-                        getSecretStorageKey: async request => {
+                        getSecretStorageKey: async (request) => {
                             const defaultKeyId = await bob.getDefaultSecretStorageKeyId();
                             expect(Object.keys(request.keys)).toEqual([defaultKeyId]);
                             return [defaultKeyId!, storagePrivateKey];
@@ -381,14 +366,12 @@ describe("Secrets", function() {
 
             bob.uploadDeviceSigningKeys = async () => ({});
             bob.uploadKeySignatures = async () => ({ failures: {} });
-            bob.setAccountData = async function(eventType, contents) {
+            bob.setAccountData = async function (eventType, contents) {
                 const event = new MatrixEvent({
                     type: eventType,
                     content: contents,
                 });
-                this.store.storeAccountDataEvents([
-                    event,
-                ]);
+                this.store.storeAccountDataEvents([event]);
                 this.emit(ClientEvent.AccountData, event);
                 return {};
             };
@@ -399,7 +382,7 @@ describe("Secrets", function() {
 
             // Set up cross-signing keys from scratch with specific storage key
             await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async func => {
+                authUploadDeviceSigningKeys: async (func) => {
                     await func({});
                 },
             });
@@ -412,25 +395,21 @@ describe("Secrets", function() {
             });
 
             // Clear local cross-signing keys and read from secret storage
-            bob.crypto!.deviceList.storeCrossSigningForUser(
-                "@bob:example.com",
-                crossSigning.toStorage(),
-            );
+            bob.crypto!.deviceList.storeCrossSigningForUser("@bob:example.com", crossSigning.toStorage());
             crossSigning.keys = {};
             await bob.bootstrapCrossSigning({
-                authUploadDeviceSigningKeys: async func => {
+                authUploadDeviceSigningKeys: async (func) => {
                     await func({});
                 },
             });
 
             expect(crossSigning.getId()).toBeTruthy();
-            expect(await crossSigning.isStoredInSecretStorage(secretStorage))
-                .toBeTruthy();
+            expect(await crossSigning.isStoredInSecretStorage(secretStorage)).toBeTruthy();
             expect(await secretStorage.hasKey()).toBeTruthy();
             bob.stopClient();
         });
 
-        it("adds passphrase checking if it's lacking", async function() {
+        it("adds passphrase checking if it's lacking", async function () {
             let crossSigningKeys: Record<string, Uint8Array> = {
                 master: XSK,
                 user_signing: USK,
@@ -443,8 +422,8 @@ describe("Secrets", function() {
                 { userId: "@alice:example.com", deviceId: "Osborne2" },
                 {
                     cryptoCallbacks: {
-                        getCrossSigningKey: async t => crossSigningKeys[t],
-                        saveCrossSigningKeys: k => crossSigningKeys = k,
+                        getCrossSigningKey: async (t) => crossSigningKeys[t],
+                        saveCrossSigningKeys: (k) => (crossSigningKeys = k),
                         getSecretStorageKey: async ({ keys }, name) => {
                             for (const keyId of Object.keys(keys)) {
                                 if (secretStorageKeys[keyId]) {
@@ -512,32 +491,44 @@ describe("Secrets", function() {
                             [`ed25519:${XSPubKey}`]: XSPubKey,
                         },
                     },
-                    self_signing: sign<ICrossSigningKey>({
-                        user_id: "@alice:example.com",
-                        usage: ["self_signing"],
-                        keys: {
-                            [`ed25519:${SSPubKey}`]: SSPubKey,
+                    self_signing: sign<ICrossSigningKey>(
+                        {
+                            user_id: "@alice:example.com",
+                            usage: ["self_signing"],
+                            keys: {
+                                [`ed25519:${SSPubKey}`]: SSPubKey,
+                            },
                         },
-                    }, XSK, "@alice:example.com"),
-                    user_signing: sign<ICrossSigningKey>({
-                        user_id: "@alice:example.com",
-                        usage: ["user_signing"],
-                        keys: {
-                            [`ed25519:${USPubKey}`]: USPubKey,
+                        XSK,
+                        "@alice:example.com",
+                    ),
+                    user_signing: sign<ICrossSigningKey>(
+                        {
+                            user_id: "@alice:example.com",
+                            usage: ["user_signing"],
+                            keys: {
+                                [`ed25519:${USPubKey}`]: USPubKey,
+                            },
                         },
-                    }, XSK, "@alice:example.com"),
+                        XSK,
+                        "@alice:example.com",
+                    ),
                 },
             });
             alice.getKeyBackupVersion = async () => {
                 return {
                     version: "1",
                     algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
-                    auth_data: sign({
-                        public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
-                    }, XSK, "@alice:example.com"),
+                    auth_data: sign(
+                        {
+                            public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
+                        },
+                        XSK,
+                        "@alice:example.com",
+                    ),
                 };
             };
-            alice.setAccountData = async function(name, data) {
+            alice.setAccountData = async function (name, data) {
                 const event = new MatrixEvent({
                     type: name,
                     content: data,
@@ -549,11 +540,9 @@ describe("Secrets", function() {
 
             await alice.bootstrapSecretStorage({});
 
-            expect(alice.getAccountData("m.secret_storage.default_key")!.getContent())
-                .toEqual({ key: "key_id" });
+            expect(alice.getAccountData("m.secret_storage.default_key")!.getContent()).toEqual({ key: "key_id" });
             const keyInfo = alice.getAccountData("m.secret_storage.key.key_id")!.getContent<ISecretStorageKeyInfo>();
-            expect(keyInfo.algorithm)
-                .toEqual("m.secret_storage.v1.aes-hmac-sha2");
+            expect(keyInfo.algorithm).toEqual("m.secret_storage.v1.aes-hmac-sha2");
             expect(keyInfo.passphrase).toEqual({
                 algorithm: "m.pbkdf2",
                 iterations: 500000,
@@ -561,11 +550,10 @@ describe("Secrets", function() {
             });
             expect(keyInfo).toHaveProperty("iv");
             expect(keyInfo).toHaveProperty("mac");
-            expect(alice.checkSecretStorageKey(secretStorageKeys.key_id, keyInfo))
-                .toBeTruthy();
+            expect(alice.checkSecretStorageKey(secretStorageKeys.key_id, keyInfo)).toBeTruthy();
             alice.stopClient();
         });
-        it("fixes backup keys in the wrong format", async function() {
+        it("fixes backup keys in the wrong format", async function () {
             let crossSigningKeys: Record<string, Uint8Array> = {
                 master: XSK,
                 user_signing: USK,
@@ -578,8 +566,8 @@ describe("Secrets", function() {
                 { userId: "@alice:example.com", deviceId: "Osborne2" },
                 {
                     cryptoCallbacks: {
-                        getCrossSigningKey: async t => crossSigningKeys[t],
-                        saveCrossSigningKeys: k => crossSigningKeys = k,
+                        getCrossSigningKey: async (t) => crossSigningKeys[t],
+                        saveCrossSigningKeys: (k) => (crossSigningKeys = k),
                         getSecretStorageKey: async ({ keys }, name) => {
                             for (const keyId of Object.keys(keys)) {
                                 if (secretStorageKeys[keyId]) {
@@ -639,7 +627,8 @@ describe("Secrets", function() {
                         encrypted: {
                             key_id: await encryptAES(
                                 "123,45,6,7,89,1,234,56,78,90,12,34,5,67,8,90",
-                                secretStorageKeys.key_id, "m.megolm_backup.v1",
+                                secretStorageKeys.key_id,
+                                "m.megolm_backup.v1",
                             ),
                         },
                     },
@@ -656,32 +645,44 @@ describe("Secrets", function() {
                             [`ed25519:${XSPubKey}`]: XSPubKey,
                         },
                     },
-                    self_signing: sign<ICrossSigningKey>({
-                        user_id: "@alice:example.com",
-                        usage: ["self_signing"],
-                        keys: {
-                            [`ed25519:${SSPubKey}`]: SSPubKey,
+                    self_signing: sign<ICrossSigningKey>(
+                        {
+                            user_id: "@alice:example.com",
+                            usage: ["self_signing"],
+                            keys: {
+                                [`ed25519:${SSPubKey}`]: SSPubKey,
+                            },
                         },
-                    }, XSK, "@alice:example.com"),
-                    user_signing: sign<ICrossSigningKey>({
-                        user_id: "@alice:example.com",
-                        usage: ["user_signing"],
-                        keys: {
-                            [`ed25519:${USPubKey}`]: USPubKey,
+                        XSK,
+                        "@alice:example.com",
+                    ),
+                    user_signing: sign<ICrossSigningKey>(
+                        {
+                            user_id: "@alice:example.com",
+                            usage: ["user_signing"],
+                            keys: {
+                                [`ed25519:${USPubKey}`]: USPubKey,
+                            },
                         },
-                    }, XSK, "@alice:example.com"),
+                        XSK,
+                        "@alice:example.com",
+                    ),
                 },
             });
             alice.getKeyBackupVersion = async () => {
                 return {
                     version: "1",
                     algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
-                    auth_data: sign({
-                        public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
-                    }, XSK, "@alice:example.com"),
+                    auth_data: sign(
+                        {
+                            public_key: "pxEXhg+4vdMf/kFwP4bVawFWdb0EmytL3eFJx++zQ0A",
+                        },
+                        XSK,
+                        "@alice:example.com",
+                    ),
                 };
             };
-            alice.setAccountData = async function(name, data) {
+            alice.setAccountData = async function (name, data) {
                 const event = new MatrixEvent({
                     type: name,
                     content: data,
@@ -695,8 +696,7 @@ describe("Secrets", function() {
 
             const backupKey = alice.getAccountData("m.megolm_backup.v1")!.getContent();
             expect(backupKey.encrypted).toHaveProperty("key_id");
-            expect(await alice.getSecret("m.megolm_backup.v1"))
-                .toEqual("ey0GB1kB6jhOWgwiBUMIWg==");
+            expect(await alice.getSecret("m.megolm_backup.v1")).toEqual("ey0GB1kB6jhOWgwiBUMIWg==");
             alice.stopClient();
         });
     });
diff --git a/spec/unit/crypto/verification/InRoomChannel.spec.ts b/spec/unit/crypto/verification/InRoomChannel.spec.ts
index c6f9db33997..562c83b04a3 100644
--- a/spec/unit/crypto/verification/InRoomChannel.spec.ts
+++ b/spec/unit/crypto/verification/InRoomChannel.spec.ts
@@ -17,15 +17,17 @@ import { MatrixClient } from "../../../../src/client";
 import { InRoomChannel } from "../../../../src/crypto/verification/request/InRoomChannel";
 import { MatrixEvent } from "../../../../src/models/event";
 
-describe("InRoomChannel tests", function() {
+describe("InRoomChannel tests", function () {
     const ALICE = "@alice:hs.tld";
     const BOB = "@bob:hs.tld";
     const MALORY = "@malory:hs.tld";
     const client = {
-        getUserId() { return ALICE; },
+        getUserId() {
+            return ALICE;
+        },
     } as unknown as MatrixClient;
 
-    it("getEventType only returns .request for a message with a msgtype", function() {
+    it("getEventType only returns .request for a message with a msgtype", function () {
         const invalidEvent = new MatrixEvent({
             type: "m.key.verification.request",
         });
@@ -34,34 +36,29 @@ describe("InRoomChannel tests", function() {
             type: "m.room.message",
             content: { msgtype: "m.key.verification.request" },
         });
-        expect(InRoomChannel.getEventType(validEvent)).
-            toStrictEqual("m.key.verification.request");
+        expect(InRoomChannel.getEventType(validEvent)).toStrictEqual("m.key.verification.request");
         const validFooEvent = new MatrixEvent({ type: "m.foo" });
-        expect(InRoomChannel.getEventType(validFooEvent)).
-            toStrictEqual("m.foo");
+        expect(InRoomChannel.getEventType(validFooEvent)).toStrictEqual("m.foo");
     });
 
-    it("getEventType should return m.room.message for messages", function() {
+    it("getEventType should return m.room.message for messages", function () {
         const messageEvent = new MatrixEvent({
             type: "m.room.message",
             content: { msgtype: "m.text" },
         });
         // XXX: The event type doesn't matter too much, just as long as it's not a verification event
-        expect(InRoomChannel.getEventType(messageEvent)).
-            toStrictEqual("m.room.message");
+        expect(InRoomChannel.getEventType(messageEvent)).toStrictEqual("m.room.message");
     });
 
-    it("getEventType should return actual type for non-message events", function() {
+    it("getEventType should return actual type for non-message events", function () {
         const event = new MatrixEvent({
             type: "m.room.member",
-            content: { },
+            content: {},
         });
-        expect(InRoomChannel.getEventType(event)).
-            toStrictEqual("m.room.member");
+        expect(InRoomChannel.getEventType(event)).toStrictEqual("m.room.member");
     });
 
-    it("getOtherPartyUserId should not return anything for a request not " +
-        "directed at me", function() {
+    it("getOtherPartyUserId should not return anything for a request not " + "directed at me", function () {
         const event = new MatrixEvent({
             sender: BOB,
             type: "m.room.message",
@@ -70,29 +67,25 @@ describe("InRoomChannel tests", function() {
         expect(InRoomChannel.getOtherPartyUserId(event, client)).toStrictEqual(undefined);
     });
 
-    it("getOtherPartyUserId should not return anything an event that is not of a valid " +
-        "request type", function() {
+    it("getOtherPartyUserId should not return anything an event that is not of a valid " + "request type", function () {
         // invalid because this should be a room message with msgtype
         const invalidRequest = new MatrixEvent({
             sender: BOB,
             type: "m.key.verification.request",
             content: { to: ALICE },
         });
-        expect(InRoomChannel.getOtherPartyUserId(invalidRequest, client))
-            .toStrictEqual(undefined);
+        expect(InRoomChannel.getOtherPartyUserId(invalidRequest, client)).toStrictEqual(undefined);
         const startEvent = new MatrixEvent({
             sender: BOB,
             type: "m.key.verification.start",
             content: { to: ALICE },
         });
-        expect(InRoomChannel.getOtherPartyUserId(startEvent, client))
-            .toStrictEqual(undefined);
+        expect(InRoomChannel.getOtherPartyUserId(startEvent, client)).toStrictEqual(undefined);
         const fooEvent = new MatrixEvent({
             sender: BOB,
             type: "m.foo",
             content: { to: ALICE },
         });
-        expect(InRoomChannel.getOtherPartyUserId(fooEvent, client))
-            .toStrictEqual(undefined);
+        expect(InRoomChannel.getOtherPartyUserId(fooEvent, client)).toStrictEqual(undefined);
     });
 });
diff --git a/spec/unit/crypto/verification/qr_code.spec.ts b/spec/unit/crypto/verification/qr_code.spec.ts
index 33fa2405c1d..7d2fc9171d1 100644
--- a/spec/unit/crypto/verification/qr_code.spec.ts
+++ b/spec/unit/crypto/verification/qr_code.spec.ts
@@ -19,13 +19,13 @@ import { logger } from "../../../../src/logger";
 
 const Olm = global.Olm;
 
-describe("QR code verification", function() {
+describe("QR code verification", function () {
     if (!global.Olm) {
-        logger.warn('Not running device verification tests: libolm not present');
+        logger.warn("Not running device verification tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
diff --git a/spec/unit/crypto/verification/request.spec.ts b/spec/unit/crypto/verification/request.spec.ts
index be957989a6d..63989c77c40 100644
--- a/spec/unit/crypto/verification/request.spec.ts
+++ b/spec/unit/crypto/verification/request.spec.ts
@@ -18,23 +18,23 @@ import "../../../olm-loader";
 import { CryptoEvent, verificationMethods } from "../../../../src/crypto";
 import { logger } from "../../../../src/logger";
 import { SAS } from "../../../../src/crypto/verification/SAS";
-import { makeTestClients } from './util';
+import { makeTestClients } from "./util";
 
 const Olm = global.Olm;
 
 jest.useFakeTimers();
 
-describe("verification request integration tests with crypto layer", function() {
+describe("verification request integration tests with crypto layer", function () {
     if (!global.Olm) {
-        logger.warn('Not running device verification unit tests: libolm not present');
+        logger.warn("Not running device verification unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
-    it("should request and accept a verification", async function() {
+    it("should request and accept a verification", async function () {
         const [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
             [
                 { userId: "@alice:example.com", deviceId: "Osborne2" },
@@ -44,7 +44,7 @@ describe("verification request integration tests with crypto layer", function()
                 verificationMethods: [verificationMethods.SAS],
             },
         );
-        alice.client.crypto!.deviceList.getRawStoredDevicesForUser = function() {
+        alice.client.crypto!.deviceList.getRawStoredDevicesForUser = function () {
             return {
                 Dynabook: {
                     algorithms: [],
@@ -66,7 +66,7 @@ describe("verification request integration tests with crypto layer", function()
             bobVerifier.endTimer();
         });
         const aliceRequest = await alice.client.requestVerification("@bob:example.com");
-        await aliceRequest.waitFor(r => r.started);
+        await aliceRequest.waitFor((r) => r.started);
         const aliceVerifier = aliceRequest.verifier;
         expect(aliceVerifier).toBeInstanceOf(SAS);
 
diff --git a/spec/unit/crypto/verification/sas.spec.ts b/spec/unit/crypto/verification/sas.spec.ts
index 2d05b31b2c3..5309c0d80f7 100644
--- a/spec/unit/crypto/verification/sas.spec.ts
+++ b/spec/unit/crypto/verification/sas.spec.ts
@@ -15,7 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import "../../../olm-loader";
-import { makeTestClients } from './util';
+import { makeTestClients } from "./util";
 import { MatrixEvent } from "../../../../src/models/event";
 import { ISasEvent, SAS, SasEvent } from "../../../../src/crypto/verification/SAS";
 import { DeviceInfo, IDevice } from "../../../../src/crypto/deviceinfo";
@@ -34,40 +34,42 @@ const Olm = global.Olm;
 let ALICE_DEVICES: Record<string, IDevice>;
 let BOB_DEVICES: Record<string, IDevice>;
 
-describe("SAS verification", function() {
+describe("SAS verification", function () {
     if (!global.Olm) {
-        logger.warn('Not running device verification unit tests: libolm not present');
+        logger.warn("Not running device verification unit tests: libolm not present");
         return;
     }
 
-    beforeAll(function() {
+    beforeAll(function () {
         return Olm.init();
     });
 
-    it("should error on an unexpected event", async function() {
+    it("should error on an unexpected event", async function () {
         //channel, baseApis, userId, deviceId, startEvent, request
         const request = {
-            onVerifierCancelled: function() {},
+            onVerifierCancelled: function () {},
         } as VerificationRequest;
         const channel = {
-            send: function() {
+            send: function () {
                 return Promise.resolve();
             },
         } as unknown as IVerificationChannel;
         const mockClient = {} as unknown as MatrixClient;
-        const event = new MatrixEvent({ type: 'test' });
+        const event = new MatrixEvent({ type: "test" });
         const sas = new SAS(channel, mockClient, "@alice:example.com", "ABCDEFG", event, request);
-        sas.handleEvent(new MatrixEvent({
-            sender: "@alice:example.com",
-            type: "es.inquisition",
-            content: {},
-        }));
+        sas.handleEvent(
+            new MatrixEvent({
+                sender: "@alice:example.com",
+                type: "es.inquisition",
+                content: {},
+            }),
+        );
         const spy = jest.fn();
         await sas.verify().catch(spy);
         expect(spy).toHaveBeenCalled();
 
         // Cancel the SAS for cleanup (we started a verification, so abort)
-        sas.cancel(new Error('error'));
+        sas.cancel(new Error("error"));
     });
 
     describe("verification", () => {
@@ -117,16 +119,12 @@ describe("SAS verification", function() {
                 },
             };
 
-            alice.client.crypto!.deviceList.storeDevicesForUser(
-                "@bob:example.com", BOB_DEVICES,
-            );
+            alice.client.crypto!.deviceList.storeDevicesForUser("@bob:example.com", BOB_DEVICES);
             alice.client.downloadKeys = () => {
                 return Promise.resolve({});
             };
 
-            bob.client.crypto!.deviceList.storeDevicesForUser(
-                "@alice:example.com", ALICE_DEVICES,
-            );
+            bob.client.crypto!.deviceList.storeDevicesForUser("@alice:example.com", ALICE_DEVICES);
             bob.client.downloadKeys = () => {
                 return Promise.resolve({});
             };
@@ -135,7 +133,7 @@ describe("SAS verification", function() {
             bobSasEvent = null;
 
             bobPromise = new Promise<VerificationBase<any, any>>((resolve, reject) => {
-                bob.client.on(CryptoEvent.VerificationRequest, request => {
+                bob.client.on(CryptoEvent.VerificationRequest, (request) => {
                     (<SAS>request.verifier!).on(SasEvent.ShowSas, (e) => {
                         if (!e.sas.emoji || !e.sas.decimal) {
                             e.cancel();
@@ -157,7 +155,9 @@ describe("SAS verification", function() {
             });
 
             aliceVerifier = alice.client.beginKeyVerification(
-                verificationMethods.SAS, bob.client.getUserId()!, bob.deviceId!,
+                verificationMethods.SAS,
+                bob.client.getUserId()!,
+                bob.deviceId!,
             ) as SAS;
             aliceVerifier.on(SasEvent.ShowSas, (e) => {
                 if (!e.sas.emoji || !e.sas.decimal) {
@@ -177,10 +177,7 @@ describe("SAS verification", function() {
             });
         });
         afterEach(async () => {
-            await Promise.all([
-                alice.stop(),
-                bob.stop(),
-            ]);
+            await Promise.all([alice.stop(), bob.stop()]);
 
             clearTestClientTimeouts();
         });
@@ -189,23 +186,21 @@ describe("SAS verification", function() {
             let macMethod;
             let keyAgreement;
             const origSendToDevice = bob.client.sendToDevice.bind(bob.client);
-            bob.client.sendToDevice = function(type, map) {
+            bob.client.sendToDevice = function (type, map) {
                 if (type === "m.key.verification.accept") {
-                    macMethod = map[alice.client.getUserId()!][alice.client.deviceId!]
-                        .message_authentication_code;
-                    keyAgreement = map[alice.client.getUserId()!][alice.client.deviceId!]
-                        .key_agreement_protocol;
+                    macMethod = map[alice.client.getUserId()!][alice.client.deviceId!].message_authentication_code;
+                    keyAgreement = map[alice.client.getUserId()!][alice.client.deviceId!].key_agreement_protocol;
                 }
                 return origSendToDevice(type, map);
             };
 
-            alice.httpBackend.when('POST', '/keys/query').respond(200, {
+            alice.httpBackend.when("POST", "/keys/query").respond(200, {
                 failures: {},
                 device_keys: {
                     "@bob:example.com": BOB_DEVICES,
                 },
             });
-            bob.httpBackend.when('POST', '/keys/query').respond(200, {
+            bob.httpBackend.when("POST", "/keys/query").respond(200, {
                 failures: {},
                 device_keys: {
                     "@alice:example.com": ALICE_DEVICES,
@@ -224,11 +219,9 @@ describe("SAS verification", function() {
             expect(keyAgreement).toBe("curve25519-hkdf-sha256");
 
             // make sure Alice and Bob verified each other
-            const bobDevice
-                  = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
+            const bobDevice = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
             expect(bobDevice?.isVerified()).toBeTruthy();
-            const aliceDevice
-                  = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
+            const aliceDevice = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
             expect(aliceDevice?.isVerified()).toBeTruthy();
         });
 
@@ -244,27 +237,27 @@ describe("SAS verification", function() {
                     // has, since it is the same object.  If this does not
                     // happen, the verification will fail due to a hash
                     // commitment mismatch.
-                    map[bob.client.getUserId()!][bob.client.deviceId!]
-                        .message_authentication_codes = ['hkdf-hmac-sha256'];
+                    map[bob.client.getUserId()!][bob.client.deviceId!].message_authentication_codes = [
+                        "hkdf-hmac-sha256",
+                    ];
                 }
                 return aliceOrigSendToDevice(type, map);
             };
             const bobOrigSendToDevice = bob.client.sendToDevice.bind(bob.client);
             bob.client.sendToDevice = (type, map) => {
                 if (type === "m.key.verification.accept") {
-                    macMethod = map[alice.client.getUserId()!][alice.client.deviceId!]
-                        .message_authentication_code;
+                    macMethod = map[alice.client.getUserId()!][alice.client.deviceId!].message_authentication_code;
                 }
                 return bobOrigSendToDevice(type, map);
             };
 
-            alice.httpBackend.when('POST', '/keys/query').respond(200, {
+            alice.httpBackend.when("POST", "/keys/query").respond(200, {
                 failures: {},
                 device_keys: {
                     "@bob:example.com": BOB_DEVICES,
                 },
             });
-            bob.httpBackend.when('POST', '/keys/query').respond(200, {
+            bob.httpBackend.when("POST", "/keys/query").respond(200, {
                 failures: {},
                 device_keys: {
                     "@alice:example.com": ALICE_DEVICES,
@@ -280,11 +273,9 @@ describe("SAS verification", function() {
 
             expect(macMethod).toBe("hkdf-hmac-sha256");
 
-            const bobDevice
-                  = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
+            const bobDevice = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
             expect(bobDevice!.isVerified()).toBeTruthy();
-            const aliceDevice
-                  = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
+            const aliceDevice = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
             expect(aliceDevice!.isVerified()).toBeTruthy();
         });
 
@@ -300,27 +291,25 @@ describe("SAS verification", function() {
                     // has, since it is the same object.  If this does not
                     // happen, the verification will fail due to a hash
                     // commitment mismatch.
-                    map[bob.client.getUserId()!][bob.client.deviceId!]
-                        .message_authentication_codes = ['hmac-sha256'];
+                    map[bob.client.getUserId()!][bob.client.deviceId!].message_authentication_codes = ["hmac-sha256"];
                 }
                 return aliceOrigSendToDevice(type, map);
             };
             const bobOrigSendToDevice = bob.client.sendToDevice.bind(bob.client);
             bob.client.sendToDevice = (type, map) => {
                 if (type === "m.key.verification.accept") {
-                    macMethod = map[alice.client.getUserId()!][alice.client.deviceId!]
-                        .message_authentication_code;
+                    macMethod = map[alice.client.getUserId()!][alice.client.deviceId!].message_authentication_code;
                 }
                 return bobOrigSendToDevice(type, map);
             };
 
-            alice.httpBackend.when('POST', '/keys/query').respond(200, {
+            alice.httpBackend.when("POST", "/keys/query").respond(200, {
                 failures: {},
                 device_keys: {
                     "@bob:example.com": BOB_DEVICES,
                 },
             });
-            bob.httpBackend.when('POST', '/keys/query').respond(200, {
+            bob.httpBackend.when("POST", "/keys/query").respond(200, {
                 failures: {},
                 device_keys: {
                     "@alice:example.com": ALICE_DEVICES,
@@ -336,41 +325,33 @@ describe("SAS verification", function() {
 
             expect(macMethod).toBe("hmac-sha256");
 
-            const bobDevice
-                  = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
+            const bobDevice = await alice.client.getStoredDevice("@bob:example.com", "Dynabook");
             expect(bobDevice?.isVerified()).toBeTruthy();
-            const aliceDevice
-                  = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
+            const aliceDevice = await bob.client.getStoredDevice("@alice:example.com", "Osborne2");
             expect(aliceDevice?.isVerified()).toBeTruthy();
         });
 
         it("should verify a cross-signing key", async () => {
-            alice.httpBackend.when('POST', '/keys/device_signing/upload').respond(
-                200, {},
-            );
-            alice.httpBackend.when('POST', '/keys/signatures/upload').respond(200, {});
+            alice.httpBackend.when("POST", "/keys/device_signing/upload").respond(200, {});
+            alice.httpBackend.when("POST", "/keys/signatures/upload").respond(200, {});
             alice.httpBackend.flush(undefined, 2);
             await resetCrossSigningKeys(alice.client);
-            bob.httpBackend.when('POST', '/keys/device_signing/upload').respond(200, {});
-            bob.httpBackend.when('POST', '/keys/signatures/upload').respond(200, {});
+            bob.httpBackend.when("POST", "/keys/device_signing/upload").respond(200, {});
+            bob.httpBackend.when("POST", "/keys/signatures/upload").respond(200, {});
             bob.httpBackend.flush(undefined, 2);
 
             await resetCrossSigningKeys(bob.client);
 
-            bob.client.crypto!.deviceList.storeCrossSigningForUser(
-                "@alice:example.com", {
-                    keys: alice.client.crypto!.crossSigningInfo.keys,
-                    crossSigningVerifiedBefore: false,
-                    firstUse: true,
-                },
-            );
+            bob.client.crypto!.deviceList.storeCrossSigningForUser("@alice:example.com", {
+                keys: alice.client.crypto!.crossSigningInfo.keys,
+                crossSigningVerifiedBefore: false,
+                firstUse: true,
+            });
 
             const verifyProm = Promise.all([
                 aliceVerifier.verify(),
                 bobPromise.then((verifier) => {
-                    bob.httpBackend.when(
-                        'POST', '/keys/signatures/upload',
-                    ).respond(200, {});
+                    bob.httpBackend.when("POST", "/keys/signatures/upload").respond(200, {});
                     bob.httpBackend.flush(undefined, 1, 2000);
                     return verifier.verify();
                 }),
@@ -378,9 +359,7 @@ describe("SAS verification", function() {
 
             await verifyProm;
 
-            const bobDeviceTrust = alice.client.checkDeviceTrust(
-                "@bob:example.com", "Dynabook",
-            );
+            const bobDeviceTrust = alice.client.checkDeviceTrust("@bob:example.com", "Dynabook");
             expect(bobDeviceTrust.isLocallyVerified()).toBeTruthy();
             expect(bobDeviceTrust.isCrossSigningVerified()).toBeFalsy();
 
@@ -388,15 +367,13 @@ describe("SAS verification", function() {
             expect(aliceTrust.isCrossSigningVerified()).toBeTruthy();
             expect(aliceTrust.isTofu()).toBeTruthy();
 
-            const aliceDeviceTrust = bob.client.checkDeviceTrust(
-                "@alice:example.com", "Osborne2",
-            );
+            const aliceDeviceTrust = bob.client.checkDeviceTrust("@alice:example.com", "Osborne2");
             expect(aliceDeviceTrust.isLocallyVerified()).toBeTruthy();
             expect(aliceDeviceTrust.isCrossSigningVerified()).toBeFalsy();
         });
     });
 
-    it("should send a cancellation message on error", async function() {
+    it("should send a cancellation message on error", async function () {
         const [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
             [
                 { userId: "@alice:example.com", deviceId: "Osborne2" },
@@ -412,7 +389,7 @@ describe("SAS verification", function() {
         bob.client.downloadKeys = jest.fn().mockResolvedValue({});
 
         const bobPromise = new Promise<VerificationBase<any, any>>((resolve, reject) => {
-            bob.client.on(CryptoEvent.VerificationRequest, request => {
+            bob.client.on(CryptoEvent.VerificationRequest, (request) => {
                 (<SAS>request.verifier!).on(SasEvent.ShowSas, (e) => {
                     e.mismatch();
                 });
@@ -421,7 +398,9 @@ describe("SAS verification", function() {
         });
 
         const aliceVerifier = alice.client.beginKeyVerification(
-            verificationMethods.SAS, bob.client.getUserId()!, bob.client.deviceId!,
+            verificationMethods.SAS,
+            bob.client.getUserId()!,
+            bob.client.deviceId!,
         );
 
         const aliceSpy = jest.fn();
@@ -432,17 +411,15 @@ describe("SAS verification", function() {
         ]);
         expect(aliceSpy).toHaveBeenCalled();
         expect(bobSpy).toHaveBeenCalled();
-        expect(alice.client.setDeviceVerified)
-            .not.toHaveBeenCalled();
-        expect(bob.client.setDeviceVerified)
-            .not.toHaveBeenCalled();
+        expect(alice.client.setDeviceVerified).not.toHaveBeenCalled();
+        expect(bob.client.setDeviceVerified).not.toHaveBeenCalled();
 
         alice.stop();
         bob.stop();
         clearTestClientTimeouts();
     });
 
-    describe("verification in DM", function() {
+    describe("verification in DM", function () {
         let alice: TestClient;
         let bob: TestClient;
         let aliceSasEvent: ISasEvent | null;
@@ -451,7 +428,7 @@ describe("SAS verification", function() {
         let bobPromise: Promise<void>;
         let clearTestClientTimeouts: Function;
 
-        beforeEach(async function() {
+        beforeEach(async function () {
             [[alice, bob], clearTestClientTimeouts] = await makeTestClients(
                 [
                     { userId: "@alice:example.com", deviceId: "Osborne2" },
@@ -526,7 +503,7 @@ describe("SAS verification", function() {
             });
 
             const aliceRequest = await alice.client.requestVerificationDM(bob.client.getUserId()!, "!room_id");
-            await aliceRequest.waitFor(r => r.started);
+            await aliceRequest.waitFor((r) => r.started);
             aliceVerifier = aliceRequest.verifier! as SAS;
             aliceVerifier.on(SasEvent.ShowSas, (e) => {
                 if (!e.sas.emoji || !e.sas.decimal) {
@@ -545,40 +522,32 @@ describe("SAS verification", function() {
                 }
             });
         });
-        afterEach(async function() {
-            await Promise.all([
-                alice.stop(),
-                bob.stop(),
-            ]);
+        afterEach(async function () {
+            await Promise.all([alice.stop(), bob.stop()]);
 
             clearTestClientTimeouts();
         });
 
-        it("should verify a key", async function() {
-            await Promise.all([
-                aliceVerifier.verify(),
-                bobPromise,
-            ]);
+        it("should verify a key", async function () {
+            await Promise.all([aliceVerifier.verify(), bobPromise]);
 
             // make sure Alice and Bob verified each other
-            expect(alice.client.crypto!.setDeviceVerification)
-                .toHaveBeenCalledWith(
-                    bob.client.getUserId(),
-                    bob.client.deviceId,
-                    true,
-                    null,
-                    null,
-                    { "ed25519:Dynabook": "bob+base64+ed25519+key" },
-                );
-            expect(bob.client.crypto!.setDeviceVerification)
-                .toHaveBeenCalledWith(
-                    alice.client.getUserId(),
-                    alice.client.deviceId,
-                    true,
-                    null,
-                    null,
-                    { "ed25519:Osborne2": "alice+base64+ed25519+key" },
-                );
+            expect(alice.client.crypto!.setDeviceVerification).toHaveBeenCalledWith(
+                bob.client.getUserId(),
+                bob.client.deviceId,
+                true,
+                null,
+                null,
+                { "ed25519:Dynabook": "bob+base64+ed25519+key" },
+            );
+            expect(bob.client.crypto!.setDeviceVerification).toHaveBeenCalledWith(
+                alice.client.getUserId(),
+                alice.client.deviceId,
+                true,
+                null,
+                null,
+                { "ed25519:Osborne2": "alice+base64+ed25519+key" },
+            );
         });
     });
 });
diff --git a/spec/unit/crypto/verification/secret_request.spec.ts b/spec/unit/crypto/verification/secret_request.spec.ts
index 20ea64d4ac3..ff8b15cc629 100644
--- a/spec/unit/crypto/verification/secret_request.spec.ts
+++ b/spec/unit/crypto/verification/secret_request.spec.ts
@@ -14,28 +14,26 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../../olm-loader';
-import { MatrixClient, MatrixEvent } from '../../../../src/matrix';
+import "../../../olm-loader";
+import { MatrixClient, MatrixEvent } from "../../../../src/matrix";
 import { encodeBase64 } from "../../../../src/crypto/olmlib";
 import "../../../../src/crypto"; // import this to cycle-break
-import { CrossSigningInfo } from '../../../../src/crypto/CrossSigning';
-import { VerificationRequest } from '../../../../src/crypto/verification/request/VerificationRequest';
-import { IVerificationChannel } from '../../../../src/crypto/verification/request/Channel';
-import { VerificationBase } from '../../../../src/crypto/verification/Base';
+import { CrossSigningInfo } from "../../../../src/crypto/CrossSigning";
+import { VerificationRequest } from "../../../../src/crypto/verification/request/VerificationRequest";
+import { IVerificationChannel } from "../../../../src/crypto/verification/request/Channel";
+import { VerificationBase } from "../../../../src/crypto/verification/Base";
 
 jest.useFakeTimers();
 
 // Private key for tests only
 const testKey = new Uint8Array([
-    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82,
-    0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef,
-    0xae, 0xb1, 0x05, 0xc1, 0xe7, 0x62, 0x78, 0xa6,
-    0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
+    0xda, 0x5a, 0x27, 0x60, 0xe3, 0x3a, 0xc5, 0x82, 0x9d, 0x12, 0xc3, 0xbe, 0xe8, 0xaa, 0xc2, 0xef, 0xae, 0xb1, 0x05,
+    0xc1, 0xe7, 0x62, 0x78, 0xa6, 0xd7, 0x1f, 0xf8, 0x2c, 0x51, 0x85, 0xf0, 0x1d,
 ]);
 const testKeyPub = "nqOvzeuGWT/sRx3h7+MHoInYj3Uk2LD/unI9kDYcHwk";
 
 describe("self-verifications", () => {
-    beforeAll(function() {
+    beforeAll(function () {
         return global.Olm.init();
     });
 
@@ -47,26 +45,22 @@ describe("self-verifications", () => {
             storeCrossSigningKeyCache: jest.fn(),
         };
 
-        const crossSigningInfo = new CrossSigningInfo(
-            userId,
-            {},
-            cacheCallbacks,
-        );
+        const crossSigningInfo = new CrossSigningInfo(userId, {}, cacheCallbacks);
         crossSigningInfo.keys = {
             master: {
                 keys: { X: testKeyPub },
                 usage: [],
-                user_id: 'user-id',
+                user_id: "user-id",
             },
             self_signing: {
                 keys: { X: testKeyPub },
                 usage: [],
-                user_id: 'user-id',
+                user_id: "user-id",
             },
             user_signing: {
                 keys: { X: testKeyPub },
                 usage: [],
-                user_id: 'user-id',
+                user_id: "user-id",
             },
         };
 
@@ -114,13 +108,10 @@ describe("self-verifications", () => {
         expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls.length).toBe(3);
         expect(secretStorage.request.mock.calls.length).toBe(4);
 
-        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[0][1])
-            .toEqual(testKey);
-        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[1][1])
-            .toEqual(testKey);
+        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[0][1]).toEqual(testKey);
+        expect(cacheCallbacks.storeCrossSigningKeyCache.mock.calls[1][1]).toEqual(testKey);
 
-        expect(storeSessionBackupPrivateKey.mock.calls[0][0])
-            .toEqual(testKey);
+        expect(storeSessionBackupPrivateKey.mock.calls[0][0]).toEqual(testKey);
 
         expect(restoreKeyBackupWithCache).toHaveBeenCalled();
 
diff --git a/spec/unit/crypto/verification/setDeviceVerification.spec.ts b/spec/unit/crypto/verification/setDeviceVerification.spec.ts
index 3d64153ab59..e1c07222663 100644
--- a/spec/unit/crypto/verification/setDeviceVerification.spec.ts
+++ b/spec/unit/crypto/verification/setDeviceVerification.spec.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../../olm-loader';
+import "../../../olm-loader";
 
 import { CRYPTO_ENABLED, MatrixClient } from "../../../../src/client";
 import { TestClient } from "../../../TestClient";
@@ -35,7 +35,7 @@ describe("crypto.setDeviceVerification", () => {
     });
 
     beforeEach(async () => {
-        client = (new TestClient(userId, deviceId1)).client;
+        client = new TestClient(userId, deviceId1).client;
         await client.initCrypto();
     });
 
@@ -46,11 +46,7 @@ describe("crypto.setDeviceVerification", () => {
     describe("when setting an own device as verified", () => {
         beforeEach(async () => {
             jest.spyOn(client.crypto!, "cancelAndResendAllOutgoingKeyRequests");
-            await client.crypto!.setDeviceVerification(
-                userId,
-                deviceId1,
-                true,
-            );
+            await client.crypto!.setDeviceVerification(userId, deviceId1, true);
         });
 
         it("cancelAndResendAllOutgoingKeyRequests should be called", () => {
diff --git a/spec/unit/crypto/verification/util.ts b/spec/unit/crypto/verification/util.ts
index f66d6464f5e..8b478660c1f 100644
--- a/spec/unit/crypto/verification/util.ts
+++ b/spec/unit/crypto/verification/util.ts
@@ -15,12 +15,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { TestClient } from '../../../TestClient';
+import { TestClient } from "../../../TestClient";
 import { IContent, MatrixEvent } from "../../../../src/models/event";
 import { IRoomTimelineData } from "../../../../src/models/event-timeline-set";
 import { Room, RoomEvent } from "../../../../src/models/room";
-import { logger } from '../../../../src/logger';
-import { MatrixClient, ClientEvent, ICreateClientOpts } from '../../../../src/client';
+import { logger } from "../../../../src/logger";
+import { MatrixClient, ClientEvent, ICreateClientOpts } from "../../../../src/client";
 
 interface UserInfo {
     userId: string;
@@ -34,31 +34,31 @@ export async function makeTestClients(
     const clients: TestClient[] = [];
     const timeouts: ReturnType<typeof setTimeout>[] = [];
     const clientMap: Record<string, Record<string, MatrixClient>> = {};
-    const makeSendToDevice = (matrixClient: MatrixClient): MatrixClient['sendToDevice'] => async (type, map) => {
-        // logger.log(this.getUserId(), "sends", type, map);
-        for (const [userId, devMap] of Object.entries(map)) {
-            if (userId in clientMap) {
-                for (const [deviceId, msg] of Object.entries(devMap)) {
-                    if (deviceId in clientMap[userId]) {
-                        const event = new MatrixEvent({
-                            sender: matrixClient.getUserId()!,
-                            type: type,
-                            content: msg,
-                        });
-                        const client = clientMap[userId][deviceId];
-                        const decryptionPromise = event.isEncrypted() ?
-                            event.attemptDecryption(client.crypto!) :
-                            Promise.resolve();
+    const makeSendToDevice =
+        (matrixClient: MatrixClient): MatrixClient["sendToDevice"] =>
+        async (type, map) => {
+            // logger.log(this.getUserId(), "sends", type, map);
+            for (const [userId, devMap] of Object.entries(map)) {
+                if (userId in clientMap) {
+                    for (const [deviceId, msg] of Object.entries(devMap)) {
+                        if (deviceId in clientMap[userId]) {
+                            const event = new MatrixEvent({
+                                sender: matrixClient.getUserId()!,
+                                type: type,
+                                content: msg,
+                            });
+                            const client = clientMap[userId][deviceId];
+                            const decryptionPromise = event.isEncrypted()
+                                ? event.attemptDecryption(client.crypto!)
+                                : Promise.resolve();
 
-                        decryptionPromise.then(
-                            () => client.emit(ClientEvent.ToDeviceEvent, event),
-                        );
+                            decryptionPromise.then(() => client.emit(ClientEvent.ToDeviceEvent, event));
+                        }
                     }
                 }
             }
-        }
-        return {};
-    };
+            return {};
+        };
     const makeSendEvent = (matrixClient: MatrixClient) => (room: string, type: string, content: IContent) => {
         // make up a unique ID as the event ID
         const eventId = "$" + matrixClient.makeTxnId();
@@ -71,15 +71,17 @@ export async function makeTestClients(
             origin_server_ts: Date.now(),
         };
         const event = new MatrixEvent(rawEvent);
-        const remoteEcho = new MatrixEvent(Object.assign({}, rawEvent, {
-            unsigned: {
-                transaction_id: matrixClient.makeTxnId(),
-            },
-        }));
+        const remoteEcho = new MatrixEvent(
+            Object.assign({}, rawEvent, {
+                unsigned: {
+                    transaction_id: matrixClient.makeTxnId(),
+                },
+            }),
+        );
 
         const timeout = setTimeout(() => {
             for (const tc of clients) {
-                const room = new Room('test', tc.client, tc.client.getUserId()!);
+                const room = new Room("test", tc.client, tc.client.getUserId()!);
                 const roomTimelineData = {} as unknown as IRoomTimelineData;
                 if (tc.client === matrixClient) {
                     logger.log("sending remote echo!!");
@@ -100,14 +102,13 @@ export async function makeTestClients(
         if (!options) options = {};
         if (!options.cryptoCallbacks) options.cryptoCallbacks = {};
         if (!options.cryptoCallbacks.saveCrossSigningKeys) {
-            options.cryptoCallbacks.saveCrossSigningKeys = k => { keys = k; };
+            options.cryptoCallbacks.saveCrossSigningKeys = (k) => {
+                keys = k;
+            };
             // @ts-ignore tsc getting confused by overloads
-            options.cryptoCallbacks.getCrossSigningKey = typ => keys[typ];
+            options.cryptoCallbacks.getCrossSigningKey = (typ) => keys[typ];
         }
-        const testClient = new TestClient(
-            userInfo.userId, userInfo.deviceId, undefined, undefined,
-            options,
-        );
+        const testClient = new TestClient(userInfo.userId, userInfo.deviceId, undefined, undefined, options);
         if (!(userInfo.userId in clientMap)) {
             clientMap[userInfo.userId] = {};
         }
diff --git a/spec/unit/crypto/verification/verification_request.spec.ts b/spec/unit/crypto/verification/verification_request.spec.ts
index 2dce928e821..ea6919216a3 100644
--- a/spec/unit/crypto/verification/verification_request.spec.ts
+++ b/spec/unit/crypto/verification/verification_request.spec.ts
@@ -13,11 +13,14 @@ 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 { VerificationRequest, READY_TYPE, START_TYPE, DONE_TYPE } from
-    "../../../../src/crypto/verification/request/VerificationRequest";
+import {
+    VerificationRequest,
+    READY_TYPE,
+    START_TYPE,
+    DONE_TYPE,
+} from "../../../../src/crypto/verification/request/VerificationRequest";
 import { InRoomChannel } from "../../../../src/crypto/verification/request/InRoomChannel";
-import { ToDeviceChannel } from
-    "../../../../src/crypto/verification/request/ToDeviceChannel";
+import { ToDeviceChannel } from "../../../../src/crypto/verification/request/ToDeviceChannel";
 import { IContent, MatrixEvent } from "../../../../src/models/event";
 import { MatrixClient } from "../../../../src/client";
 import { IVerificationChannel } from "../../../../src/crypto/verification/request/Channel";
@@ -32,20 +35,26 @@ function makeMockClient(userId: string, deviceId: string): MockClient {
     let events: MatrixEvent[] = [];
     const deviceEvents: Record<string, Record<string, MatrixEvent[]>> = {};
     return {
-        getUserId() { return userId; },
-        getDeviceId() { return deviceId; },
+        getUserId() {
+            return userId;
+        },
+        getDeviceId() {
+            return deviceId;
+        },
 
         sendEvent(roomId: string, type: string, content: IContent) {
             counter = counter + 1;
             const eventId = `$${userId}-${deviceId}-${counter}`;
-            events.push(new MatrixEvent({
-                sender: userId,
-                event_id: eventId,
-                room_id: roomId,
-                type,
-                content,
-                origin_server_ts: Date.now(),
-            }));
+            events.push(
+                new MatrixEvent({
+                    sender: userId,
+                    event_id: eventId,
+                    room_id: roomId,
+                    type,
+                    content,
+                    origin_server_ts: Date.now(),
+                }),
+            );
             return Promise.resolve({ event_id: eventId });
         },
 
@@ -84,7 +93,7 @@ function makeMockClient(userId: string, deviceId: string): MockClient {
 }
 
 const MOCK_METHOD = "mock-verify";
-class MockVerifier extends VerificationBase<'', any> {
+class MockVerifier extends VerificationBase<"", any> {
     public _channel;
     public _startEvent;
     constructor(
@@ -123,11 +132,13 @@ class MockVerifier extends VerificationBase<'', any> {
 }
 
 function makeRemoteEcho(event: MatrixEvent) {
-    return new MatrixEvent(Object.assign({}, event.event, {
-        unsigned: {
-            transaction_id: "abc",
-        },
-    }));
+    return new MatrixEvent(
+        Object.assign({}, event.event, {
+            unsigned: {
+                transaction_id: "abc",
+            },
+        }),
+    );
 }
 
 async function distributeEvent(
@@ -135,33 +146,26 @@ async function distributeEvent(
     theirRequest: VerificationRequest,
     event: MatrixEvent,
 ): Promise<void> {
-    await ownRequest.channel.handleEvent(
-        makeRemoteEcho(event),
-        ownRequest,
-        true,
-    );
+    await ownRequest.channel.handleEvent(makeRemoteEcho(event), ownRequest, true);
     await theirRequest.channel.handleEvent(event, theirRequest, true);
 }
 
 jest.useFakeTimers();
 
-describe("verification request unit tests", function() {
-    it("transition from UNSENT to DONE through happy path", async function() {
+describe("verification request unit tests", function () {
+    it("transition from UNSENT to DONE through happy path", async function () {
         const alice = makeMockClient("@alice:matrix.tld", "device1");
         const bob = makeMockClient("@bob:matrix.tld", "device1");
-        const verificationMethods = new Map(
-            [[MOCK_METHOD, MockVerifier]],
-        ) as unknown as Map<string, typeof VerificationBase>;
+        const verificationMethods = new Map([[MOCK_METHOD, MockVerifier]]) as unknown as Map<
+            string,
+            typeof VerificationBase
+        >;
         const aliceRequest = new VerificationRequest(
             new InRoomChannel(alice, "!room", bob.getUserId()!),
             verificationMethods,
             alice,
         );
-        const bobRequest = new VerificationRequest(
-            new InRoomChannel(bob, "!room"),
-            verificationMethods,
-            bob,
-        );
+        const bobRequest = new VerificationRequest(new InRoomChannel(bob, "!room"), verificationMethods, bob);
         expect(aliceRequest.invalid).toBe(true);
         expect(bobRequest.invalid).toBe(true);
 
@@ -199,23 +203,23 @@ describe("verification request unit tests", function() {
         expect(bobRequest.done).toBe(true);
     });
 
-    it("methods only contains common methods", async function() {
+    it("methods only contains common methods", async function () {
         const alice = makeMockClient("@alice:matrix.tld", "device1");
         const bob = makeMockClient("@bob:matrix.tld", "device1");
-        const aliceVerificationMethods = new Map(
-            [["c", function() {}], ["a", function() {}]],
-        ) as unknown as Map<string, typeof VerificationBase>;
-        const bobVerificationMethods = new Map(
-            [["c", function() {}], ["b", function() {}]],
-        ) as unknown as Map<string, typeof VerificationBase>;
+        const aliceVerificationMethods = new Map([
+            ["c", function () {}],
+            ["a", function () {}],
+        ]) as unknown as Map<string, typeof VerificationBase>;
+        const bobVerificationMethods = new Map([
+            ["c", function () {}],
+            ["b", function () {}],
+        ]) as unknown as Map<string, typeof VerificationBase>;
         const aliceRequest = new VerificationRequest(
             new InRoomChannel(alice, "!room", bob.getUserId()!),
-            aliceVerificationMethods, alice);
-        const bobRequest = new VerificationRequest(
-            new InRoomChannel(bob, "!room"),
-            bobVerificationMethods,
-            bob,
+            aliceVerificationMethods,
+            alice,
         );
+        const bobRequest = new VerificationRequest(new InRoomChannel(bob, "!room"), bobVerificationMethods, bob);
         await aliceRequest.sendRequest();
         const [requestEvent] = alice.popEvents();
         await distributeEvent(aliceRequest, bobRequest, requestEvent);
@@ -226,7 +230,7 @@ describe("verification request unit tests", function() {
         expect(bobRequest.methods).toStrictEqual(["c"]);
     });
 
-    it("other client accepting request puts it in observeOnly mode", async function() {
+    it("other client accepting request puts it in observeOnly mode", async function () {
         const alice = makeMockClient("@alice:matrix.tld", "device1");
         const bob1 = makeMockClient("@bob:matrix.tld", "device1");
         const bob2 = makeMockClient("@bob:matrix.tld", "device2");
@@ -237,16 +241,8 @@ describe("verification request unit tests", function() {
         );
         await aliceRequest.sendRequest();
         const [requestEvent] = alice.popEvents();
-        const bob1Request = new VerificationRequest(
-            new InRoomChannel(bob1, "!room"),
-            new Map(),
-            bob1,
-        );
-        const bob2Request = new VerificationRequest(
-            new InRoomChannel(bob2, "!room"),
-            new Map(),
-            bob2,
-        );
+        const bob1Request = new VerificationRequest(new InRoomChannel(bob1, "!room"), new Map(), bob1);
+        const bob2Request = new VerificationRequest(new InRoomChannel(bob2, "!room"), new Map(), bob2);
 
         await bob1Request.channel.handleEvent(requestEvent, bob1Request, true);
         await bob2Request.channel.handleEvent(requestEvent, bob2Request, true);
@@ -258,12 +254,13 @@ describe("verification request unit tests", function() {
         expect(bob2Request.observeOnly).toBe(true);
     });
 
-    it("verify own device with to_device messages", async function() {
+    it("verify own device with to_device messages", async function () {
         const bob1 = makeMockClient("@bob:matrix.tld", "device1");
         const bob2 = makeMockClient("@bob:matrix.tld", "device2");
-        const verificationMethods = new Map(
-            [[MOCK_METHOD, MockVerifier]],
-        ) as unknown as Map<string, typeof VerificationBase>;
+        const verificationMethods = new Map([[MOCK_METHOD, MockVerifier]]) as unknown as Map<
+            string,
+            typeof VerificationBase
+        >;
         const bob1Request = new VerificationRequest(
             new ToDeviceChannel(
                 bob1,
@@ -300,7 +297,7 @@ describe("verification request unit tests", function() {
         expect(bob2Request.done).toBe(true);
     });
 
-    it("request times out after 10 minutes", async function() {
+    it("request times out after 10 minutes", async function () {
         const alice = makeMockClient("@alice:matrix.tld", "device1");
         const bob = makeMockClient("@bob:matrix.tld", "device1");
         const aliceRequest = new VerificationRequest(
@@ -318,7 +315,7 @@ describe("verification request unit tests", function() {
         expect(aliceRequest._cancellingUserId).toBe(alice.getUserId());
     });
 
-    it("request times out 2 minutes after receipt", async function() {
+    it("request times out 2 minutes after receipt", async function () {
         const alice = makeMockClient("@alice:matrix.tld", "device1");
         const bob = makeMockClient("@bob:matrix.tld", "device1");
         const aliceRequest = new VerificationRequest(
@@ -328,11 +325,7 @@ describe("verification request unit tests", function() {
         );
         await aliceRequest.sendRequest();
         const [requestEvent] = alice.popEvents();
-        const bobRequest = new VerificationRequest(
-            new InRoomChannel(bob, "!room"),
-            new Map(),
-            bob,
-        );
+        const bobRequest = new VerificationRequest(new InRoomChannel(bob, "!room"), new Map(), bob);
 
         await bobRequest.channel.handleEvent(requestEvent, bobRequest, true);
 
diff --git a/spec/unit/embedded.spec.ts b/spec/unit/embedded.spec.ts
index 3e0ead87169..ef5215e20f0 100644
--- a/spec/unit/embedded.spec.ts
+++ b/spec/unit/embedded.spec.ts
@@ -23,13 +23,7 @@ limitations under the License.
 // eslint-disable-next-line no-restricted-imports
 import { EventEmitter } from "events";
 import { MockedObject } from "jest-mock";
-import {
-    WidgetApi,
-    WidgetApiToWidgetAction,
-    MatrixCapabilities,
-    ITurnServer,
-    IRoomEvent,
-} from "matrix-widget-api";
+import { WidgetApi, WidgetApiToWidgetAction, MatrixCapabilities, ITurnServer, IRoomEvent } from "matrix-widget-api";
 
 import { createRoomWidgetClient, MsgType } from "../../src/matrix";
 import { MatrixClient, ClientEvent, ITurnServer as IClientTurnServer } from "../../src/client";
@@ -88,7 +82,9 @@ describe("RoomWidgetClient", () => {
             expect(widgetApi.requestCapabilityToSendEvent).toHaveBeenCalledWith("org.matrix.rageshake_request");
             await client.sendEvent("!1:example.org", "org.matrix.rageshake_request", { request_id: 123 });
             expect(widgetApi.sendRoomEvent).toHaveBeenCalledWith(
-                "org.matrix.rageshake_request", { request_id: 123 }, "!1:example.org",
+                "org.matrix.rageshake_request",
+                { request_id: 123 },
+                "!1:example.org",
             );
         });
 
@@ -105,8 +101,8 @@ describe("RoomWidgetClient", () => {
             expect(widgetApi.requestCapabilityForRoomTimeline).toHaveBeenCalledWith("!1:example.org");
             expect(widgetApi.requestCapabilityToReceiveEvent).toHaveBeenCalledWith("org.matrix.rageshake_request");
 
-            const emittedEvent = new Promise<MatrixEvent>(resolve => client.once(ClientEvent.Event, resolve));
-            const emittedSync = new Promise<SyncState>(resolve => client.once(ClientEvent.Sync, resolve));
+            const emittedEvent = new Promise<MatrixEvent>((resolve) => client.once(ClientEvent.Event, resolve));
+            const emittedSync = new Promise<SyncState>((resolve) => client.once(ClientEvent.Sync, resolve));
             widgetApi.emit(
                 `action:${WidgetApiToWidgetAction.SendEvent}`,
                 new CustomEvent(`action:${WidgetApiToWidgetAction.SendEvent}`, { detail: { data: event } }),
@@ -118,7 +114,12 @@ describe("RoomWidgetClient", () => {
             // It should've also inserted the event into the room object
             const room = client.getRoom("!1:example.org");
             expect(room).not.toBeNull();
-            expect(room!.getLiveTimeline().getEvents().map(e => e.getEffectiveEvent())).toEqual([event]);
+            expect(
+                room!
+                    .getLiveTimeline()
+                    .getEvents()
+                    .map((e) => e.getEffectiveEvent()),
+            ).toEqual([event]);
         });
     });
 
@@ -157,7 +158,10 @@ describe("RoomWidgetClient", () => {
             expect(widgetApi.requestCapabilityToSendState).toHaveBeenCalledWith("org.example.foo", "bar");
             await client.sendStateEvent("!1:example.org", "org.example.foo", { hello: "world" }, "bar");
             expect(widgetApi.sendStateEvent).toHaveBeenCalledWith(
-                "org.example.foo", "bar", { hello: "world" }, "!1:example.org",
+                "org.example.foo",
+                "bar",
+                { hello: "world" },
+                "!1:example.org",
             );
         });
 
@@ -166,8 +170,8 @@ describe("RoomWidgetClient", () => {
             expect(widgetApi.requestCapabilityForRoomTimeline).toHaveBeenCalledWith("!1:example.org");
             expect(widgetApi.requestCapabilityToReceiveState).toHaveBeenCalledWith("org.example.foo", "bar");
 
-            const emittedEvent = new Promise<MatrixEvent>(resolve => client.once(ClientEvent.Event, resolve));
-            const emittedSync = new Promise<SyncState>(resolve => client.once(ClientEvent.Sync, resolve));
+            const emittedEvent = new Promise<MatrixEvent>((resolve) => client.once(ClientEvent.Event, resolve));
+            const emittedSync = new Promise<SyncState>((resolve) => client.once(ClientEvent.Sync, resolve));
             widgetApi.emit(
                 `action:${WidgetApiToWidgetAction.SendEvent}`,
                 new CustomEvent(`action:${WidgetApiToWidgetAction.SendEvent}`, { detail: { data: event } }),
@@ -260,8 +264,8 @@ describe("RoomWidgetClient", () => {
                 content: { hello: "world" },
             };
 
-            const emittedEvent = new Promise<MatrixEvent>(resolve => client.once(ClientEvent.ToDeviceEvent, resolve));
-            const emittedSync = new Promise<SyncState>(resolve => client.once(ClientEvent.Sync, resolve));
+            const emittedEvent = new Promise<MatrixEvent>((resolve) => client.once(ClientEvent.ToDeviceEvent, resolve));
+            const emittedSync = new Promise<SyncState>((resolve) => client.once(ClientEvent.Sync, resolve));
             widgetApi.emit(
                 `action:${WidgetApiToWidgetAction.SendToDevice}`,
                 new CustomEvent(`action:${WidgetApiToWidgetAction.SendToDevice}`, { detail: { data: event } }),
@@ -308,7 +312,7 @@ describe("RoomWidgetClient", () => {
         };
 
         let emitServer2: () => void;
-        const getServer2 = new Promise<ITurnServer>(resolve => emitServer2 = () => resolve(server2));
+        const getServer2 = new Promise<ITurnServer>((resolve) => (emitServer2 = () => resolve(server2)));
         widgetApi.getTurnServers.mockImplementation(async function* () {
             yield server1;
             yield await getServer2;
@@ -321,7 +325,7 @@ describe("RoomWidgetClient", () => {
         expect(client.getTurnServers()).toEqual([clientServer1]);
 
         // Subsequent servers arrive asynchronously and should emit an event
-        const emittedServer = new Promise<IClientTurnServer[]>(resolve =>
+        const emittedServer = new Promise<IClientTurnServer[]>((resolve) =>
             client.once(ClientEvent.TurnServers, resolve),
         );
         emitServer2!();
diff --git a/spec/unit/event-mapper.spec.ts b/spec/unit/event-mapper.spec.ts
index 0dc43fc7a8b..4b1f4cbaeea 100644
--- a/spec/unit/event-mapper.spec.ts
+++ b/spec/unit/event-mapper.spec.ts
@@ -18,7 +18,7 @@ import { MatrixClient, MatrixEvent, MatrixEventEvent, MatrixScheduler, Room } fr
 import { eventMapperFor } from "../../src/event-mapper";
 import { IStore } from "../../src/store";
 
-describe("eventMapperFor", function() {
+describe("eventMapperFor", function () {
     let rooms: Room[] = [];
 
     const userId = "@test:example.org";
@@ -29,10 +29,10 @@ describe("eventMapperFor", function() {
         client = new MatrixClient({
             baseUrl: "https://my.home.server",
             accessToken: "my.access.token",
-            fetchFn: function() {} as any, // NOP
+            fetchFn: function () {} as any, // NOP
             store: {
                 getRoom(roomId: string): Room | null {
-                    return rooms.find(r => r.roomId === roomId) ?? null;
+                    return rooms.find((r) => r.roomId === roomId) ?? null;
                 },
             } as IStore,
             scheduler: {
diff --git a/spec/unit/event-timeline-set.spec.ts b/spec/unit/event-timeline-set.spec.ts
index 2bc068af660..2831b6ca608 100644
--- a/spec/unit/event-timeline-set.spec.ts
+++ b/spec/unit/event-timeline-set.spec.ts
@@ -25,12 +25,12 @@ import {
     MatrixEvent,
     MatrixEventEvent,
     Room,
-} from '../../src';
+} from "../../src";
 import { Thread } from "../../src/models/thread";
 import { ReEmitter } from "../../src/ReEmitter";
 
-describe('EventTimelineSet', () => {
-    const roomId = '!foo:bar';
+describe("EventTimelineSet", () => {
+    const roomId = "!foo:bar";
     const userA = "@alice:bar";
 
     let room: Room;
@@ -42,7 +42,7 @@ describe('EventTimelineSet', () => {
     let replyEvent: MatrixEvent;
 
     const itShouldReturnTheRelatedEvents = () => {
-        it('should return the related events', () => {
+        it("should return the related events", () => {
             eventTimelineSet.relations.aggregateChildEvent(messageEvent);
             const relations = eventTimelineSet.relations.getChildEventsForEvent(
                 messageEvent.getId()!,
@@ -55,45 +55,49 @@ describe('EventTimelineSet', () => {
         });
     };
 
-    const mkThreadResponse = (root: MatrixEvent) => utils.mkEvent({
-        event: true,
-        type: EventType.RoomMessage,
-        user: userA,
-        room: roomId,
-        content: {
-            "body": "Thread response :: " + Math.random(),
-            "m.relates_to": {
-                "event_id": root.getId(),
-                "m.in_reply_to": {
-                    "event_id": root.getId(),
+    const mkThreadResponse = (root: MatrixEvent) =>
+        utils.mkEvent(
+            {
+                event: true,
+                type: EventType.RoomMessage,
+                user: userA,
+                room: roomId,
+                content: {
+                    "body": "Thread response :: " + Math.random(),
+                    "m.relates_to": {
+                        "event_id": root.getId(),
+                        "m.in_reply_to": {
+                            event_id: root.getId(),
+                        },
+                        "rel_type": "m.thread",
+                    },
                 },
-                "rel_type": "m.thread",
             },
-        },
-    }, room.client);
+            room.client,
+        );
 
     beforeEach(() => {
-        client = utils.mock(MatrixClient, 'MatrixClient');
-        client.reEmitter = utils.mock(ReEmitter, 'ReEmitter');
+        client = utils.mock(MatrixClient, "MatrixClient");
+        client.reEmitter = utils.mock(ReEmitter, "ReEmitter");
         room = new Room(roomId, client, userA);
         eventTimelineSet = new EventTimelineSet(room);
         eventTimeline = new EventTimeline(eventTimelineSet);
         messageEvent = utils.mkMessage({
             room: roomId,
             user: userA,
-            msg: 'Hi!',
+            msg: "Hi!",
             event: true,
         });
         replyEvent = utils.mkReplyMessage({
             room: roomId,
             user: userA,
-            msg: 'Hoo!',
+            msg: "Hoo!",
             event: true,
             replyToMessage: messageEvent,
         });
     });
 
-    describe('addLiveEvent', () => {
+    describe("addLiveEvent", () => {
         it("Adds event to the live timeline in the timeline set", () => {
             const liveTimeline = eventTimelineSet.getLiveTimeline();
             expect(liveTimeline.getEvents().length).toStrictEqual(0);
@@ -111,7 +115,10 @@ describe('EventTimelineSet', () => {
 
             // make a duplicate
             const duplicateMessageEvent = utils.mkMessage({
-                room: roomId, user: userA, msg: "dupe", event: true,
+                room: roomId,
+                user: userA,
+                msg: "dupe",
+                event: true,
             });
             duplicateMessageEvent.event.event_id = messageEvent.getId();
 
@@ -133,7 +140,7 @@ describe('EventTimelineSet', () => {
         });
     });
 
-    describe('addEventToTimeline', () => {
+    describe("addEventToTimeline", () => {
         let thread: Thread;
 
         beforeEach(() => {
@@ -153,19 +160,10 @@ describe('EventTimelineSet', () => {
         it("Make sure legacy overload passing options directly as parameters still works", () => {
             const liveTimeline = eventTimelineSet.getLiveTimeline();
             expect(() => {
-                eventTimelineSet.addEventToTimeline(
-                    messageEvent,
-                    liveTimeline,
-                    true,
-                );
+                eventTimelineSet.addEventToTimeline(messageEvent, liveTimeline, true);
             }).not.toThrow();
             expect(() => {
-                eventTimelineSet.addEventToTimeline(
-                    messageEvent,
-                    liveTimeline,
-                    true,
-                    false,
-                );
+                eventTimelineSet.addEventToTimeline(messageEvent, liveTimeline, true, false);
             }).not.toThrow();
         });
 
@@ -204,8 +202,8 @@ describe('EventTimelineSet', () => {
             expect(liveTimeline.getEvents().length).toStrictEqual(0);
         });
 
-        describe('non-room timeline', () => {
-            it('Adds event to timeline', () => {
+        describe("non-room timeline", () => {
+            it("Adds event to timeline", () => {
                 const nonRoomEventTimelineSet = new EventTimelineSet(
                     // This is what we're specifically testing against, a timeline
                     // without a `room` defined
@@ -222,24 +220,16 @@ describe('EventTimelineSet', () => {
         });
     });
 
-    describe('aggregateRelations', () => {
-        describe('with unencrypted events', () => {
+    describe("aggregateRelations", () => {
+        describe("with unencrypted events", () => {
             beforeEach(() => {
-                eventTimelineSet.addEventsToTimeline(
-                    [
-                        messageEvent,
-                        replyEvent,
-                    ],
-                    true,
-                    eventTimeline,
-                    'foo',
-                );
+                eventTimelineSet.addEventsToTimeline([messageEvent, replyEvent], true, eventTimeline, "foo");
             });
 
             itShouldReturnTheRelatedEvents();
         });
 
-        describe('with events to be decrypted', () => {
+        describe("with events to be decrypted", () => {
             let messageEventShouldAttemptDecryptionSpy: jest.SpyInstance;
             let messageEventIsDecryptionFailureSpy: jest.SpyInstance;
 
@@ -247,26 +237,18 @@ describe('EventTimelineSet', () => {
             let replyEventIsDecryptionFailureSpy: jest.SpyInstance;
 
             beforeEach(() => {
-                messageEventShouldAttemptDecryptionSpy = jest.spyOn(messageEvent, 'shouldAttemptDecryption');
+                messageEventShouldAttemptDecryptionSpy = jest.spyOn(messageEvent, "shouldAttemptDecryption");
                 messageEventShouldAttemptDecryptionSpy.mockReturnValue(true);
-                messageEventIsDecryptionFailureSpy = jest.spyOn(messageEvent, 'isDecryptionFailure');
+                messageEventIsDecryptionFailureSpy = jest.spyOn(messageEvent, "isDecryptionFailure");
 
-                replyEventShouldAttemptDecryptionSpy = jest.spyOn(replyEvent, 'shouldAttemptDecryption');
+                replyEventShouldAttemptDecryptionSpy = jest.spyOn(replyEvent, "shouldAttemptDecryption");
                 replyEventShouldAttemptDecryptionSpy.mockReturnValue(true);
-                replyEventIsDecryptionFailureSpy = jest.spyOn(messageEvent, 'isDecryptionFailure');
-
-                eventTimelineSet.addEventsToTimeline(
-                    [
-                        messageEvent,
-                        replyEvent,
-                    ],
-                    true,
-                    eventTimeline,
-                    'foo',
-                );
+                replyEventIsDecryptionFailureSpy = jest.spyOn(messageEvent, "isDecryptionFailure");
+
+                eventTimelineSet.addEventsToTimeline([messageEvent, replyEvent], true, eventTimeline, "foo");
             });
 
-            it('should not return the related events', () => {
+            it("should not return the related events", () => {
                 eventTimelineSet.relations.aggregateChildEvent(messageEvent);
                 const relations = eventTimelineSet.relations.getChildEventsForEvent(
                     messageEvent.getId()!,
@@ -276,7 +258,7 @@ describe('EventTimelineSet', () => {
                 expect(relations).toBeUndefined();
             });
 
-            describe('after decryption', () => {
+            describe("after decryption", () => {
                 beforeEach(() => {
                     // simulate decryption failure once
                     messageEventIsDecryptionFailureSpy.mockReturnValue(true);
@@ -302,22 +284,26 @@ describe('EventTimelineSet', () => {
     });
 
     describe("canContain", () => {
-        const mkThreadResponse = (root: MatrixEvent) => utils.mkEvent({
-            event: true,
-            type: EventType.RoomMessage,
-            user: userA,
-            room: roomId,
-            content: {
-                "body": "Thread response :: " + Math.random(),
-                "m.relates_to": {
-                    "event_id": root.getId(),
-                    "m.in_reply_to": {
-                        "event_id": root.getId()!,
+        const mkThreadResponse = (root: MatrixEvent) =>
+            utils.mkEvent(
+                {
+                    event: true,
+                    type: EventType.RoomMessage,
+                    user: userA,
+                    room: roomId,
+                    content: {
+                        "body": "Thread response :: " + Math.random(),
+                        "m.relates_to": {
+                            "event_id": root.getId(),
+                            "m.in_reply_to": {
+                                event_id: root.getId()!,
+                            },
+                            "rel_type": "m.thread",
+                        },
                     },
-                    "rel_type": "m.thread",
                 },
-            },
-        }, room.client);
+                room.client,
+            );
 
         let thread: Thread;
 
diff --git a/spec/unit/event-timeline.spec.ts b/spec/unit/event-timeline.spec.ts
index 052b035a9be..2ac49c49f39 100644
--- a/spec/unit/event-timeline.spec.ts
+++ b/spec/unit/event-timeline.spec.ts
@@ -1,4 +1,4 @@
-import { mocked } from 'jest-mock';
+import { mocked } from "jest-mock";
 
 import * as utils from "../test-utils/test-utils";
 import { Direction, EventTimeline } from "../../src/models/event-timeline";
@@ -8,7 +8,7 @@ import { Room } from "../../src/models/room";
 import { RoomMember } from "../../src/models/room-member";
 import { EventTimelineSet } from "../../src/models/event-timeline-set";
 
-describe("EventTimeline", function() {
+describe("EventTimeline", function () {
     const roomId = "!foo:bar";
     const userA = "@alice:bar";
     const userB = "@bertha:bar";
@@ -19,7 +19,7 @@ describe("EventTimeline", function() {
     const getTimeline = (): EventTimeline => {
         const room = new Room(roomId, mockClient, userA);
         const timelineSet = new EventTimelineSet(room);
-        jest.spyOn(room, 'getUnfilteredTimelineSet').mockReturnValue(timelineSet);
+        jest.spyOn(room, "getUnfilteredTimelineSet").mockReturnValue(timelineSet);
 
         const timeline = new EventTimeline(timelineSet);
         // We manually stub the methods we'll be mocking out later instead of mocking the whole module
@@ -31,29 +31,34 @@ describe("EventTimeline", function() {
         return timeline;
     };
 
-    beforeEach(function() {
+    beforeEach(function () {
         // reset any RoomState mocks
         jest.resetAllMocks();
 
         timeline = getTimeline();
     });
 
-    describe("construction", function() {
-        it("getRoomId should get room id", function() {
+    describe("construction", function () {
+        it("getRoomId should get room id", function () {
             const v = timeline.getRoomId();
             expect(v).toEqual(roomId);
         });
     });
 
-    describe("initialiseState", function() {
-        it("should copy state events to start and end state", function() {
+    describe("initialiseState", function () {
+        it("should copy state events to start and end state", function () {
             const events = [
                 utils.mkMembership({
-                    room: roomId, mship: "invite", user: userB, skey: userA,
+                    room: roomId,
+                    mship: "invite",
+                    user: userB,
+                    skey: userA,
                     event: true,
                 }),
                 utils.mkEvent({
-                    type: "m.room.name", room: roomId, user: userB,
+                    type: "m.room.name",
+                    room: roomId,
+                    user: userB,
                     event: true,
                     content: { name: "New room" },
                 }),
@@ -61,49 +66,51 @@ describe("EventTimeline", function() {
             timeline.initialiseState(events);
             // @ts-ignore private prop
             const timelineStartState = timeline.startState!;
-            expect(mocked(timelineStartState).setStateEvents).toHaveBeenCalledWith(
-                events,
-                { timelineWasEmpty: undefined },
-            );
+            expect(mocked(timelineStartState).setStateEvents).toHaveBeenCalledWith(events, {
+                timelineWasEmpty: undefined,
+            });
             // @ts-ignore private prop
             const timelineEndState = timeline.endState!;
-            expect(mocked(timelineEndState).setStateEvents).toHaveBeenCalledWith(
-                events,
-                { timelineWasEmpty: undefined },
-            );
+            expect(mocked(timelineEndState).setStateEvents).toHaveBeenCalledWith(events, {
+                timelineWasEmpty: undefined,
+            });
         });
 
-        it("should raise an exception if called after events are added", function() {
-            const event =
-                utils.mkMessage({
-                    room: roomId, user: userA, msg: "Adam stole the plushies",
-                    event: true,
-                });
+        it("should raise an exception if called after events are added", function () {
+            const event = utils.mkMessage({
+                room: roomId,
+                user: userA,
+                msg: "Adam stole the plushies",
+                event: true,
+            });
 
             const state = [
                 utils.mkMembership({
-                    room: roomId, mship: "invite", user: userB, skey: userA,
+                    room: roomId,
+                    mship: "invite",
+                    user: userB,
+                    skey: userA,
                     event: true,
                 }),
             ];
 
-            expect(function() {
+            expect(function () {
                 timeline.initialiseState(state);
             }).not.toThrow();
             timeline.addEvent(event, { toStartOfTimeline: false });
-            expect(function() {
+            expect(function () {
                 timeline.initialiseState(state);
             }).toThrow();
         });
     });
 
-    describe("paginationTokens", function() {
-        it("pagination tokens should start null", function() {
+    describe("paginationTokens", function () {
+        it("pagination tokens should start null", function () {
             expect(timeline.getPaginationToken(EventTimeline.BACKWARDS)).toBe(null);
             expect(timeline.getPaginationToken(EventTimeline.FORWARDS)).toBe(null);
         });
 
-        it("setPaginationToken should set token", function() {
+        it("setPaginationToken should set token", function () {
             timeline.setPaginationToken("back", EventTimeline.BACKWARDS);
             timeline.setPaginationToken("fwd", EventTimeline.FORWARDS);
             expect(timeline.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("back");
@@ -121,13 +128,13 @@ describe("EventTimeline", function() {
         });
     });
 
-    describe("neighbouringTimelines", function() {
-        it("neighbouring timelines should start null", function() {
+    describe("neighbouringTimelines", function () {
+        it("neighbouring timelines should start null", function () {
             expect(timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)).toBe(null);
             expect(timeline.getNeighbouringTimeline(EventTimeline.FORWARDS)).toBe(null);
         });
 
-        it("setNeighbouringTimeline should set neighbour", function() {
+        it("setNeighbouringTimeline should set neighbour", function () {
             const prev = getTimeline();
             const next = getTimeline();
             timeline.setNeighbouringTimeline(prev, EventTimeline.BACKWARDS);
@@ -136,42 +143,44 @@ describe("EventTimeline", function() {
             expect(timeline.getNeighbouringTimeline(EventTimeline.FORWARDS)).toBe(next);
         });
 
-        it("setNeighbouringTimeline should throw if called twice", function() {
+        it("setNeighbouringTimeline should throw if called twice", function () {
             const prev = getTimeline();
             const next = getTimeline();
-            expect(function() {
+            expect(function () {
                 timeline.setNeighbouringTimeline(prev, EventTimeline.BACKWARDS);
             }).not.toThrow();
-            expect(timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS))
-                .toBe(prev);
-            expect(function() {
+            expect(timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)).toBe(prev);
+            expect(function () {
                 timeline.setNeighbouringTimeline(prev, EventTimeline.BACKWARDS);
             }).toThrow();
 
-            expect(function() {
+            expect(function () {
                 timeline.setNeighbouringTimeline(next, EventTimeline.FORWARDS);
             }).not.toThrow();
-            expect(timeline.getNeighbouringTimeline(EventTimeline.FORWARDS))
-                .toBe(next);
-            expect(function() {
+            expect(timeline.getNeighbouringTimeline(EventTimeline.FORWARDS)).toBe(next);
+            expect(function () {
                 timeline.setNeighbouringTimeline(next, EventTimeline.FORWARDS);
             }).toThrow();
         });
     });
 
-    describe("addEvent", function() {
+    describe("addEvent", function () {
         const events = [
             utils.mkMessage({
-                room: roomId, user: userA, msg: "hungry hungry hungry",
+                room: roomId,
+                user: userA,
+                msg: "hungry hungry hungry",
                 event: true,
             }),
             utils.mkMessage({
-                room: roomId, user: userB, msg: "nom nom nom",
+                room: roomId,
+                user: userB,
+                msg: "nom nom nom",
                 event: true,
             }),
         ];
 
-        it("should be able to add events to the end", function() {
+        it("should be able to add events to the end", function () {
             timeline.addEvent(events[0], { toStartOfTimeline: false });
             const initialIndex = timeline.getBaseIndex();
             timeline.addEvent(events[1], { toStartOfTimeline: false });
@@ -181,7 +190,7 @@ describe("EventTimeline", function() {
             expect(timeline.getEvents()[1]).toEqual(events[1]);
         });
 
-        it("should be able to add events to the start", function() {
+        it("should be able to add events to the start", function () {
             timeline.addEvent(events[0], { toStartOfTimeline: true });
             const initialIndex = timeline.getBaseIndex();
             timeline.addEvent(events[1], { toStartOfTimeline: true });
@@ -191,7 +200,7 @@ describe("EventTimeline", function() {
             expect(timeline.getEvents()[1]).toEqual(events[0]);
         });
 
-        it("should set event.sender for new and old events", function() {
+        it("should set event.sender for new and old events", function () {
             const sentinel = new RoomMember(roomId, userA);
             sentinel.name = "Alice";
             sentinel.membership = "join";
@@ -200,27 +209,31 @@ describe("EventTimeline", function() {
             sentinel.name = "Old Alice";
             sentinel.membership = "join";
 
-            mocked(timeline.getState(EventTimeline.FORWARDS)!).getSentinelMember
-                .mockImplementation(function(uid) {
-                    if (uid === userA) {
-                        return sentinel;
-                    }
-                    return null;
-                });
-            mocked(timeline.getState(EventTimeline.BACKWARDS)!).getSentinelMember
-                .mockImplementation(function(uid) {
-                    if (uid === userA) {
-                        return oldSentinel;
-                    }
-                    return null;
-                });
+            mocked(timeline.getState(EventTimeline.FORWARDS)!).getSentinelMember.mockImplementation(function (uid) {
+                if (uid === userA) {
+                    return sentinel;
+                }
+                return null;
+            });
+            mocked(timeline.getState(EventTimeline.BACKWARDS)!).getSentinelMember.mockImplementation(function (uid) {
+                if (uid === userA) {
+                    return oldSentinel;
+                }
+                return null;
+            });
 
             const newEv = utils.mkEvent({
-                type: "m.room.name", room: roomId, user: userA, event: true,
+                type: "m.room.name",
+                room: roomId,
+                user: userA,
+                event: true,
                 content: { name: "New Room Name" },
             });
             const oldEv = utils.mkEvent({
-                type: "m.room.name", room: roomId, user: userA, event: true,
+                type: "m.room.name",
+                room: roomId,
+                user: userA,
+                event: true,
                 content: { name: "Old Room Name" },
             });
 
@@ -230,128 +243,159 @@ describe("EventTimeline", function() {
             expect(oldEv.sender).toEqual(oldSentinel);
         });
 
-        it("should set event.target for new and old m.room.member events",
-            function() {
-                const sentinel = new RoomMember(roomId, userA);
-                sentinel.name = "Alice";
-                sentinel.membership = "join";
-
-                const oldSentinel = new RoomMember(roomId, userA);
-                sentinel.name = "Old Alice";
-                sentinel.membership = "join";
-
-                mocked(timeline.getState(EventTimeline.FORWARDS)!).getSentinelMember
-                    .mockImplementation(function(uid) {
-                        if (uid === userA) {
-                            return sentinel;
-                        }
-                        return null;
-                    });
-                mocked(timeline.getState(EventTimeline.BACKWARDS)!).getSentinelMember
-                    .mockImplementation(function(uid) {
-                        if (uid === userA) {
-                            return oldSentinel;
-                        }
-                        return null;
-                    });
-
-                const newEv = utils.mkMembership({
-                    room: roomId, mship: "invite", user: userB, skey: userA, event: true,
-                });
-                const oldEv = utils.mkMembership({
-                    room: roomId, mship: "ban", user: userB, skey: userA, event: true,
-                });
-                timeline.addEvent(newEv, { toStartOfTimeline: false });
-                expect(newEv.target).toEqual(sentinel);
-                timeline.addEvent(oldEv, { toStartOfTimeline: true });
-                expect(oldEv.target).toEqual(oldSentinel);
-            });
+        it("should set event.target for new and old m.room.member events", function () {
+            const sentinel = new RoomMember(roomId, userA);
+            sentinel.name = "Alice";
+            sentinel.membership = "join";
 
-        it("should call setStateEvents on the right RoomState with the right " +
-           "forwardLooking value for new events", function() {
-            const events = [
-                utils.mkMembership({
-                    room: roomId, mship: "invite", user: userB, skey: userA, event: true,
-                }),
-                utils.mkEvent({
-                    type: "m.room.name", room: roomId, user: userB, event: true,
-                    content: {
-                        name: "New room",
-                    },
-                }),
-            ];
+            const oldSentinel = new RoomMember(roomId, userA);
+            sentinel.name = "Old Alice";
+            sentinel.membership = "join";
 
-            timeline.addEvent(events[0], { toStartOfTimeline: false });
-            timeline.addEvent(events[1], { toStartOfTimeline: false });
+            mocked(timeline.getState(EventTimeline.FORWARDS)!).getSentinelMember.mockImplementation(function (uid) {
+                if (uid === userA) {
+                    return sentinel;
+                }
+                return null;
+            });
+            mocked(timeline.getState(EventTimeline.BACKWARDS)!).getSentinelMember.mockImplementation(function (uid) {
+                if (uid === userA) {
+                    return oldSentinel;
+                }
+                return null;
+            });
 
-            expect(timeline.getState(EventTimeline.FORWARDS)!.setStateEvents).
-                toHaveBeenCalledWith([events[0]], { timelineWasEmpty: undefined });
-            expect(timeline.getState(EventTimeline.FORWARDS)!.setStateEvents).
-                toHaveBeenCalledWith([events[1]], { timelineWasEmpty: undefined });
+            const newEv = utils.mkMembership({
+                room: roomId,
+                mship: "invite",
+                user: userB,
+                skey: userA,
+                event: true,
+            });
+            const oldEv = utils.mkMembership({
+                room: roomId,
+                mship: "ban",
+                user: userB,
+                skey: userA,
+                event: true,
+            });
+            timeline.addEvent(newEv, { toStartOfTimeline: false });
+            expect(newEv.target).toEqual(sentinel);
+            timeline.addEvent(oldEv, { toStartOfTimeline: true });
+            expect(oldEv.target).toEqual(oldSentinel);
+        });
 
-            expect(events[0].forwardLooking).toBe(true);
-            expect(events[1].forwardLooking).toBe(true);
+        it(
+            "should call setStateEvents on the right RoomState with the right " + "forwardLooking value for new events",
+            function () {
+                const events = [
+                    utils.mkMembership({
+                        room: roomId,
+                        mship: "invite",
+                        user: userB,
+                        skey: userA,
+                        event: true,
+                    }),
+                    utils.mkEvent({
+                        type: "m.room.name",
+                        room: roomId,
+                        user: userB,
+                        event: true,
+                        content: {
+                            name: "New room",
+                        },
+                    }),
+                ];
+
+                timeline.addEvent(events[0], { toStartOfTimeline: false });
+                timeline.addEvent(events[1], { toStartOfTimeline: false });
 
-            expect(timeline.getState(EventTimeline.BACKWARDS)!.setStateEvents).
-                not.toHaveBeenCalled();
-        });
+                expect(timeline.getState(EventTimeline.FORWARDS)!.setStateEvents).toHaveBeenCalledWith([events[0]], {
+                    timelineWasEmpty: undefined,
+                });
+                expect(timeline.getState(EventTimeline.FORWARDS)!.setStateEvents).toHaveBeenCalledWith([events[1]], {
+                    timelineWasEmpty: undefined,
+                });
 
-        it("should call setStateEvents on the right RoomState with the right " +
-           "forwardLooking value for old events", function() {
-            const events = [
-                utils.mkMembership({
-                    room: roomId, mship: "invite", user: userB, skey: userA, event: true,
-                }),
-                utils.mkEvent({
-                    type: "m.room.name", room: roomId, user: userB, event: true,
-                    content: {
-                        name: "New room",
-                    },
-                }),
-            ];
+                expect(events[0].forwardLooking).toBe(true);
+                expect(events[1].forwardLooking).toBe(true);
+
+                expect(timeline.getState(EventTimeline.BACKWARDS)!.setStateEvents).not.toHaveBeenCalled();
+            },
+        );
+
+        it(
+            "should call setStateEvents on the right RoomState with the right " + "forwardLooking value for old events",
+            function () {
+                const events = [
+                    utils.mkMembership({
+                        room: roomId,
+                        mship: "invite",
+                        user: userB,
+                        skey: userA,
+                        event: true,
+                    }),
+                    utils.mkEvent({
+                        type: "m.room.name",
+                        room: roomId,
+                        user: userB,
+                        event: true,
+                        content: {
+                            name: "New room",
+                        },
+                    }),
+                ];
 
-            timeline.addEvent(events[0], { toStartOfTimeline: true });
-            timeline.addEvent(events[1], { toStartOfTimeline: true });
+                timeline.addEvent(events[0], { toStartOfTimeline: true });
+                timeline.addEvent(events[1], { toStartOfTimeline: true });
 
-            expect(timeline.getState(EventTimeline.BACKWARDS)!.setStateEvents).
-                toHaveBeenCalledWith([events[0]], { timelineWasEmpty: undefined });
-            expect(timeline.getState(EventTimeline.BACKWARDS)!.setStateEvents).
-                toHaveBeenCalledWith([events[1]], { timelineWasEmpty: undefined });
+                expect(timeline.getState(EventTimeline.BACKWARDS)!.setStateEvents).toHaveBeenCalledWith([events[0]], {
+                    timelineWasEmpty: undefined,
+                });
+                expect(timeline.getState(EventTimeline.BACKWARDS)!.setStateEvents).toHaveBeenCalledWith([events[1]], {
+                    timelineWasEmpty: undefined,
+                });
 
-            expect(events[0].forwardLooking).toBe(false);
-            expect(events[1].forwardLooking).toBe(false);
+                expect(events[0].forwardLooking).toBe(false);
+                expect(events[1].forwardLooking).toBe(false);
 
-            expect(timeline.getState(EventTimeline.FORWARDS)!.setStateEvents).
-                not.toHaveBeenCalled();
-        });
+                expect(timeline.getState(EventTimeline.FORWARDS)!.setStateEvents).not.toHaveBeenCalled();
+            },
+        );
 
         it("Make sure legacy overload passing options directly as parameters still works", () => {
             expect(() => timeline.addEvent(events[0], { toStartOfTimeline: true })).not.toThrow();
             // @ts-ignore stateContext is not a valid param
             expect(() => timeline.addEvent(events[0], { stateContext: new RoomState(roomId) })).not.toThrow();
-            expect(() => timeline.addEvent(events[0],
-                { toStartOfTimeline: false, roomState: new RoomState(roomId) },
-            )).not.toThrow();
+            expect(() =>
+                timeline.addEvent(events[0], { toStartOfTimeline: false, roomState: new RoomState(roomId) }),
+            ).not.toThrow();
         });
     });
 
-    describe("removeEvent", function() {
+    describe("removeEvent", function () {
         const events = [
             utils.mkMessage({
-                room: roomId, user: userA, msg: "hungry hungry hungry",
+                room: roomId,
+                user: userA,
+                msg: "hungry hungry hungry",
                 event: true,
             }),
             utils.mkMessage({
-                room: roomId, user: userB, msg: "nom nom nom",
+                room: roomId,
+                user: userB,
+                msg: "nom nom nom",
                 event: true,
             }),
             utils.mkMessage({
-                room: roomId, user: userB, msg: "piiie",
+                room: roomId,
+                user: userB,
+                msg: "piiie",
                 event: true,
             }),
         ];
 
-        it("should remove events", function() {
+        it("should remove events", function () {
             timeline.addEvent(events[0], { toStartOfTimeline: false });
             timeline.addEvent(events[1], { toStartOfTimeline: false });
             expect(timeline.getEvents().length).toEqual(2);
@@ -365,7 +409,7 @@ describe("EventTimeline", function() {
             expect(timeline.getEvents().length).toEqual(0);
         });
 
-        it("should update baseIndex", function() {
+        it("should update baseIndex", function () {
             timeline.addEvent(events[0], { toStartOfTimeline: false });
             timeline.addEvent(events[1], { toStartOfTimeline: true });
             timeline.addEvent(events[2], { toStartOfTimeline: false });
@@ -384,15 +428,14 @@ describe("EventTimeline", function() {
         // this is basically https://github.com/vector-im/vector-web/issues/937
         // - removing the last event got baseIndex into such a state that
         // further addEvent(ev, false) calls made the index increase.
-        it("should not make baseIndex assplode when removing the last event",
-            function() {
-                timeline.addEvent(events[0], { toStartOfTimeline: true });
-                timeline.removeEvent(events[0].getId()!);
-                const initialIndex = timeline.getBaseIndex();
-                timeline.addEvent(events[1], { toStartOfTimeline: false });
-                timeline.addEvent(events[2], { toStartOfTimeline: false });
-                expect(timeline.getBaseIndex()).toEqual(initialIndex);
-                expect(timeline.getEvents().length).toEqual(2);
-            });
+        it("should not make baseIndex assplode when removing the last event", function () {
+            timeline.addEvent(events[0], { toStartOfTimeline: true });
+            timeline.removeEvent(events[0].getId()!);
+            const initialIndex = timeline.getBaseIndex();
+            timeline.addEvent(events[1], { toStartOfTimeline: false });
+            timeline.addEvent(events[2], { toStartOfTimeline: false });
+            expect(timeline.getBaseIndex()).toEqual(initialIndex);
+            expect(timeline.getEvents().length).toEqual(2);
+        });
     });
 });
diff --git a/spec/unit/filter-component.spec.ts b/spec/unit/filter-component.spec.ts
index a0a337cd17d..ad7cecde26a 100644
--- a/spec/unit/filter-component.spec.ts
+++ b/spec/unit/filter-component.spec.ts
@@ -1,15 +1,15 @@
 import { RelationType } from "../../src";
 import { FilterComponent } from "../../src/filter-component";
-import { mkEvent } from '../test-utils/test-utils';
+import { mkEvent } from "../test-utils/test-utils";
 
-describe("Filter Component", function() {
-    describe("types", function() {
-        it("should filter out events with other types", function() {
-            const filter = new FilterComponent({ types: ['m.room.message'] });
+describe("Filter Component", function () {
+    describe("types", function () {
+        it("should filter out events with other types", function () {
+            const filter = new FilterComponent({ types: ["m.room.message"] });
             const event = mkEvent({
-                type: 'm.room.member',
-                content: { },
-                room: 'roomId',
+                type: "m.room.member",
+                content: {},
+                room: "roomId",
                 event: true,
             });
 
@@ -18,12 +18,12 @@ describe("Filter Component", function() {
             expect(checkResult).toBe(false);
         });
 
-        it("should validate events with the same type", function() {
-            const filter = new FilterComponent({ types: ['m.room.message'] });
+        it("should validate events with the same type", function () {
+            const filter = new FilterComponent({ types: ["m.room.message"] });
             const event = mkEvent({
-                type: 'm.room.message',
-                content: { },
-                room: 'roomId',
+                type: "m.room.message",
+                content: {},
+                room: "roomId",
                 event: true,
             });
 
@@ -32,17 +32,20 @@ describe("Filter Component", function() {
             expect(checkResult).toBe(true);
         });
 
-        it("should filter out events by relation participation", function() {
-            const currentUserId = '@me:server.org';
-            const filter = new FilterComponent({
-                related_by_senders: [currentUserId],
-            }, currentUserId);
+        it("should filter out events by relation participation", function () {
+            const currentUserId = "@me:server.org";
+            const filter = new FilterComponent(
+                {
+                    related_by_senders: [currentUserId],
+                },
+                currentUserId,
+            );
 
             const threadRootNotParticipated = mkEvent({
-                type: 'm.room.message',
+                type: "m.room.message",
                 content: {},
-                room: 'roomId',
-                user: '@someone-else:server.org',
+                room: "roomId",
+                user: "@someone-else:server.org",
                 event: true,
                 unsigned: {
                     "m.relations": {
@@ -57,14 +60,17 @@ describe("Filter Component", function() {
             expect(filter.check(threadRootNotParticipated)).toBe(false);
         });
 
-        it("should keep events by relation participation", function() {
-            const currentUserId = '@me:server.org';
-            const filter = new FilterComponent({
-                related_by_senders: [currentUserId],
-            }, currentUserId);
+        it("should keep events by relation participation", function () {
+            const currentUserId = "@me:server.org";
+            const filter = new FilterComponent(
+                {
+                    related_by_senders: [currentUserId],
+                },
+                currentUserId,
+            );
 
             const threadRootParticipated = mkEvent({
-                type: 'm.room.message',
+                type: "m.room.message",
                 content: {},
                 unsigned: {
                     "m.relations": {
@@ -74,23 +80,23 @@ describe("Filter Component", function() {
                         },
                     },
                 },
-                user: '@someone-else:server.org',
-                room: 'roomId',
+                user: "@someone-else:server.org",
+                room: "roomId",
                 event: true,
             });
 
             expect(filter.check(threadRootParticipated)).toBe(true);
         });
 
-        it("should filter out events by relation type", function() {
+        it("should filter out events by relation type", function () {
             const filter = new FilterComponent({
                 related_by_rel_types: ["m.thread"],
             });
 
             const referenceRelationEvent = mkEvent({
-                type: 'm.room.message',
+                type: "m.room.message",
                 content: {},
-                room: 'roomId',
+                room: "roomId",
                 event: true,
                 unsigned: {
                     "m.relations": {
@@ -102,13 +108,13 @@ describe("Filter Component", function() {
             expect(filter.check(referenceRelationEvent)).toBe(false);
         });
 
-        it("should keep events by relation type", function() {
+        it("should keep events by relation type", function () {
             const filter = new FilterComponent({
                 related_by_rel_types: ["m.thread"],
             });
 
             const threadRootEvent = mkEvent({
-                type: 'm.room.message',
+                type: "m.room.message",
                 content: {},
                 unsigned: {
                     "m.relations": {
@@ -118,22 +124,22 @@ describe("Filter Component", function() {
                         },
                     },
                 },
-                room: 'roomId',
+                room: "roomId",
                 event: true,
             });
 
             const eventWithMultipleRelations = mkEvent({
-                "type": "m.room.message",
-                "content": {},
-                "unsigned": {
+                type: "m.room.message",
+                content: {},
+                unsigned: {
                     "m.relations": {
                         "testtesttest": {},
                         "m.annotation": {
-                            "chunk": [
+                            chunk: [
                                 {
-                                    "type": "m.reaction",
-                                    "key": "🤫",
-                                    "count": 1,
+                                    type: "m.reaction",
+                                    key: "🤫",
+                                    count: 1,
                                 },
                             ],
                         },
@@ -143,20 +149,20 @@ describe("Filter Component", function() {
                         },
                     },
                 },
-                "room": 'roomId',
-                "event": true,
+                room: "roomId",
+                event: true,
             });
 
             const noMatchEvent = mkEvent({
-                "type": "m.room.message",
-                "content": {},
-                "unsigned": {
+                type: "m.room.message",
+                content: {},
+                unsigned: {
                     "m.relations": {
-                        "testtesttest": {},
+                        testtesttest: {},
                     },
                 },
-                "room": 'roomId',
-                "event": true,
+                room: "roomId",
+                event: true,
             });
 
             expect(filter.check(threadRootEvent)).toBe(true);
diff --git a/spec/unit/filter.spec.ts b/spec/unit/filter.spec.ts
index ef8d67e5140..6a31f691b62 100644
--- a/spec/unit/filter.spec.ts
+++ b/spec/unit/filter.spec.ts
@@ -19,17 +19,17 @@ import { Filter, IFilterDefinition } from "../../src/filter";
 import { mkEvent } from "../test-utils/test-utils";
 import { EventType } from "../../src";
 
-describe("Filter", function() {
+describe("Filter", function () {
     const filterId = "f1lt3ring15g00d4ursoul";
     const userId = "@sir_arthur_david:humming.tiger";
     let filter: Filter;
 
-    beforeEach(function() {
+    beforeEach(function () {
         filter = new Filter(userId);
     });
 
-    describe("fromJson", function() {
-        it("create a new Filter from the provided values", function() {
+    describe("fromJson", function () {
+        it("create a new Filter from the provided values", function () {
             const definition = {
                 event_fields: ["type", "content"],
             };
@@ -40,8 +40,8 @@ describe("Filter", function() {
         });
     });
 
-    describe("setTimelineLimit", function() {
-        it("should set room.timeline.limit of the filter definition", function() {
+    describe("setTimelineLimit", function () {
+        it("should set room.timeline.limit of the filter definition", function () {
             filter.setTimelineLimit(10);
             expect(filter.getDefinition()).toEqual({
                 room: {
@@ -53,18 +53,18 @@ describe("Filter", function() {
         });
     });
 
-    describe("setDefinition/getDefinition", function() {
-        it("should set and get the filter body", function() {
+    describe("setDefinition/getDefinition", function () {
+        it("should set and get the filter body", function () {
             const definition = {
-                event_format: "client" as IFilterDefinition['event_format'],
+                event_format: "client" as IFilterDefinition["event_format"],
             };
             filter.setDefinition(definition);
             expect(filter.getDefinition()).toEqual(definition);
         });
     });
 
-    describe("setUnreadThreadNotifications", function() {
-        it("setUnreadThreadNotifications", function() {
+    describe("setUnreadThreadNotifications", function () {
+        it("setUnreadThreadNotifications", function () {
             filter.setUnreadThreadNotifications(true);
             expect(filter.getDefinition()).toEqual({
                 room: {
diff --git a/spec/unit/http-api/fetch.spec.ts b/spec/unit/http-api/fetch.spec.ts
index 1af230211aa..9fc0642c571 100644
--- a/spec/unit/http-api/fetch.spec.ts
+++ b/spec/unit/http-api/fetch.spec.ts
@@ -65,8 +65,9 @@ describe("FetchHttpApi", () => {
     describe("idServerRequest", () => {
         it("should throw if no idBaseUrl", () => {
             const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), { baseUrl, prefix });
-            expect(() => api.idServerRequest(Method.Get, "/test", {}, IdentityPrefix.V2))
-                .toThrow("No identity server base URL set");
+            expect(() => api.idServerRequest(Method.Get, "/test", {}, IdentityPrefix.V2)).toThrow(
+                "No identity server base URL set",
+            );
         });
 
         it("should send params as query string for GET requests", () => {
@@ -105,9 +106,11 @@ describe("FetchHttpApi", () => {
         const text = "418 I'm a teapot";
         const fetchFn = jest.fn().mockResolvedValue({ ok: true, text: jest.fn().mockResolvedValue(text) });
         const api = new FetchHttpApi(new TypedEventEmitter<any, any>(), { baseUrl, prefix, fetchFn, onlyData: true });
-        await expect(api.requestOtherUrl(Method.Get, "http://url", undefined, {
-            json: false,
-        })).resolves.toBe(text);
+        await expect(
+            api.requestOtherUrl(Method.Get, "http://url", undefined, {
+                json: false,
+            }),
+        ).resolves.toBe(text);
     });
 
     it("should send token via query params if useAuthorizationHeader=false", () => {
@@ -207,10 +210,12 @@ describe("FetchHttpApi", () => {
                     return name === "Content-Type" ? "application/json" : null;
                 },
             },
-            text: jest.fn().mockResolvedValue(JSON.stringify({
-                errcode: "M_CONSENT_NOT_GIVEN",
-                error: "Ye shall ask for consent",
-            })),
+            text: jest.fn().mockResolvedValue(
+                JSON.stringify({
+                    errcode: "M_CONSENT_NOT_GIVEN",
+                    error: "Ye shall ask for consent",
+                }),
+            ),
         });
         const emitter = new TypedEventEmitter<HttpApiEvent, HttpApiEventHandlerMap>();
         const api = new FetchHttpApi(emitter, { baseUrl, prefix, fetchFn });
diff --git a/spec/unit/http-api/index.spec.ts b/spec/unit/http-api/index.spec.ts
index 55a4d49df1b..cef31ffea96 100644
--- a/spec/unit/http-api/index.spec.ts
+++ b/spec/unit/http-api/index.spec.ts
@@ -85,8 +85,10 @@ describe("MatrixHttpApi", () => {
             useAuthorizationHeader: false,
         });
         upload = api.uploadContent({} as File);
-        expect(xhr.open)
-            .toHaveBeenCalledWith(Method.Post, baseUrl.toLowerCase() + "/_matrix/media/r0/upload?access_token=token");
+        expect(xhr.open).toHaveBeenCalledWith(
+            Method.Post,
+            baseUrl.toLowerCase() + "/_matrix/media/r0/upload?access_token=token",
+        );
         expect(xhr.setRequestHeader).not.toHaveBeenCalledWith("Authorization");
     });
 
@@ -104,8 +106,10 @@ describe("MatrixHttpApi", () => {
     it("should include filename by default", () => {
         const api = new MatrixHttpApi(new TypedEventEmitter<any, any>(), { baseUrl, prefix });
         upload = api.uploadContent({} as File, { name: "name" });
-        expect(xhr.open)
-            .toHaveBeenCalledWith(Method.Post, baseUrl.toLowerCase() + "/_matrix/media/r0/upload?filename=name");
+        expect(xhr.open).toHaveBeenCalledWith(
+            Method.Post,
+            baseUrl.toLowerCase() + "/_matrix/media/r0/upload?filename=name",
+        );
     });
 
     it("should allow not sending the filename", () => {
@@ -216,9 +220,9 @@ describe("MatrixHttpApi", () => {
     it("should return active uploads in `getCurrentUploads`", () => {
         const api = new MatrixHttpApi(new TypedEventEmitter<any, any>(), { baseUrl, prefix });
         upload = api.uploadContent({} as File);
-        expect(api.getCurrentUploads().find(u => u.promise === upload)).toBeTruthy();
+        expect(api.getCurrentUploads().find((u) => u.promise === upload)).toBeTruthy();
         api.cancelUpload(upload);
-        expect(api.getCurrentUploads().find(u => u.promise === upload)).toBeFalsy();
+        expect(api.getCurrentUploads().find((u) => u.promise === upload)).toBeFalsy();
     });
 
     it("should return expected object from `getContentUri`", () => {
diff --git a/spec/unit/http-api/utils.spec.ts b/spec/unit/http-api/utils.spec.ts
index 108ba306fba..9d74f79dc7d 100644
--- a/spec/unit/http-api/utils.spec.ts
+++ b/spec/unit/http-api/utils.spec.ts
@@ -51,10 +51,7 @@ describe("anySignal", () => {
     jest.useFakeTimers();
 
     it("should fire when any signal fires", () => {
-        const { signal } = anySignal([
-            timeoutSignal(3000),
-            timeoutSignal(2000),
-        ]);
+        const { signal } = anySignal([timeoutSignal(3000), timeoutSignal(2000)]);
 
         const onabort = jest.fn();
         signal.onabort = onabort;
@@ -67,10 +64,7 @@ describe("anySignal", () => {
     });
 
     it("should cleanup when instructed", () => {
-        const { signal, cleanup } = anySignal([
-            timeoutSignal(3000),
-            timeoutSignal(2000),
-        ]);
+        const { signal, cleanup } = anySignal([timeoutSignal(3000), timeoutSignal(2000)]);
 
         const onabort = jest.fn();
         signal.onabort = onabort;
@@ -93,53 +87,95 @@ describe("anySignal", () => {
 
 describe("parseErrorResponse", () => {
     it("should resolve Matrix Errors from XHR", () => {
-        expect(parseErrorResponse({
-            getResponseHeader(name: string): string | null {
-                return name === "Content-Type" ? "application/json" : null;
-            },
-            status: 500,
-        } as XMLHttpRequest, '{"errcode": "TEST"}')).toStrictEqual(new MatrixError({
-            errcode: "TEST",
-        }, 500));
+        expect(
+            parseErrorResponse(
+                {
+                    getResponseHeader(name: string): string | null {
+                        return name === "Content-Type" ? "application/json" : null;
+                    },
+                    status: 500,
+                } as XMLHttpRequest,
+                '{"errcode": "TEST"}',
+            ),
+        ).toStrictEqual(
+            new MatrixError(
+                {
+                    errcode: "TEST",
+                },
+                500,
+            ),
+        );
     });
 
     it("should resolve Matrix Errors from fetch", () => {
-        expect(parseErrorResponse({
-            headers: {
-                get(name: string): string | null {
-                    return name === "Content-Type" ? "application/json" : null;
+        expect(
+            parseErrorResponse(
+                {
+                    headers: {
+                        get(name: string): string | null {
+                            return name === "Content-Type" ? "application/json" : null;
+                        },
+                    },
+                    status: 500,
+                } as Response,
+                '{"errcode": "TEST"}',
+            ),
+        ).toStrictEqual(
+            new MatrixError(
+                {
+                    errcode: "TEST",
                 },
-            },
-            status: 500,
-        } as Response, '{"errcode": "TEST"}')).toStrictEqual(new MatrixError({
-            errcode: "TEST",
-        }, 500));
+                500,
+            ),
+        );
     });
 
     it("should resolve Matrix Errors from XHR with urls", () => {
-        expect(parseErrorResponse({
-            responseURL: "https://example.com",
-            getResponseHeader(name: string): string | null {
-                return name === "Content-Type" ? "application/json" : null;
-            },
-            status: 500,
-        } as XMLHttpRequest, '{"errcode": "TEST"}')).toStrictEqual(new MatrixError({
-            errcode: "TEST",
-        }, 500, "https://example.com"));
+        expect(
+            parseErrorResponse(
+                {
+                    responseURL: "https://example.com",
+                    getResponseHeader(name: string): string | null {
+                        return name === "Content-Type" ? "application/json" : null;
+                    },
+                    status: 500,
+                } as XMLHttpRequest,
+                '{"errcode": "TEST"}',
+            ),
+        ).toStrictEqual(
+            new MatrixError(
+                {
+                    errcode: "TEST",
+                },
+                500,
+                "https://example.com",
+            ),
+        );
     });
 
     it("should resolve Matrix Errors from fetch with urls", () => {
-        expect(parseErrorResponse({
-            url: "https://example.com",
-            headers: {
-                get(name: string): string | null {
-                    return name === "Content-Type" ? "application/json" : null;
+        expect(
+            parseErrorResponse(
+                {
+                    url: "https://example.com",
+                    headers: {
+                        get(name: string): string | null {
+                            return name === "Content-Type" ? "application/json" : null;
+                        },
+                    },
+                    status: 500,
+                } as Response,
+                '{"errcode": "TEST"}',
+            ),
+        ).toStrictEqual(
+            new MatrixError(
+                {
+                    errcode: "TEST",
                 },
-            },
-            status: 500,
-        } as Response, '{"errcode": "TEST"}')).toStrictEqual(new MatrixError({
-            errcode: "TEST",
-        }, 500, "https://example.com"));
+                500,
+                "https://example.com",
+            ),
+        );
     });
 
     it("should set a sensible default error message on MatrixError", () => {
@@ -152,37 +188,51 @@ describe("parseErrorResponse", () => {
     });
 
     it("should handle no type gracefully", () => {
-        expect(parseErrorResponse({
-            headers: {
-                get(name: string): string | null {
-                    return null;
-                },
-            },
-            status: 500,
-        } as Response, '{"errcode": "TEST"}')).toStrictEqual(new HTTPError("Server returned 500 error", 500));
+        expect(
+            parseErrorResponse(
+                {
+                    headers: {
+                        get(name: string): string | null {
+                            return null;
+                        },
+                    },
+                    status: 500,
+                } as Response,
+                '{"errcode": "TEST"}',
+            ),
+        ).toStrictEqual(new HTTPError("Server returned 500 error", 500));
     });
 
     it("should handle invalid type gracefully", () => {
-        expect(parseErrorResponse({
-            headers: {
-                get(name: string): string | null {
-                    return name === "Content-Type" ? " " : null;
-                },
-            },
-            status: 500,
-        } as Response, '{"errcode": "TEST"}'))
-            .toStrictEqual(new Error("Error parsing Content-Type ' ': TypeError: invalid media type"));
+        expect(
+            parseErrorResponse(
+                {
+                    headers: {
+                        get(name: string): string | null {
+                            return name === "Content-Type" ? " " : null;
+                        },
+                    },
+                    status: 500,
+                } as Response,
+                '{"errcode": "TEST"}',
+            ),
+        ).toStrictEqual(new Error("Error parsing Content-Type ' ': TypeError: invalid media type"));
     });
 
     it("should handle plaintext errors", () => {
-        expect(parseErrorResponse({
-            headers: {
-                get(name: string): string | null {
-                    return name === "Content-Type" ? "text/plain" : null;
-                },
-            },
-            status: 418,
-        } as Response, "I'm a teapot")).toStrictEqual(new HTTPError("Server returned 418 error: I'm a teapot", 418));
+        expect(
+            parseErrorResponse(
+                {
+                    headers: {
+                        get(name: string): string | null {
+                            return name === "Content-Type" ? "text/plain" : null;
+                        },
+                    },
+                    status: 418,
+                } as Response,
+                "I'm a teapot",
+            ),
+        ).toStrictEqual(new HTTPError("Server returned 418 error: I'm a teapot", 418));
     });
 });
 
diff --git a/spec/unit/interactive-auth.spec.ts b/spec/unit/interactive-auth.spec.ts
index 098cadad5f0..366a9a710c8 100644
--- a/spec/unit/interactive-auth.spec.ts
+++ b/spec/unit/interactive-auth.spec.ts
@@ -44,9 +44,7 @@ describe("InteractiveAuth", () => {
             requestEmailToken: jest.fn(),
             authData: {
                 session: "sessionId",
-                flows: [
-                    { stages: [AuthType.Password] },
-                ],
+                flows: [{ stages: [AuthType.Password] }],
                 params: {
                     [AuthType.Password]: { param: "aa" },
                 },
@@ -60,7 +58,7 @@ describe("InteractiveAuth", () => {
 
         // first we expect a call here
         stateUpdated.mockImplementation((stage) => {
-            logger.log('aaaa');
+            logger.log("aaaa");
             expect(stage).toEqual(AuthType.Password);
             ia.submitAuthDict({
                 type: AuthType.Password,
@@ -68,9 +66,9 @@ describe("InteractiveAuth", () => {
         });
 
         // .. which should trigger a call here
-        const requestRes = { "a": "b" };
+        const requestRes = { a: "b" };
         doRequest.mockImplementation(async (authData) => {
-            logger.log('cccc');
+            logger.log("cccc");
             expect(authData).toEqual({
                 session: "sessionId",
                 type: AuthType.Password,
@@ -95,9 +93,7 @@ describe("InteractiveAuth", () => {
             requestEmailToken: jest.fn(),
             authData: {
                 session: "sessionId",
-                flows: [
-                    { stages: [AuthType.Password] },
-                ],
+                flows: [{ stages: [AuthType.Password] }],
                 errcode: "MockError0",
                 params: {
                     [AuthType.Password]: { param: "aa" },
@@ -112,7 +108,7 @@ describe("InteractiveAuth", () => {
 
         // first we expect a call here
         stateUpdated.mockImplementation((stage) => {
-            logger.log('aaaa');
+            logger.log("aaaa");
             expect(stage).toEqual(AuthType.Password);
             ia.submitAuthDict({
                 type: AuthType.Password,
@@ -120,9 +116,9 @@ describe("InteractiveAuth", () => {
         });
 
         // .. which should trigger a call here
-        const requestRes = { "a": "b" };
+        const requestRes = { a: "b" };
         doRequest.mockImplementation(async (authData) => {
-            logger.log('cccc');
+            logger.log("cccc");
             expect(authData).toEqual({
                 session: "sessionId",
                 type: AuthType.Password,
@@ -146,12 +142,10 @@ describe("InteractiveAuth", () => {
             stateUpdated,
             requestEmailToken,
             matrixClient: getFakeClient(),
-            emailSid: 'myEmailSid',
+            emailSid: "myEmailSid",
             authData: {
                 session: "sessionId",
-                flows: [
-                    { stages: [AuthType.Email, AuthType.Password] },
-                ],
+                flows: [{ stages: [AuthType.Email, AuthType.Password] }],
                 params: {
                     [AuthType.Email]: { param: "aa" },
                     [AuthType.Password]: { param: "bb" },
@@ -166,7 +160,7 @@ describe("InteractiveAuth", () => {
 
         // first we expect a call here
         stateUpdated.mockImplementation((stage) => {
-            logger.log('husky');
+            logger.log("husky");
             expect(stage).toEqual(AuthType.Email);
             ia.submitAuthDict({
                 type: AuthType.Email,
@@ -174,9 +168,9 @@ describe("InteractiveAuth", () => {
         });
 
         // .. which should trigger a call here
-        const requestRes = { "a": "b" };
+        const requestRes = { a: "b" };
         doRequest.mockImplementation(async (authData) => {
-            logger.log('barfoo');
+            logger.log("barfoo");
             expect(authData).toEqual({
                 session: "sessionId",
                 type: AuthType.Email,
@@ -211,20 +205,21 @@ describe("InteractiveAuth", () => {
         doRequest.mockImplementation((authData) => {
             logger.log("request1", authData);
             expect(authData).toEqual(null); // first request should be null
-            const err = new MatrixError({
-                session: "sessionId",
-                flows: [
-                    { stages: [AuthType.Password] },
-                ],
-                params: {
-                    [AuthType.Password]: { param: "aa" },
+            const err = new MatrixError(
+                {
+                    session: "sessionId",
+                    flows: [{ stages: [AuthType.Password] }],
+                    params: {
+                        [AuthType.Password]: { param: "aa" },
+                    },
                 },
-            }, 401);
+                401,
+            );
             throw err;
         });
 
         // .. which should be followed by a call to stateUpdated
-        const requestRes = { "a": "b" };
+        const requestRes = { a: "b" };
         stateUpdated.mockImplementation((stage) => {
             expect(stage).toEqual(AuthType.Password);
             expect(ia.getSessionId()).toEqual("sessionId");
@@ -272,20 +267,21 @@ describe("InteractiveAuth", () => {
         doRequest.mockImplementation((authData) => {
             logger.log("request1", authData);
             expect(authData).toEqual(null); // first request should be null
-            const err = new MatrixError({
-                session: "sessionId",
-                flows: [
-                    { stages: [AuthType.Password] },
-                ],
-                params: {
-                    [AuthType.Password]: { param: "aa" },
+            const err = new MatrixError(
+                {
+                    session: "sessionId",
+                    flows: [{ stages: [AuthType.Password] }],
+                    params: {
+                        [AuthType.Password]: { param: "aa" },
+                    },
                 },
-            }, 401);
+                401,
+            );
             throw err;
         });
 
         // .. which should be followed by a call to stateUpdated
-        const requestRes = { "a": "b" };
+        const requestRes = { a: "b" };
         stateUpdated.mockImplementation((stage) => {
             expect(stage).toEqual(AuthType.Password);
             expect(ia.getSessionId()).toEqual("sessionId");
@@ -329,19 +325,20 @@ describe("InteractiveAuth", () => {
         doRequest.mockImplementation((authData) => {
             logger.log("request1", authData);
             expect(authData).toEqual(null); // first request should be null
-            const err = new MatrixError({
-                session: "sessionId",
-                flows: [],
-                params: {
-                    [AuthType.Password]: { param: "aa" },
+            const err = new MatrixError(
+                {
+                    session: "sessionId",
+                    flows: [],
+                    params: {
+                        [AuthType.Password]: { param: "aa" },
+                    },
                 },
-            }, 401);
+                401,
+            );
             throw err;
         });
 
-        await expect(ia.attemptAuth.bind(ia)).rejects.toThrow(
-            new Error('No appropriate authentication flow found'),
-        );
+        await expect(ia.attemptAuth.bind(ia)).rejects.toThrow(new Error("No appropriate authentication flow found"));
     });
 
     it("should start an auth stage and reject if no auth flow but has session", async () => {
@@ -354,29 +351,29 @@ describe("InteractiveAuth", () => {
             doRequest,
             stateUpdated,
             requestEmailToken,
-            authData: {
-            },
+            authData: {},
             sessionId: "sessionId",
         });
 
         doRequest.mockImplementation((authData) => {
             logger.log("request1", authData);
-            expect(authData).toEqual({ "session": "sessionId" }); // has existing sessionId
-            const err = new MatrixError({
-                session: "sessionId",
-                flows: [],
-                params: {
-                    [AuthType.Password]: { param: "aa" },
+            expect(authData).toEqual({ session: "sessionId" }); // has existing sessionId
+            const err = new MatrixError(
+                {
+                    session: "sessionId",
+                    flows: [],
+                    params: {
+                        [AuthType.Password]: { param: "aa" },
+                    },
+                    error: "Mock Error 1",
+                    errcode: "MOCKERR1",
                 },
-                error: "Mock Error 1",
-                errcode: "MOCKERR1",
-            }, 401);
+                401,
+            );
             throw err;
         });
 
-        await expect(ia.attemptAuth.bind(ia)).rejects.toThrow(
-            new Error('No appropriate authentication flow found'),
-        );
+        await expect(ia.attemptAuth.bind(ia)).rejects.toThrow(new Error("No appropriate authentication flow found"));
     });
 
     it("should handle unexpected error types without data propery set", async () => {
@@ -396,14 +393,12 @@ describe("InteractiveAuth", () => {
 
         doRequest.mockImplementation((authData) => {
             logger.log("request1", authData);
-            expect(authData).toEqual({ "session": "sessionId" }); // has existing sessionId
-            const err = new HTTPError('myerror', 401);
+            expect(authData).toEqual({ session: "sessionId" }); // has existing sessionId
+            const err = new HTTPError("myerror", 401);
             throw err;
         });
 
-        await expect(ia.attemptAuth.bind(ia)).rejects.toThrow(
-            new Error("myerror"),
-        );
+        await expect(ia.attemptAuth.bind(ia)).rejects.toThrow(new Error("myerror"));
     });
 
     it("should allow dummy auth", async () => {
@@ -417,15 +412,13 @@ describe("InteractiveAuth", () => {
             stateUpdated,
             requestEmailToken,
             authData: {
-                session: 'sessionId',
-                flows: [
-                    { stages: [AuthType.Dummy] },
-                ],
+                session: "sessionId",
+                flows: [{ stages: [AuthType.Dummy] }],
                 params: {},
             },
         });
 
-        const requestRes = { "a": "b" };
+        const requestRes = { a: "b" };
         doRequest.mockImplementation((authData) => {
             logger.log("request1", authData);
             expect(authData).toEqual({
@@ -450,7 +443,9 @@ describe("InteractiveAuth", () => {
 
             const ia = new InteractiveAuth({
                 matrixClient: getFakeClient(),
-                doRequest, stateUpdated, requestEmailToken,
+                doRequest,
+                stateUpdated,
+                requestEmailToken,
             });
 
             await ia.requestEmailToken();
@@ -477,7 +472,9 @@ describe("InteractiveAuth", () => {
 
             const ia = new InteractiveAuth({
                 matrixClient: getFakeClient(),
-                doRequest, stateUpdated, requestEmailToken,
+                doRequest,
+                stateUpdated,
+                requestEmailToken,
             });
 
             await ia.requestEmailToken();
@@ -506,7 +503,9 @@ describe("InteractiveAuth", () => {
 
             const ia = new InteractiveAuth({
                 matrixClient: getFakeClient(),
-                doRequest, stateUpdated, requestEmailToken,
+                doRequest,
+                stateUpdated,
+                requestEmailToken,
             });
 
             await expect(ia.requestEmailToken.bind(ia)).rejects.toThrowError("unspecific network error");
@@ -520,7 +519,9 @@ describe("InteractiveAuth", () => {
 
             const ia = new InteractiveAuth({
                 matrixClient: getFakeClient(),
-                doRequest, stateUpdated, requestEmailToken,
+                doRequest,
+                stateUpdated,
+                requestEmailToken,
             });
 
             await Promise.all([ia.requestEmailToken(), ia.requestEmailToken(), ia.requestEmailToken()]);
@@ -536,7 +537,9 @@ describe("InteractiveAuth", () => {
 
             const ia = new InteractiveAuth({
                 matrixClient: getFakeClient(),
-                doRequest, stateUpdated, requestEmailToken,
+                doRequest,
+                stateUpdated,
+                requestEmailToken,
             });
 
             await ia.requestEmailToken();
diff --git a/spec/unit/local_notifications.spec.ts b/spec/unit/local_notifications.spec.ts
index 4f6f0c32a3c..e46d462ad96 100644
--- a/spec/unit/local_notifications.spec.ts
+++ b/spec/unit/local_notifications.spec.ts
@@ -16,15 +16,13 @@ limitations under the License.
 
 import { LocalNotificationSettings } from "../../src/@types/local_notifications";
 import { LOCAL_NOTIFICATION_SETTINGS_PREFIX, MatrixClient } from "../../src/matrix";
-import { TestClient } from '../TestClient';
+import { TestClient } from "../TestClient";
 
 let client: MatrixClient;
 
 describe("Local notification settings", () => {
     beforeEach(() => {
-        client = (new TestClient(
-            "@alice:matrix.org", "123", undefined, undefined, undefined,
-        )).client;
+        client = new TestClient("@alice:matrix.org", "123", undefined, undefined, undefined).client;
         client.setAccountData = jest.fn();
     });
 
diff --git a/spec/unit/location.spec.ts b/spec/unit/location.spec.ts
index d7bdf407fa5..b2d2a50d701 100644
--- a/spec/unit/location.spec.ts
+++ b/spec/unit/location.spec.ts
@@ -25,13 +25,13 @@ import {
 import { TEXT_NODE_TYPE } from "../../src/@types/extensible_events";
 import { MsgType } from "../../src/@types/event";
 
-describe("Location", function() {
+describe("Location", function () {
     const defaultContent = {
-        "body": "Location geo:-36.24484561954707,175.46884959563613;u=10 at 2022-03-09T11:01:52.443Z",
-        "msgtype": "m.location",
-        "geo_uri": "geo:-36.24484561954707,175.46884959563613;u=10",
-        [M_LOCATION.name]: { "uri": "geo:-36.24484561954707,175.46884959563613;u=10", "description": null },
-        [M_ASSET.name]: { "type": "m.self" },
+        body: "Location geo:-36.24484561954707,175.46884959563613;u=10 at 2022-03-09T11:01:52.443Z",
+        msgtype: "m.location",
+        geo_uri: "geo:-36.24484561954707,175.46884959563613;u=10",
+        [M_LOCATION.name]: { uri: "geo:-36.24484561954707,175.46884959563613;u=10", description: null },
+        [M_ASSET.name]: { type: "m.self" },
         [TEXT_NODE_TYPE.name]: "Location geo:-36.24484561954707,175.46884959563613;u=10 at 2022-03-09T11:01:52.443Z",
         [M_TIMESTAMP.name]: 1646823712443,
     } as any;
@@ -44,12 +44,14 @@ describe("Location", function() {
 
     const legacyEventContent = {
         // eslint-disable-next-line camelcase
-        body, msgtype, geo_uri,
+        body,
+        msgtype,
+        geo_uri,
     } as LocationEventWireContent;
 
-    it("should create a valid location with defaults", function() {
+    it("should create a valid location with defaults", function () {
         const loc = makeLocationContent(undefined, "geo:foo", 134235435);
-        expect(loc.body).toEqual('User Location geo:foo at 1970-01-02T13:17:15.435Z');
+        expect(loc.body).toEqual("User Location geo:foo at 1970-01-02T13:17:15.435Z");
         expect(loc.msgtype).toEqual(MsgType.Location);
         expect(loc.geo_uri).toEqual("geo:foo");
         expect(M_LOCATION.findIn(loc)).toEqual({
@@ -57,13 +59,12 @@ describe("Location", function() {
             description: undefined,
         });
         expect(M_ASSET.findIn(loc)).toEqual({ type: LocationAssetType.Self });
-        expect(TEXT_NODE_TYPE.findIn(loc)).toEqual('User Location geo:foo at 1970-01-02T13:17:15.435Z');
+        expect(TEXT_NODE_TYPE.findIn(loc)).toEqual("User Location geo:foo at 1970-01-02T13:17:15.435Z");
         expect(M_TIMESTAMP.findIn(loc)).toEqual(134235435);
     });
 
-    it("should create a valid location with explicit properties", function() {
-        const loc = makeLocationContent(
-            undefined, "geo:bar", 134235436, "desc", LocationAssetType.Pin);
+    it("should create a valid location with explicit properties", function () {
+        const loc = makeLocationContent(undefined, "geo:bar", 134235436, "desc", LocationAssetType.Pin);
 
         expect(loc.body).toEqual('Location "desc" geo:bar at 1970-01-02T13:17:15.436Z');
         expect(loc.msgtype).toEqual(MsgType.Location);
@@ -77,19 +78,19 @@ describe("Location", function() {
         expect(M_TIMESTAMP.findIn(loc)).toEqual(134235436);
     });
 
-    it('parses backwards compatible event correctly', () => {
+    it("parses backwards compatible event correctly", () => {
         const eventContent = parseLocationEvent(backwardsCompatibleEventContent);
 
         expect(eventContent).toEqual(backwardsCompatibleEventContent);
     });
 
-    it('parses modern correctly', () => {
+    it("parses modern correctly", () => {
         const eventContent = parseLocationEvent(modernEventContent);
 
         expect(eventContent).toEqual(backwardsCompatibleEventContent);
     });
 
-    it('parses legacy event correctly', () => {
+    it("parses legacy event correctly", () => {
         const eventContent = parseLocationEvent(legacyEventContent);
 
         const {
diff --git a/spec/unit/login.spec.ts b/spec/unit/login.spec.ts
index 6b3ae47fe97..a1951d18ca3 100644
--- a/spec/unit/login.spec.ts
+++ b/spec/unit/login.spec.ts
@@ -1,59 +1,59 @@
-import { SSOAction } from '../../src/@types/auth';
-import { TestClient } from '../TestClient';
+import { SSOAction } from "../../src/@types/auth";
+import { TestClient } from "../TestClient";
 
-describe('Login request', function() {
+describe("Login request", function () {
     let client: TestClient;
 
-    beforeEach(function() {
+    beforeEach(function () {
         client = new TestClient();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         client.stop();
     });
 
-    it('should store "access_token" and "user_id" if in response', async function() {
+    it('should store "access_token" and "user_id" if in response', async function () {
         const response = { user_id: 1, access_token: Date.now().toString(16) };
 
-        client.httpBackend.when('POST', '/login').respond(200, response);
-        client.httpBackend.flush('/login', 1, 100);
-        await client.client.login('m.login.any', { user: 'test', password: '12312za' });
+        client.httpBackend.when("POST", "/login").respond(200, response);
+        client.httpBackend.flush("/login", 1, 100);
+        await client.client.login("m.login.any", { user: "test", password: "12312za" });
 
         expect(client.client.getAccessToken()).toBe(response.access_token);
         expect(client.client.getUserId()).toBe(response.user_id);
     });
 });
 
-describe('SSO login URL', function() {
+describe("SSO login URL", function () {
     let client: TestClient;
 
-    beforeEach(function() {
+    beforeEach(function () {
         client = new TestClient();
     });
 
-    afterEach(function() {
+    afterEach(function () {
         client.stop();
     });
 
-    describe('SSOAction', function() {
+    describe("SSOAction", function () {
         const redirectUri = "https://test.com/foo";
 
-        it('No action', function() {
+        it("No action", function () {
             const urlString = client.client.getSsoLoginUrl(redirectUri, undefined, undefined, undefined);
             const url = new URL(urlString);
-            expect(url.searchParams.has('org.matrix.msc3824.action')).toBe(false);
+            expect(url.searchParams.has("org.matrix.msc3824.action")).toBe(false);
         });
 
-        it('register', function() {
+        it("register", function () {
             const urlString = client.client.getSsoLoginUrl(redirectUri, undefined, undefined, SSOAction.REGISTER);
             const url = new URL(urlString);
-            expect(url.searchParams.get('org.matrix.msc3824.action')).toEqual('register');
+            expect(url.searchParams.get("org.matrix.msc3824.action")).toEqual("register");
         });
 
-        it('login', function() {
+        it("login", function () {
             const urlString = client.client.getSsoLoginUrl(redirectUri, undefined, undefined, SSOAction.LOGIN);
             const url = new URL(urlString);
-            expect(url.searchParams.get('org.matrix.msc3824.action')).toEqual('login');
+            expect(url.searchParams.get("org.matrix.msc3824.action")).toEqual("login");
         });
     });
 });
diff --git a/spec/unit/matrix-client.spec.ts b/spec/unit/matrix-client.spec.ts
index 419ef50206c..b13dfc125be 100644
--- a/spec/unit/matrix-client.spec.ts
+++ b/spec/unit/matrix-client.spec.ts
@@ -38,7 +38,8 @@ import { makeBeaconInfoContent } from "../../src/content-helpers";
 import { M_BEACON_INFO } from "../../src/@types/beacon";
 import {
     ContentHelpers,
-    EventTimeline, ICreateRoomOpts,
+    EventTimeline,
+    ICreateRoomOpts,
     IRequestOpts,
     MatrixError,
     MatrixHttpApi,
@@ -83,7 +84,7 @@ type WrappedRoom = Room & {
     _state: Map<string, any>;
 };
 
-describe("MatrixClient", function() {
+describe("MatrixClient", function () {
     const userId = "@alice:bar";
     const identityServerUrl = "https://identity.server";
     const identityServerDomain = "identity.server";
@@ -137,13 +138,20 @@ describe("MatrixClient", function() {
             });
         }
         const next = httpLookups.shift();
-        const logLine = (
-            "MatrixClient[UT] RECV " + method + " " + path + "  " +
-            "EXPECT " + (next ? next.method : next) + " " + (next ? next.path : next)
-        );
+        const logLine =
+            "MatrixClient[UT] RECV " +
+            method +
+            " " +
+            path +
+            "  " +
+            "EXPECT " +
+            (next ? next.method : next) +
+            " " +
+            (next ? next.path : next);
         logger.log(logLine);
 
-        if (!next) { // no more things to return
+        if (!next) {
+            // no more things to return
             if (pendingLookup) {
                 if (pendingLookup.method === method && pendingLookup.path === path) {
                     return pendingLookup.promise;
@@ -159,15 +167,12 @@ describe("MatrixClient", function() {
             return pendingLookup.promise;
         }
         if (next.path === path && next.method === method) {
-            logger.log(
-                "MatrixClient[UT] Matched. Returning " +
-                (next.error ? "BAD" : "GOOD") + " response",
-            );
+            logger.log("MatrixClient[UT] Matched. Returning " + (next.error ? "BAD" : "GOOD") + " response");
             if (next.expectBody) {
                 expect(data).toEqual(next.expectBody);
             }
             if (next.expectQueryParams) {
-                Object.keys(next.expectQueryParams).forEach(function(k) {
+                Object.keys(next.expectQueryParams).forEach(function (k) {
                     expect(qp?.[k]).toEqual(next.expectQueryParams![k]);
                 });
             }
@@ -201,18 +206,13 @@ describe("MatrixClient", function() {
             baseUrl: "https://my.home.server",
             idBaseUrl: identityServerUrl,
             accessToken: "my.access.token",
-            fetchFn: function() {} as any, // NOP
+            fetchFn: function () {} as any, // NOP
             store: store,
             scheduler: scheduler,
             userId: userId,
         });
         // FIXME: We shouldn't be yanking http like this.
-        client.http = ([
-            "authedRequest",
-            "getContentUri",
-            "request",
-            "uploadContent",
-        ] as const).reduce((r, k) => {
+        client.http = (["authedRequest", "getContentUri", "request", "uploadContent"] as const).reduce((r, k) => {
             r[k] = jest.fn();
             return r;
         }, {} as MatrixHttpApi<any>);
@@ -220,22 +220,35 @@ describe("MatrixClient", function() {
         mocked(client.http.request).mockImplementation(httpReq);
     }
 
-    beforeEach(function() {
-        scheduler = ([
-            "getQueueForEvent",
-            "queueEvent",
-            "removeEventFromQueue",
-            "setProcessFunction",
-        ] as const).reduce((r, k) => {
-            r[k] = jest.fn();
-            return r;
-        }, {} as MatrixScheduler);
-        store = ([
-            "getRoom", "getRooms", "getUser", "getSyncToken", "scrollback",
-            "save", "wantsSave", "setSyncToken", "storeEvents", "storeRoom", "storeUser",
-            "getFilterIdByName", "setFilterIdByName", "getFilter", "storeFilter",
-            "startup", "deleteAllData",
-        ] as const).reduce((r, k) => {
+    beforeEach(function () {
+        scheduler = (["getQueueForEvent", "queueEvent", "removeEventFromQueue", "setProcessFunction"] as const).reduce(
+            (r, k) => {
+                r[k] = jest.fn();
+                return r;
+            },
+            {} as MatrixScheduler,
+        );
+        store = (
+            [
+                "getRoom",
+                "getRooms",
+                "getUser",
+                "getSyncToken",
+                "scrollback",
+                "save",
+                "wantsSave",
+                "setSyncToken",
+                "storeEvents",
+                "storeRoom",
+                "storeUser",
+                "getFilterIdByName",
+                "setFilterIdByName",
+                "getFilter",
+                "storeFilter",
+                "startup",
+                "deleteAllData",
+            ] as const
+        ).reduce((r, k) => {
             r[k] = jest.fn();
             return r;
         }, {} as Store);
@@ -256,13 +269,13 @@ describe("MatrixClient", function() {
         httpLookups.push(SYNC_RESPONSE);
     });
 
-    afterEach(function() {
+    afterEach(function () {
         // need to re-stub the requests with NOPs because there are no guarantees
         // clients from previous tests will be GC'd before the next test. This
         // means they may call /events and then fail an expect() which will fail
         // a DIFFERENT test (pollution between tests!) - we return unresolved
         // promises to stop the client from continuing to run.
-        mocked(client.http.authedRequest).mockImplementation(function() {
+        mocked(client.http.authedRequest).mockImplementation(function () {
             return new Promise(() => {});
         });
         client.stopClient();
@@ -276,12 +289,14 @@ describe("MatrixClient", function() {
         it("overload without threadId works", async () => {
             const eventId = "$eventId:example.org";
             const txnId = client.makeTxnId();
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
-                data: { event_id: eventId },
-                expectBody: content,
-            }];
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
+                    data: { event_id: eventId },
+                    expectBody: content,
+                },
+            ];
 
             await client.sendEvent(roomId, EventType.RoomMessage, { ...content }, txnId);
         });
@@ -289,12 +304,14 @@ describe("MatrixClient", function() {
         it("overload with null threadId works", async () => {
             const eventId = "$eventId:example.org";
             const txnId = client.makeTxnId();
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
-                data: { event_id: eventId },
-                expectBody: content,
-            }];
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
+                    data: { event_id: eventId },
+                    expectBody: content,
+                },
+            ];
 
             await client.sendEvent(roomId, null, EventType.RoomMessage, { ...content }, txnId);
         });
@@ -303,19 +320,21 @@ describe("MatrixClient", function() {
             const eventId = "$eventId:example.org";
             const txnId = client.makeTxnId();
             const threadId = "$threadId:server";
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
-                data: { event_id: eventId },
-                expectBody: {
-                    ...content,
-                    "m.relates_to": {
-                        "event_id": threadId,
-                        "is_falling_back": true,
-                        "rel_type": "m.thread",
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
+                    data: { event_id: eventId },
+                    expectBody: {
+                        ...content,
+                        "m.relates_to": {
+                            event_id: threadId,
+                            is_falling_back: true,
+                            rel_type: "m.thread",
+                        },
                     },
                 },
-            }];
+            ];
 
             await client.sendEvent(roomId, threadId, EventType.RoomMessage, { ...content }, txnId);
         });
@@ -331,22 +350,24 @@ describe("MatrixClient", function() {
             const rootEvent = new MatrixEvent({ event_id: threadId });
             room.createThread(threadId, rootEvent, [rootEvent], false);
 
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
-                data: { event_id: eventId },
-                expectBody: {
-                    ...content,
-                    "m.relates_to": {
-                        "m.in_reply_to": {
-                            event_id: threadId,
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
+                    data: { event_id: eventId },
+                    expectBody: {
+                        ...content,
+                        "m.relates_to": {
+                            "m.in_reply_to": {
+                                event_id: threadId,
+                            },
+                            "event_id": threadId,
+                            "is_falling_back": true,
+                            "rel_type": "m.thread",
                         },
-                        "event_id": threadId,
-                        "is_falling_back": true,
-                        "rel_type": "m.thread",
                     },
                 },
-            }];
+            ];
 
             await client.sendEvent(roomId, threadId, EventType.RoomMessage, { ...content }, txnId);
         });
@@ -371,22 +392,24 @@ describe("MatrixClient", function() {
             const rootEvent = new MatrixEvent({ event_id: threadId });
             room.createThread(threadId, rootEvent, [rootEvent], false);
 
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
-                data: { event_id: eventId },
-                expectBody: {
-                    ...content,
-                    "m.relates_to": {
-                        "m.in_reply_to": {
-                            event_id: "$other:event",
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`,
+                    data: { event_id: eventId },
+                    expectBody: {
+                        ...content,
+                        "m.relates_to": {
+                            "m.in_reply_to": {
+                                event_id: "$other:event",
+                            },
+                            "event_id": threadId,
+                            "is_falling_back": false,
+                            "rel_type": "m.thread",
                         },
-                        "event_id": threadId,
-                        "is_falling_back": false,
-                        "rel_type": "m.thread",
                     },
                 },
-            }];
+            ];
 
             await client.sendEvent(roomId, threadId, EventType.RoomMessage, { ...content }, txnId);
         });
@@ -572,15 +595,12 @@ describe("MatrixClient", function() {
         expect(tree).toBeFalsy();
     });
 
-    it("should not POST /filter if a matching filter already exists", async function() {
-        httpLookups = [
-            PUSH_RULES_RESPONSE,
-            SYNC_RESPONSE,
-        ];
+    it("should not POST /filter if a matching filter already exists", async function () {
+        httpLookups = [PUSH_RULES_RESPONSE, SYNC_RESPONSE];
         const filterId = "ehfewf";
         mocked(store.getFilterIdByName).mockReturnValue(filterId);
         const filter = new Filter("0", filterId);
-        filter.setDefinition({ "room": { "timeline": { "limit": 8 } } });
+        filter.setDefinition({ room: { timeline: { limit: 8 } } });
         mocked(store.getFilter).mockReturnValue(filter);
         const syncPromise = new Promise<void>((resolve, reject) => {
             client.on(ClientEvent.Sync, function syncListener(state) {
@@ -597,12 +617,12 @@ describe("MatrixClient", function() {
         await syncPromise;
     });
 
-    describe("getSyncState", function() {
-        it("should return null if the client isn't started", function() {
+    describe("getSyncState", function () {
+        it("should return null if the client isn't started", function () {
             expect(client.getSyncState()).toBe(null);
         });
 
-        it("should return the same sync state as emitted sync events", async function() {
+        it("should return the same sync state as emitted sync events", async function () {
             const syncingPromise = new Promise<void>((resolve) => {
                 client.on(ClientEvent.Sync, function syncListener(state) {
                     expect(state).toEqual(client.getSyncState());
@@ -617,22 +637,20 @@ describe("MatrixClient", function() {
         });
     });
 
-    describe("getOrCreateFilter", function() {
-        it("should POST createFilter if no id is present in localStorage", function() {
-        });
-        it("should use an existing filter if id is present in localStorage", function() {
-        });
-        it("should handle localStorage filterId missing from the server", function(done) {
+    describe("getOrCreateFilter", function () {
+        it("should POST createFilter if no id is present in localStorage", function () {});
+        it("should use an existing filter if id is present in localStorage", function () {});
+        it("should handle localStorage filterId missing from the server", function (done) {
             function getFilterName(userId: string, suffix?: string) {
                 // scope this on the user ID because people may login on many accounts
                 // and they all need to be stored!
                 return "FILTER_SYNC_" + userId + (suffix ? "_" + suffix : "");
             }
-            const invalidFilterId = 'invalidF1lt3r';
+            const invalidFilterId = "invalidF1lt3r";
             httpLookups = [];
             httpLookups.push({
                 method: "GET",
-                path: FILTER_PATH + '/' + invalidFilterId,
+                path: FILTER_PATH + "/" + invalidFilterId,
                 error: {
                     errcode: "M_UNKNOWN",
                     name: "M_UNKNOWN",
@@ -648,25 +666,27 @@ describe("MatrixClient", function() {
             client.store.setFilterIdByName(filterName, invalidFilterId);
             const filter = new Filter(client.credentials.userId);
 
-            client.getOrCreateFilter(filterName, filter).then(function(filterId) {
+            client.getOrCreateFilter(filterName, filter).then(function (filterId) {
                 expect(filterId).toEqual(FILTER_RESPONSE.data?.filter_id);
                 done();
             });
         });
     });
 
-    describe("retryImmediately", function() {
-        it("should return false if there is no request waiting", async function() {
+    describe("retryImmediately", function () {
+        it("should return false if there is no request waiting", async function () {
             httpLookups = [];
             await client.startClient();
             expect(client.retryImmediately()).toBe(false);
         });
 
-        it("should work on /filter", function(done) {
+        it("should work on /filter", function (done) {
             httpLookups = [];
             httpLookups.push(PUSH_RULES_RESPONSE);
             httpLookups.push({
-                method: "POST", path: FILTER_PATH, error: { errcode: "NOPE_NOPE_NOPE" },
+                method: "POST",
+                path: FILTER_PATH,
+                error: { errcode: "NOPE_NOPE_NOPE" },
             });
             httpLookups.push(FILTER_RESPONSE);
             httpLookups.push(SYNC_RESPONSE);
@@ -687,20 +707,22 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        it("should work on /sync", function(done) {
+        it("should work on /sync", function (done) {
             httpLookups.push({
-                method: "GET", path: "/sync", error: { errcode: "NOPE_NOPE_NOPE" },
+                method: "GET",
+                path: "/sync",
+                error: { errcode: "NOPE_NOPE_NOPE" },
             });
             httpLookups.push({
-                method: "GET", path: "/sync", data: SYNC_DATA,
+                method: "GET",
+                path: "/sync",
+                data: SYNC_DATA,
             });
 
             client.on(ClientEvent.Sync, function syncListener(state) {
                 if (state === "ERROR" && httpLookups.length > 0) {
                     expect(httpLookups.length).toEqual(1);
-                    expect(client.retryImmediately()).toBe(
-                        true,
-                    );
+                    expect(client.retryImmediately()).toBe(true);
                     jest.advanceTimersByTime(1);
                 } else if (state === "RECONNECTING" && httpLookups.length > 0) {
                     jest.advanceTimersByTime(10000);
@@ -712,10 +734,12 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        it("should work on /pushrules", function(done) {
+        it("should work on /pushrules", function (done) {
             httpLookups = [];
             httpLookups.push({
-                method: "GET", path: "/pushrules/", error: { errcode: "NOPE_NOPE_NOPE" },
+                method: "GET",
+                path: "/pushrules/",
+                error: { errcode: "NOPE_NOPE_NOPE" },
             });
             httpLookups.push(PUSH_RULES_RESPONSE);
             httpLookups.push(FILTER_RESPONSE);
@@ -738,13 +762,11 @@ describe("MatrixClient", function() {
         });
     });
 
-    describe("emitted sync events", function() {
+    describe("emitted sync events", function () {
         function syncChecker(expectedStates: [string, string | null][], done: Function) {
             return function syncListener(state: SyncState, old: SyncState | null) {
                 const expected = expectedStates.shift();
-                logger.log(
-                    "'sync' curr=%s old=%s EXPECT=%s", state, old, expected,
-                );
+                logger.log("'sync' curr=%s old=%s EXPECT=%s", state, old, expected);
                 if (!expected) {
                     done();
                     return;
@@ -760,19 +782,21 @@ describe("MatrixClient", function() {
             };
         }
 
-        it("should transition null -> PREPARED after the first /sync", function(done) {
+        it("should transition null -> PREPARED after the first /sync", function (done) {
             const expectedStates: [string, string | null][] = [];
             expectedStates.push(["PREPARED", null]);
             client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
             client.startClient();
         });
 
-        it("should transition null -> ERROR after a failed /filter", function(done) {
+        it("should transition null -> ERROR after a failed /filter", function (done) {
             const expectedStates: [string, string | null][] = [];
             httpLookups = [];
             httpLookups.push(PUSH_RULES_RESPONSE);
             httpLookups.push({
-                method: "POST", path: FILTER_PATH, error: { errcode: "NOPE_NOPE_NOPE" },
+                method: "POST",
+                path: FILTER_PATH,
+                error: { errcode: "NOPE_NOPE_NOPE" },
             });
             expectedStates.push(["ERROR", null]);
             client.on(ClientEvent.Sync, syncChecker(expectedStates, done));
@@ -782,24 +806,31 @@ describe("MatrixClient", function() {
         // Disabled because now `startClient` makes a legit call to `/versions`
         // And those tests are really unhappy about it... Not possible to figure
         // out what a good resolution would look like
-        xit("should transition ERROR -> CATCHUP after /sync if prev failed", function(done) {
+        xit("should transition ERROR -> CATCHUP after /sync if prev failed", function (done) {
             const expectedStates: [string, string | null][] = [];
             acceptKeepalives = false;
             httpLookups = [];
             httpLookups.push(PUSH_RULES_RESPONSE);
             httpLookups.push(FILTER_RESPONSE);
             httpLookups.push({
-                method: "GET", path: "/sync", error: { errcode: "NOPE_NOPE_NOPE" },
+                method: "GET",
+                path: "/sync",
+                error: { errcode: "NOPE_NOPE_NOPE" },
             });
             httpLookups.push({
-                method: "GET", path: KEEP_ALIVE_PATH,
+                method: "GET",
+                path: KEEP_ALIVE_PATH,
                 error: { errcode: "KEEPALIVE_FAIL" },
             });
             httpLookups.push({
-                method: "GET", path: KEEP_ALIVE_PATH, data: {},
+                method: "GET",
+                path: KEEP_ALIVE_PATH,
+                data: {},
             });
             httpLookups.push({
-                method: "GET", path: "/sync", data: SYNC_DATA,
+                method: "GET",
+                path: "/sync",
+                data: SYNC_DATA,
             });
 
             expectedStates.push(["RECONNECTING", null]);
@@ -809,7 +840,7 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        it("should transition PREPARED -> SYNCING after /sync", function(done) {
+        it("should transition PREPARED -> SYNCING after /sync", function (done) {
             const expectedStates: [string, string | null][] = [];
             expectedStates.push(["PREPARED", null]);
             expectedStates.push(["SYNCING", "PREPARED"]);
@@ -817,14 +848,17 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        xit("should transition SYNCING -> ERROR after a failed /sync", function(done) {
+        xit("should transition SYNCING -> ERROR after a failed /sync", function (done) {
             acceptKeepalives = false;
             const expectedStates: [string, string | null][] = [];
             httpLookups.push({
-                method: "GET", path: "/sync", error: { errcode: "NONONONONO" },
+                method: "GET",
+                path: "/sync",
+                error: { errcode: "NONONONONO" },
             });
             httpLookups.push({
-                method: "GET", path: KEEP_ALIVE_PATH,
+                method: "GET",
+                path: KEEP_ALIVE_PATH,
                 error: { errcode: "KEEPALIVE_FAIL" },
             });
 
@@ -836,10 +870,12 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        xit("should transition ERROR -> SYNCING after /sync if prev failed", function(done) {
+        xit("should transition ERROR -> SYNCING after /sync if prev failed", function (done) {
             const expectedStates: [string, string | null][] = [];
             httpLookups.push({
-                method: "GET", path: "/sync", error: { errcode: "NONONONONO" },
+                method: "GET",
+                path: "/sync",
+                error: { errcode: "NONONONONO" },
             });
             httpLookups.push(SYNC_RESPONSE);
 
@@ -850,7 +886,7 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        it("should transition SYNCING -> SYNCING on subsequent /sync successes", function(done) {
+        it("should transition SYNCING -> SYNCING on subsequent /sync successes", function (done) {
             const expectedStates: [string, string | null][] = [];
             httpLookups.push(SYNC_RESPONSE);
             httpLookups.push(SYNC_RESPONSE);
@@ -862,18 +898,22 @@ describe("MatrixClient", function() {
             client.startClient();
         });
 
-        xit("should transition ERROR -> ERROR if keepalive keeps failing", function(done) {
+        xit("should transition ERROR -> ERROR if keepalive keeps failing", function (done) {
             acceptKeepalives = false;
             const expectedStates: [string, string | null][] = [];
             httpLookups.push({
-                method: "GET", path: "/sync", error: { errcode: "NONONONONO" },
+                method: "GET",
+                path: "/sync",
+                error: { errcode: "NONONONONO" },
             });
             httpLookups.push({
-                method: "GET", path: KEEP_ALIVE_PATH,
+                method: "GET",
+                path: KEEP_ALIVE_PATH,
                 error: { errcode: "KEEPALIVE_FAIL" },
             });
             httpLookups.push({
-                method: "GET", path: KEEP_ALIVE_PATH,
+                method: "GET",
+                path: KEEP_ALIVE_PATH,
                 error: { errcode: "KEEPALIVE_FAIL" },
             });
 
@@ -887,27 +927,29 @@ describe("MatrixClient", function() {
         });
     });
 
-    describe("inviteByEmail", function() {
+    describe("inviteByEmail", function () {
         const roomId = "!foo:bar";
 
-        it("should send an invite HTTP POST", function() {
-            httpLookups = [{
-                method: "POST",
-                path: "/rooms/!foo%3Abar/invite",
-                data: {},
-                expectBody: {
-                    id_server: identityServerDomain,
-                    medium: "email",
-                    address: "alice@gmail.com",
+        it("should send an invite HTTP POST", function () {
+            httpLookups = [
+                {
+                    method: "POST",
+                    path: "/rooms/!foo%3Abar/invite",
+                    data: {},
+                    expectBody: {
+                        id_server: identityServerDomain,
+                        medium: "email",
+                        address: "alice@gmail.com",
+                    },
                 },
-            }];
+            ];
             client.inviteByEmail(roomId, "alice@gmail.com");
             expect(httpLookups.length).toEqual(0);
         });
     });
 
-    describe("guest rooms", function() {
-        it("should only do /sync calls (without filter/pushrules)", async function() {
+    describe("guest rooms", function () {
+        it("should only do /sync calls (without filter/pushrules)", async function () {
             httpLookups = []; // no /pushrules or /filter
             httpLookups.push({
                 method: "GET",
@@ -919,20 +961,21 @@ describe("MatrixClient", function() {
             expect(httpLookups.length).toBe(0);
         });
 
-        xit("should be able to peek into a room using peekInRoom", function(done) {
-        });
+        xit("should be able to peek into a room using peekInRoom", function (done) {});
     });
 
-    describe("getPresence", function() {
-        it("should send a presence HTTP GET", function() {
-            httpLookups = [{
-                method: "GET",
-                path: `/presence/${encodeURIComponent(userId)}/status`,
-                data: {
-                    "presence": "unavailable",
-                    "last_active_ago": 420845,
+    describe("getPresence", function () {
+        it("should send a presence HTTP GET", function () {
+            httpLookups = [
+                {
+                    method: "GET",
+                    path: `/presence/${encodeURIComponent(userId)}/status`,
+                    data: {
+                        presence: "unavailable",
+                        last_active_ago: 420845,
+                    },
                 },
-            }];
+            ];
             client.getPresence(userId);
             expect(httpLookups.length).toEqual(0);
         });
@@ -970,11 +1013,13 @@ describe("MatrixClient", function() {
         it("overload without threadId works", async () => {
             const eventId = "$eventId:example.org";
             const txnId = client.makeTxnId();
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
-                data: { event_id: eventId },
-            }];
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
+                    data: { event_id: eventId },
+                },
+            ];
 
             await client.redactEvent(roomId, eventId, txnId);
         });
@@ -982,11 +1027,13 @@ describe("MatrixClient", function() {
         it("overload with null threadId works", async () => {
             const eventId = "$eventId:example.org";
             const txnId = client.makeTxnId();
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
-                data: { event_id: eventId },
-            }];
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
+                    data: { event_id: eventId },
+                },
+            ];
 
             await client.redactEvent(roomId, null, eventId, txnId);
         });
@@ -994,11 +1041,13 @@ describe("MatrixClient", function() {
         it("overload with threadId works", async () => {
             const eventId = "$eventId:example.org";
             const txnId = client.makeTxnId();
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
-                data: { event_id: eventId },
-            }];
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
+                    data: { event_id: eventId },
+                },
+            ];
 
             await client.redactEvent(roomId, "$threadId:server", eventId, txnId);
         });
@@ -1007,12 +1056,14 @@ describe("MatrixClient", function() {
             const eventId = "$eventId:example.org";
             const txnId = client.makeTxnId();
             const reason = "This is the redaction reason";
-            httpLookups = [{
-                method: "PUT",
-                path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
-                expectBody: { reason }, // NOT ENCRYPTED
-                data: { event_id: eventId },
-            }];
+            httpLookups = [
+                {
+                    method: "PUT",
+                    path: `/rooms/${encodeURIComponent(roomId)}/redact/${encodeURIComponent(eventId)}/${txnId}`,
+                    expectBody: { reason }, // NOT ENCRYPTED
+                    data: { event_id: eventId },
+                },
+            ];
 
             await client.redactEvent(roomId, eventId, txnId, { reason });
         });
@@ -1058,7 +1109,8 @@ describe("MatrixClient", function() {
                 expect(getRoomId).toEqual(roomId);
                 return mockRoom;
             };
-            client.crypto = { // mock crypto
+            client.crypto = {
+                // mock crypto
                 encryptEvent: () => new Promise(() => {}),
                 stop: jest.fn(),
             } as unknown as Crypto;
@@ -1067,7 +1119,7 @@ describe("MatrixClient", function() {
         function assertCancelled() {
             expect(event.status).toBe(EventStatus.CANCELLED);
             expect(client.scheduler?.removeEventFromQueue(event)).toBeFalsy();
-            expect(httpLookups.filter(h => h.path.includes("/send/")).length).toBe(0);
+            expect(httpLookups.filter((h) => h.path.includes("/send/")).length).toBe(0);
         }
 
         it("should cancel an event which is queued", () => {
@@ -1105,22 +1157,22 @@ describe("MatrixClient", function() {
             const room = new Room("!room1:matrix.org", client, userId);
 
             const rootEvent = new MatrixEvent({
-                "content": {},
-                "origin_server_ts": 1,
-                "room_id": "!room1:matrix.org",
-                "sender": "@alice:matrix.org",
-                "type": "m.room.message",
-                "unsigned": {
+                content: {},
+                origin_server_ts: 1,
+                room_id: "!room1:matrix.org",
+                sender: "@alice:matrix.org",
+                type: "m.room.message",
+                unsigned: {
                     "m.relations": {
                         "m.thread": {
-                            "latest_event": {},
-                            "count": 33,
-                            "current_user_participated": false,
+                            latest_event: {},
+                            count: 33,
+                            current_user_participated: false,
                         },
                     },
                 },
-                "event_id": "$ev1",
-                "user_id": "@alice:matrix.org",
+                event_id: "$ev1",
+                user_id: "@alice:matrix.org",
             });
 
             expect(rootEvent.isThreadRoot).toBe(true);
@@ -1145,12 +1197,7 @@ describe("MatrixClient", function() {
             const rpEvent = new MatrixEvent({ event_id: "read_private_event_id" });
             client.getRoom = () => room;
 
-            client.setRoomReadMarkers(
-                "room_id",
-                "read_marker_event_id",
-                rrEvent,
-                rpEvent,
-            );
+            client.setRoomReadMarkers("room_id", "read_marker_event_id", rrEvent, rpEvent);
 
             expect(client.setRoomReadMarkersHttpRequest).toHaveBeenCalledWith(
                 "room_id",
@@ -1175,7 +1222,7 @@ describe("MatrixClient", function() {
     });
 
     describe("beacons", () => {
-        const roomId = '!room:server.org';
+        const roomId = "!room:server.org";
         const content = makeBeaconInfoContent(100, true);
 
         beforeEach(() => {
@@ -1188,10 +1235,10 @@ describe("MatrixClient", function() {
             // event type combined
             const expectedEventType = M_BEACON_INFO.name;
             const [method, path, queryParams, requestContent] = mocked(client.http.authedRequest).mock.calls[0];
-            expect(method).toBe('PUT');
+            expect(method).toBe("PUT");
             expect(path).toEqual(
                 `/rooms/${encodeURIComponent(roomId)}/state/` +
-                `${encodeURIComponent(expectedEventType)}/${encodeURIComponent(userId)}`,
+                    `${encodeURIComponent(expectedEventType)}/${encodeURIComponent(userId)}`,
             );
             expect(queryParams).toBeFalsy();
             expect(requestContent).toEqual(content);
@@ -1204,31 +1251,31 @@ describe("MatrixClient", function() {
             const [, path, , requestContent] = mocked(client.http.authedRequest).mock.calls[0];
             expect(path).toEqual(
                 `/rooms/${encodeURIComponent(roomId)}/state/` +
-                `${encodeURIComponent(M_BEACON_INFO.name)}/${encodeURIComponent(userId)}`,
+                    `${encodeURIComponent(M_BEACON_INFO.name)}/${encodeURIComponent(userId)}`,
             );
             expect(requestContent).toEqual(content);
         });
 
-        describe('processBeaconEvents()', () => {
-            it('does nothing when events is falsy', () => {
+        describe("processBeaconEvents()", () => {
+            it("does nothing when events is falsy", () => {
                 const room = new Room(roomId, client, userId);
-                const roomStateProcessSpy = jest.spyOn(room.currentState, 'processBeaconEvents');
+                const roomStateProcessSpy = jest.spyOn(room.currentState, "processBeaconEvents");
 
                 client.processBeaconEvents(room, undefined);
                 expect(roomStateProcessSpy).not.toHaveBeenCalled();
             });
 
-            it('does nothing when events is of length 0', () => {
+            it("does nothing when events is of length 0", () => {
                 const room = new Room(roomId, client, userId);
-                const roomStateProcessSpy = jest.spyOn(room.currentState, 'processBeaconEvents');
+                const roomStateProcessSpy = jest.spyOn(room.currentState, "processBeaconEvents");
 
                 client.processBeaconEvents(room, []);
                 expect(roomStateProcessSpy).not.toHaveBeenCalled();
             });
 
-            it('calls room states processBeaconEvents with events', () => {
+            it("calls room states processBeaconEvents with events", () => {
                 const room = new Room(roomId, client, userId);
-                const roomStateProcessSpy = jest.spyOn(room.currentState, 'processBeaconEvents');
+                const roomStateProcessSpy = jest.spyOn(room.currentState, "processBeaconEvents");
 
                 const messageEvent = testUtils.mkMessage({ room: roomId, user: userId, event: true });
                 const beaconEvent = makeBeaconEvent(userId);
@@ -1242,14 +1289,13 @@ describe("MatrixClient", function() {
     describe("setRoomTopic", () => {
         const roomId = "!foofoofoofoofoofoo:matrix.org";
         const createSendStateEventMock = (topic: string, htmlTopic?: string) => {
-            return jest.fn()
-                .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
-                    expect(roomId).toEqual(roomId);
-                    expect(eventType).toEqual(EventType.RoomTopic);
-                    expect(content).toMatchObject(ContentHelpers.makeTopicContent(topic, htmlTopic));
-                    expect(stateKey).toBeUndefined();
-                    return Promise.resolve();
-                });
+            return jest.fn().mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
+                expect(roomId).toEqual(roomId);
+                expect(eventType).toEqual(EventType.RoomTopic);
+                expect(content).toMatchObject(ContentHelpers.makeTopicContent(topic, htmlTopic));
+                expect(stateKey).toBeUndefined();
+                return Promise.resolve();
+            });
         };
 
         it("is called with plain text topic and sends state event", async () => {
@@ -1275,13 +1321,13 @@ describe("MatrixClient", function() {
     });
 
     describe("setPassword", () => {
-        const auth = { session: 'abcdef', type: 'foo' };
-        const newPassword = 'newpassword';
+        const auth = { session: "abcdef", type: "foo" };
+        const newPassword = "newpassword";
 
         const passwordTest = (expectedRequestContent: any) => {
             const [method, path, queryParams, requestContent] = mocked(client.http.authedRequest).mock.calls[0];
-            expect(method).toBe('POST');
-            expect(path).toEqual('/account/password');
+            expect(method).toBe("POST");
+            expect(path).toEqual("/account/password");
             expect(queryParams).toBeFalsy();
             expect(requestContent).toEqual(expectedRequestContent);
         };
@@ -1334,7 +1380,7 @@ describe("MatrixClient", function() {
             // Current version of the endpoint we support is v3
             const [method, path, queryParams, data, opts] = mocked(client.http.authedRequest).mock.calls[0];
             expect(data).toBeFalsy();
-            expect(method).toBe('GET');
+            expect(method).toBe("GET");
             expect(path).toEqual(`/rooms/${encodeURIComponent(roomId)}/aliases`);
             expect(opts).toMatchObject({ prefix: "/_matrix/client/v3" });
             expect(queryParams).toBeFalsy();
@@ -1397,11 +1443,17 @@ describe("MatrixClient", function() {
             client.on(ClientEvent.TurnServers, onTurnServers);
             expect(await client.checkTurnServers()).toBe(true);
             client.off(ClientEvent.TurnServers, onTurnServers);
-            expect(events).toEqual([[[{
-                urls: turnServer.uris,
-                username: turnServer.username,
-                credential: turnServer.password,
-            }]]]);
+            expect(events).toEqual([
+                [
+                    [
+                        {
+                            urls: turnServer.uris,
+                            username: turnServer.username,
+                            credential: turnServer.password,
+                        },
+                    ],
+                ],
+            ]);
         });
 
         it("emits an event when an error occurs", async () => {
@@ -1448,11 +1500,11 @@ describe("MatrixClient", function() {
         beforeEach(() => {
             // Mockup `getAccountData`/`setAccountData`.
             const dataStore = new Map();
-            client.setAccountData = function(eventType, content) {
+            client.setAccountData = function (eventType, content) {
                 dataStore.set(eventType, content);
                 return Promise.resolve({});
             };
-            client.getAccountData = function(eventType) {
+            client.getAccountData = function (eventType) {
                 const data = dataStore.get(eventType);
                 return new MatrixEvent({
                     content: data,
@@ -1461,23 +1513,23 @@ describe("MatrixClient", function() {
 
             // Mockup `createRoom`/`getRoom`/`joinRoom`, including state.
             const rooms = new Map();
-            client.createRoom = function(options: Options = {}) {
+            client.createRoom = function (options: Options = {}) {
                 const roomId = options["_roomId"] || `!room-${rooms.size}:example.org`;
                 const state = new Map<string, any>();
                 const room = {
                     roomId,
                     _options: options,
                     _state: state,
-                    getUnfilteredTimelineSet: function() {
+                    getUnfilteredTimelineSet: function () {
                         return {
-                            getLiveTimeline: function() {
+                            getLiveTimeline: function () {
                                 return {
-                                    getState: function(direction) {
+                                    getState: function (direction) {
                                         expect(direction).toBe(EventTimeline.FORWARDS);
                                         return {
-                                            getStateEvents: function(type) {
+                                            getStateEvents: function (type) {
                                                 const store = state.get(type) || {};
-                                                return Object.keys(store).map(key => store[key]);
+                                                return Object.keys(store).map((key) => store[key]);
                                             },
                                         };
                                     },
@@ -1489,15 +1541,15 @@ describe("MatrixClient", function() {
                 rooms.set(roomId, room);
                 return Promise.resolve({ room_id: roomId });
             };
-            client.getRoom = function(roomId) {
+            client.getRoom = function (roomId) {
                 return rooms.get(roomId);
             };
-            client.joinRoom = async function(roomId) {
+            client.joinRoom = async function (roomId) {
                 return this.getRoom(roomId)! || this.createRoom({ _roomId: roomId } as ICreateRoomOpts);
             };
 
             // Mockup state events
-            client.sendStateEvent = function(roomId, type, content) {
+            client.sendStateEvent = function (roomId, type, content) {
                 const room = this.getRoom(roomId) as WrappedRoom;
                 const state: Map<string, any> = room._state;
                 let store = state.get(type);
@@ -1507,19 +1559,19 @@ describe("MatrixClient", function() {
                 }
                 const eventId = `$event-${Math.random()}:example.org`;
                 store[eventId] = {
-                    getId: function() {
+                    getId: function () {
                         return eventId;
                     },
-                    getRoomId: function() {
+                    getRoomId: function () {
                         return roomId;
                     },
-                    getContent: function() {
+                    getContent: function () {
                         return content;
                     },
                 };
                 return Promise.resolve({ event_id: eventId });
             };
-            client.redactEvent = function(roomId, eventId) {
+            client.redactEvent = function (roomId, eventId) {
                 const room = this.getRoom(roomId) as WrappedRoom;
                 const state: Map<string, any> = room._state;
                 for (const store of state.values()) {
diff --git a/spec/unit/models/MSC3089Branch.spec.ts b/spec/unit/models/MSC3089Branch.spec.ts
index 6f8fdbe4e56..33bc21ddcc8 100644
--- a/spec/unit/models/MSC3089Branch.spec.ts
+++ b/spec/unit/models/MSC3089Branch.spec.ts
@@ -50,23 +50,27 @@ describe("MSC3089Branch", () => {
                 }
             },
         };
-        indexEvent = ({
+        indexEvent = {
             getRoomId: () => branchRoomId,
             getStateKey: () => fileEventId,
-        });
+        };
         directory = new MSC3089TreeSpace(client, branchRoomId);
         branch = new MSC3089Branch(client, indexEvent, directory);
-        branch2 = new MSC3089Branch(client, {
-            getRoomId: () => branchRoomId,
-            getStateKey: () => fileEventId2,
-        } as MatrixEvent, directory);
+        branch2 = new MSC3089Branch(
+            client,
+            {
+                getRoomId: () => branchRoomId,
+                getStateKey: () => fileEventId2,
+            } as MatrixEvent,
+            directory,
+        );
     });
 
-    it('should know the file event ID', () => {
+    it("should know the file event ID", () => {
         expect(branch.id).toEqual(fileEventId);
     });
 
-    it('should know if the file is active or not', () => {
+    it("should know if the file is active or not", () => {
         indexEvent.getContent = () => ({});
         expect(branch.isActive).toBe(false);
         indexEvent.getContent = () => ({ active: false });
@@ -77,15 +81,16 @@ describe("MSC3089Branch", () => {
         expect(branch.isActive).toBe(false);
     });
 
-    it('should be able to delete the file', async () => {
+    it("should be able to delete the file", async () => {
         const eventIdOrder = [fileEventId, fileEventId2];
 
-        const stateFn = jest.fn()
+        const stateFn = jest
+            .fn()
             .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                 expect(roomId).toEqual(branchRoomId);
                 expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
                 expect(content).toMatchObject({});
-                expect(content['active']).toBeUndefined();
+                expect(content["active"]).toBeUndefined();
                 expect(stateKey).toEqual(eventIdOrder[stateFn.mock.calls.length - 1]);
 
                 return Promise.resolve(); // return value not used
@@ -109,7 +114,7 @@ describe("MSC3089Branch", () => {
         expect(redactFn).toHaveBeenCalledTimes(2);
     });
 
-    it('should know its name', async () => {
+    it("should know its name", async () => {
         const name = "My File.txt";
         indexEvent.getContent = () => ({ active: true, name: name });
 
@@ -118,10 +123,11 @@ describe("MSC3089Branch", () => {
         expect(res).toEqual(name);
     });
 
-    it('should be able to change its name', async () => {
+    it("should be able to change its name", async () => {
         const name = "My File.txt";
         indexEvent.getContent = () => ({ active: true, retained: true });
-        const stateFn = jest.fn()
+        const stateFn = jest
+            .fn()
             .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                 expect(roomId).toEqual(branchRoomId);
                 expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
@@ -141,7 +147,7 @@ describe("MSC3089Branch", () => {
         expect(stateFn).toHaveBeenCalledTimes(1);
     });
 
-    it('should be v1 by default', () => {
+    it("should be v1 by default", () => {
         indexEvent.getContent = () => ({ active: true });
 
         const res = branch.version;
@@ -149,7 +155,7 @@ describe("MSC3089Branch", () => {
         expect(res).toEqual(1);
     });
 
-    it('should be vN when set', () => {
+    it("should be vN when set", () => {
         indexEvent.getContent = () => ({ active: true, version: 3 });
 
         const res = branch.version;
@@ -157,7 +163,7 @@ describe("MSC3089Branch", () => {
         expect(res).toEqual(3);
     });
 
-    it('should be unlocked by default', async () => {
+    it("should be unlocked by default", async () => {
         indexEvent.getContent = () => ({ active: true });
 
         const res = branch.isLocked();
@@ -165,7 +171,7 @@ describe("MSC3089Branch", () => {
         expect(res).toEqual(false);
     });
 
-    it('should use lock status from index event', async () => {
+    it("should use lock status from index event", async () => {
         indexEvent.getContent = () => ({ active: true, locked: true });
 
         const res = branch.isLocked();
@@ -173,10 +179,11 @@ describe("MSC3089Branch", () => {
         expect(res).toEqual(true);
     });
 
-    it('should be able to change its locked status', async () => {
+    it("should be able to change its locked status", async () => {
         const locked = true;
         indexEvent.getContent = () => ({ active: true, retained: true });
-        const stateFn = jest.fn()
+        const stateFn = jest
+            .fn()
             .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                 expect(roomId).toEqual(branchRoomId);
                 expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
@@ -196,16 +203,17 @@ describe("MSC3089Branch", () => {
         expect(stateFn).toHaveBeenCalledTimes(1);
     });
 
-    it('should be able to return event information', async () => {
+    it("should be able to return event information", async () => {
         const mxcLatter = "example.org/file";
         const fileContent = { isFile: "not quite", url: "mxc://" + mxcLatter };
         const fileEvent = { getId: () => fileEventId, getOriginalContent: () => ({ file: fileContent }) };
-        staticRoom.getUnfilteredTimelineSet = () => ({
-            findEventById: (eventId) => {
-                expect(eventId).toEqual(fileEventId);
-                return fileEvent;
-            },
-        }) as EventTimelineSet;
+        staticRoom.getUnfilteredTimelineSet = () =>
+            ({
+                findEventById: (eventId) => {
+                    expect(eventId).toEqual(fileEventId);
+                    return fileEvent;
+                },
+            } as EventTimelineSet);
         client.mxcUrlToHttp = (mxc: string) => {
             expect(mxc).toEqual("mxc://" + mxcLatter);
             return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
@@ -217,20 +225,21 @@ describe("MSC3089Branch", () => {
         expect(res).toMatchObject({
             info: fileContent,
             // Escape regex from MDN guides: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
-            httpUrl: expect.stringMatching(`.+${mxcLatter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`),
+            httpUrl: expect.stringMatching(`.+${mxcLatter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`),
         });
     });
 
-    it('should be able to return the event object', async () => {
+    it("should be able to return the event object", async () => {
         const mxcLatter = "example.org/file";
         const fileContent = { isFile: "not quite", url: "mxc://" + mxcLatter };
         const fileEvent = { getId: () => fileEventId, getOriginalContent: () => ({ file: fileContent }) };
-        staticRoom.getUnfilteredTimelineSet = () => ({
-            findEventById: (eventId) => {
-                expect(eventId).toEqual(fileEventId);
-                return fileEvent;
-            },
-        }) as EventTimelineSet;
+        staticRoom.getUnfilteredTimelineSet = () =>
+            ({
+                findEventById: (eventId) => {
+                    expect(eventId).toEqual(fileEventId);
+                    return fileEvent;
+                },
+            } as EventTimelineSet);
         client.mxcUrlToHttp = (mxc: string) => {
             expect(mxc).toEqual("mxc://" + mxcLatter);
             return `https://example.org/_matrix/media/v1/download/${mxcLatter}`;
@@ -242,14 +251,15 @@ describe("MSC3089Branch", () => {
         expect(res).toBe(fileEvent);
     });
 
-    it('should create new versions of itself', async () => {
+    it("should create new versions of itself", async () => {
         const canaryName = "canary";
         const canaryContents = "contents go here";
         const canaryFile = {} as IEncryptedFile;
         const canaryAddl = { canary: true };
         indexEvent.getContent = () => ({ active: true, retained: true });
         const stateKeyOrder = [fileEventId2, fileEventId];
-        const stateFn = jest.fn()
+        const stateFn = jest
+            .fn()
             .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                 expect(roomId).toEqual(branchRoomId);
                 expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test that we're definitely using the unstable value
@@ -273,26 +283,25 @@ describe("MSC3089Branch", () => {
             });
         client.sendStateEvent = stateFn;
 
-        const createFn = jest.fn().mockImplementation((
-            name: string,
-            contents: ArrayBuffer,
-            info: Partial<IEncryptedFile>,
-            addl: IContent,
-        ) => {
-            expect(name).toEqual(canaryName);
-            expect(contents).toBe(canaryContents);
-            expect(info).toBe(canaryFile);
-            expect(addl).toMatchObject({
-                ...canaryAddl,
-                "m.new_content": true,
-                "m.relates_to": {
-                    "rel_type": RelationType.Replace,
-                    "event_id": fileEventId,
-                },
-            });
+        const createFn = jest
+            .fn()
+            .mockImplementation(
+                (name: string, contents: ArrayBuffer, info: Partial<IEncryptedFile>, addl: IContent) => {
+                    expect(name).toEqual(canaryName);
+                    expect(contents).toBe(canaryContents);
+                    expect(info).toBe(canaryFile);
+                    expect(addl).toMatchObject({
+                        ...canaryAddl,
+                        "m.new_content": true,
+                        "m.relates_to": {
+                            rel_type: RelationType.Replace,
+                            event_id: fileEventId,
+                        },
+                    });
 
-            return Promise.resolve({ event_id: fileEventId2 });
-        });
+                    return Promise.resolve({ event_id: fileEventId2 });
+                },
+            );
         directory.createFile = createFn;
 
         await branch.createNewVersion(canaryName, canaryContents, canaryFile, canaryAddl);
@@ -301,21 +310,27 @@ describe("MSC3089Branch", () => {
         expect(createFn).toHaveBeenCalledTimes(1);
     });
 
-    it('should fetch file history', async () => {
-        branch2.getFileEvent = () => Promise.resolve({
-            replacingEventId: () => undefined,
-            getId: () => fileEventId2,
-        } as MatrixEvent);
-        branch.getFileEvent = () => Promise.resolve({
-            replacingEventId: () => fileEventId2,
-            getId: () => fileEventId,
-        } as MatrixEvent);
-
-        const events = [await branch.getFileEvent(), await branch2.getFileEvent(), {
-            replacingEventId: (): string | undefined => undefined,
-            getId: () => "$unknown",
-        }];
-        staticRoom.getLiveTimeline = () => ({ getEvents: () => events }) as EventTimeline;
+    it("should fetch file history", async () => {
+        branch2.getFileEvent = () =>
+            Promise.resolve({
+                replacingEventId: () => undefined,
+                getId: () => fileEventId2,
+            } as MatrixEvent);
+        branch.getFileEvent = () =>
+            Promise.resolve({
+                replacingEventId: () => fileEventId2,
+                getId: () => fileEventId,
+            } as MatrixEvent);
+
+        const events = [
+            await branch.getFileEvent(),
+            await branch2.getFileEvent(),
+            {
+                replacingEventId: (): string | undefined => undefined,
+                getId: () => "$unknown",
+            },
+        ];
+        staticRoom.getLiveTimeline = () => ({ getEvents: () => events } as EventTimeline);
 
         directory.getFile = (evId: string) => {
             expect(evId).toEqual(fileEventId);
@@ -323,9 +338,6 @@ describe("MSC3089Branch", () => {
         };
 
         const results = await branch2.getVersionHistory();
-        expect(results).toMatchObject([
-            branch2,
-            branch,
-        ]);
+        expect(results).toMatchObject([branch2, branch]);
     });
 });
diff --git a/spec/unit/models/MSC3089TreeSpace.spec.ts b/spec/unit/models/MSC3089TreeSpace.spec.ts
index ab39b907535..9cb82f7870a 100644
--- a/spec/unit/models/MSC3089TreeSpace.spec.ts
+++ b/spec/unit/models/MSC3089TreeSpace.spec.ts
@@ -72,18 +72,19 @@ describe("MSC3089TreeSpace", () => {
         });
     }
 
-    it('should populate the room reference', () => {
+    it("should populate the room reference", () => {
         expect(tree.room).toBe(room);
     });
 
-    it('should proxy the ID member to room ID', () => {
+    it("should proxy the ID member to room ID", () => {
         expect(tree.id).toEqual(tree.roomId);
         expect(tree.id).toEqual(roomId);
     });
 
-    it('should support setting the name of the space', async () => {
+    it("should support setting the name of the space", async () => {
         const newName = "NEW NAME";
-        const fn = jest.fn()
+        const fn = jest
+            .fn()
             .mockImplementation((stateRoomId: string, eventType: EventType, content: any, stateKey: string) => {
                 expect(stateRoomId).toEqual(roomId);
                 expect(eventType).toEqual(EventType.RoomName);
@@ -96,7 +97,7 @@ describe("MSC3089TreeSpace", () => {
         expect(fn).toHaveBeenCalledTimes(1);
     });
 
-    it('should support inviting users to the space', async () => {
+    it("should support inviting users to the space", async () => {
         const target = targetUser;
         const fn = jest.fn().mockImplementation((inviteRoomId: string, userId: string) => {
             expect(inviteRoomId).toEqual(roomId);
@@ -108,7 +109,7 @@ describe("MSC3089TreeSpace", () => {
         expect(fn).toHaveBeenCalledTimes(1);
     });
 
-    it('should retry invites to the space', async () => {
+    it("should retry invites to the space", async () => {
         const target = targetUser;
         const fn = jest.fn().mockImplementation((inviteRoomId: string, userId: string) => {
             expect(inviteRoomId).toEqual(roomId);
@@ -121,7 +122,7 @@ describe("MSC3089TreeSpace", () => {
         expect(fn).toHaveBeenCalledTimes(2);
     });
 
-    it('should not retry invite permission errors', async () => {
+    it("should not retry invite permission errors", async () => {
         const target = targetUser;
         const fn = jest.fn().mockImplementation((inviteRoomId: string, userId: string) => {
             expect(inviteRoomId).toEqual(roomId);
@@ -141,7 +142,7 @@ describe("MSC3089TreeSpace", () => {
         expect(fn).toHaveBeenCalledTimes(1);
     });
 
-    it('should invite to subspaces', async () => {
+    it("should invite to subspaces", async () => {
         const target = targetUser;
         const fn = jest.fn().mockImplementation((inviteRoomId: string, userId: string) => {
             expect(inviteRoomId).toEqual(roomId);
@@ -162,7 +163,7 @@ describe("MSC3089TreeSpace", () => {
         expect(fn).toHaveBeenCalledTimes(4);
     });
 
-    it('should share keys with invitees', async () => {
+    it("should share keys with invitees", async () => {
         const target = targetUser;
         const sendKeysFn = jest.fn().mockImplementation((inviteRoomId: string, userIds: string[]) => {
             expect(inviteRoomId).toEqual(roomId);
@@ -190,7 +191,7 @@ describe("MSC3089TreeSpace", () => {
         expect(historyFn).toHaveBeenCalledTimes(1);
     });
 
-    it('should not share keys with invitees if inappropriate history visibility', async () => {
+    it("should not share keys with invitees if inappropriate history visibility", async () => {
         const target = targetUser;
         const sendKeysFn = jest.fn().mockImplementation((inviteRoomId: string, userIds: string[]) => {
             expect(inviteRoomId).toEqual(roomId);
@@ -215,7 +216,8 @@ describe("MSC3089TreeSpace", () => {
 
     async function evaluatePowerLevels(pls: any, role: TreePermissions, expectedPl: number) {
         makePowerLevels(pls);
-        const fn = jest.fn()
+        const fn = jest
+            .fn()
             .mockImplementation((stateRoomId: string, eventType: EventType, content: any, stateKey: string) => {
                 expect(stateRoomId).toEqual(roomId);
                 expect(eventType).toEqual(EventType.RoomPowerLevels);
@@ -240,80 +242,100 @@ describe("MSC3089TreeSpace", () => {
         expect(finalPermissions).toEqual(role);
     }
 
-    it('should support setting Viewer permissions', () => {
-        return evaluatePowerLevels({
-            ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
-            users_default: 1024,
-            events_default: 1025,
-            events: {
-                [EventType.RoomPowerLevels]: 1026,
+    it("should support setting Viewer permissions", () => {
+        return evaluatePowerLevels(
+            {
+                ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
+                users_default: 1024,
+                events_default: 1025,
+                events: {
+                    [EventType.RoomPowerLevels]: 1026,
+                },
             },
-        }, TreePermissions.Viewer, 1024);
+            TreePermissions.Viewer,
+            1024,
+        );
     });
 
-    it('should support setting Editor permissions', () => {
-        return evaluatePowerLevels({
-            ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
-            users_default: 1024,
-            events_default: 1025,
-            events: {
-                [EventType.RoomPowerLevels]: 1026,
+    it("should support setting Editor permissions", () => {
+        return evaluatePowerLevels(
+            {
+                ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
+                users_default: 1024,
+                events_default: 1025,
+                events: {
+                    [EventType.RoomPowerLevels]: 1026,
+                },
             },
-        }, TreePermissions.Editor, 1025);
+            TreePermissions.Editor,
+            1025,
+        );
     });
 
-    it('should support setting Owner permissions', () => {
-        return evaluatePowerLevels({
-            ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
-            users_default: 1024,
-            events_default: 1025,
-            events: {
-                [EventType.RoomPowerLevels]: 1026,
+    it("should support setting Owner permissions", () => {
+        return evaluatePowerLevels(
+            {
+                ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
+                users_default: 1024,
+                events_default: 1025,
+                events: {
+                    [EventType.RoomPowerLevels]: 1026,
+                },
             },
-        }, TreePermissions.Owner, 1026);
+            TreePermissions.Owner,
+            1026,
+        );
     });
 
-    it('should support demoting permissions', () => {
-        return evaluatePowerLevels({
-            ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
-            users_default: 1024,
-            events_default: 1025,
-            events: {
-                [EventType.RoomPowerLevels]: 1026,
-            },
-            users: {
-                [targetUser]: 2222,
+    it("should support demoting permissions", () => {
+        return evaluatePowerLevels(
+            {
+                ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
+                users_default: 1024,
+                events_default: 1025,
+                events: {
+                    [EventType.RoomPowerLevels]: 1026,
+                },
+                users: {
+                    [targetUser]: 2222,
+                },
             },
-        }, TreePermissions.Viewer, 1024);
+            TreePermissions.Viewer,
+            1024,
+        );
     });
 
-    it('should support promoting permissions', () => {
-        return evaluatePowerLevels({
-            ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
-            users_default: 1024,
-            events_default: 1025,
-            events: {
-                [EventType.RoomPowerLevels]: 1026,
-            },
-            users: {
-                [targetUser]: 5,
+    it("should support promoting permissions", () => {
+        return evaluatePowerLevels(
+            {
+                ...DEFAULT_TREE_POWER_LEVELS_TEMPLATE,
+                users_default: 1024,
+                events_default: 1025,
+                events: {
+                    [EventType.RoomPowerLevels]: 1026,
+                },
+                users: {
+                    [targetUser]: 5,
+                },
             },
-        }, TreePermissions.Editor, 1025);
+            TreePermissions.Editor,
+            1025,
+        );
     });
 
-    it('should support defaults: Viewer', () => {
+    it("should support defaults: Viewer", () => {
         return evaluatePowerLevels({}, TreePermissions.Viewer, 0);
     });
 
-    it('should support defaults: Editor', () => {
+    it("should support defaults: Editor", () => {
         return evaluatePowerLevels({}, TreePermissions.Editor, 50);
     });
 
-    it('should support defaults: Owner', () => {
+    it("should support defaults: Owner", () => {
         return evaluatePowerLevels({}, TreePermissions.Owner, 100);
     });
 
-    it('should create subdirectories', async () => {
+    it("should create subdirectories", async () => {
         const subspaceName = "subdirectory";
         const subspaceId = "!subspace:localhost";
         const domain = "domain.example.com";
@@ -331,7 +353,8 @@ describe("MSC3089TreeSpace", () => {
             expect(name).toEqual(subspaceName);
             return new MSC3089TreeSpace(client, subspaceId);
         });
-        const sendStateFn = jest.fn()
+        const sendStateFn = jest
+            .fn()
             .mockImplementation(async (roomId: string, eventType: EventType, content: any, stateKey: string) => {
                 expect([tree.roomId, subspaceId]).toContain(roomId);
                 if (roomId === subspaceId) {
@@ -361,7 +384,7 @@ describe("MSC3089TreeSpace", () => {
         expect(sendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, content, subspaceId);
     });
 
-    it('should find subdirectories', () => {
+    it("should find subdirectories", () => {
         const firstChildRoom = "!one:example.org";
         const secondChildRoom = "!two:example.org";
         const thirdChildRoom = "!three:example.org"; // to ensure it doesn't end up in the subdirectories
@@ -399,7 +422,7 @@ describe("MSC3089TreeSpace", () => {
         expect(getFn).toHaveBeenCalledWith(thirdChildRoom); // check to make sure it tried
     });
 
-    it('should find specific directories', () => {
+    it("should find specific directories", () => {
         client.getRoom = () => ({} as Room); // to appease the TreeSpace constructor
 
         // Only mocking used API
@@ -415,7 +438,7 @@ describe("MSC3089TreeSpace", () => {
         expect(result).toBeFalsy();
     });
 
-    it('should be able to delete itself', async () => {
+    it("should be able to delete itself", async () => {
         const delete1 = jest.fn().mockImplementation(() => Promise.resolve());
         const subdir1 = { delete: delete1 } as any as MSC3089TreeSpace; // mock tested bits
 
@@ -466,7 +489,7 @@ describe("MSC3089TreeSpace", () => {
         expect(leaveFn).toHaveBeenCalledTimes(1);
     });
 
-    describe('get and set order', () => {
+    describe("get and set order", () => {
         // Danger: these are partial implementations for testing purposes only
 
         // @ts-ignore - "MatrixEvent is a value but used as a type", which is true but not important
@@ -483,7 +506,7 @@ describe("MSC3089TreeSpace", () => {
             const content: IContent = {
                 via: [staticDomain],
             };
-            if (order) content['order'] = order;
+            if (order) content["order"] = order;
             parentState.push({
                 getType: () => EventType.SpaceChild,
                 getStateKey: () => roomId,
@@ -511,7 +534,7 @@ describe("MSC3089TreeSpace", () => {
         }
 
         function expectOrder(childRoomId: string, order: number) {
-            const child = childTrees.find(c => c.roomId === childRoomId);
+            const child = childTrees.find((c) => c.roomId === childRoomId);
             expect(child).toBeDefined();
             expect(child!.getOrder()).toEqual(order);
         }
@@ -523,10 +546,10 @@ describe("MSC3089TreeSpace", () => {
                         expect([EventType.SpaceParent, EventType.RoomCreate]).toContain(eventType);
                         if (eventType === EventType.RoomCreate) {
                             expect(stateKey).toEqual("");
-                            return childState[roomId].find(e => e.getType() === EventType.RoomCreate);
+                            return childState[roomId].find((e) => e.getType() === EventType.RoomCreate);
                         } else {
                             expect(stateKey).toBeUndefined();
-                            return childState[roomId].filter(e => e.getType() === eventType);
+                            return childState[roomId].filter((e) => e.getType() === eventType);
                         }
                     },
                 },
@@ -541,22 +564,22 @@ describe("MSC3089TreeSpace", () => {
                 roomId: tree.roomId,
                 currentState: {
                     getStateEvents: (eventType: EventType, stateKey?: string) => {
-                        expect([
-                            EventType.SpaceChild,
-                            EventType.RoomCreate,
-                            EventType.SpaceParent,
-                        ]).toContain(eventType);
+                        expect([EventType.SpaceChild, EventType.RoomCreate, EventType.SpaceParent]).toContain(
+                            eventType,
+                        );
 
                         if (eventType === EventType.RoomCreate) {
                             expect(stateKey).toEqual("");
-                            return parentState.filter(e => e.getType() === EventType.RoomCreate)[0];
+                            return parentState.filter((e) => e.getType() === EventType.RoomCreate)[0];
                         } else {
                             if (stateKey !== undefined) {
                                 expect(Object.keys(rooms)).toContain(stateKey);
                                 expect(stateKey).not.toEqual(tree.roomId);
-                                return parentState.find(e => e.getType() === eventType && e.getStateKey() === stateKey);
+                                return parentState.find(
+                                    (e) => e.getType() === eventType && e.getStateKey() === stateKey,
+                                );
                             } // else fine
-                            return parentState.filter(e => e.getType() === eventType);
+                            return parentState.filter((e) => e.getType() === eventType);
                         }
                     },
                 },
@@ -567,18 +590,23 @@ describe("MSC3089TreeSpace", () => {
             (<any>tree).room = parentRoom; // override readonly
             client.getRoom = (r) => rooms[r ?? ""];
 
-            clientSendStateFn = jest.fn()
+            clientSendStateFn = jest
+                .fn()
                 .mockImplementation((roomId: string, eventType: EventType, content: any, stateKey: string) => {
                     expect(roomId).toEqual(tree.roomId);
                     expect(eventType).toEqual(EventType.SpaceChild);
-                    expect(content).toMatchObject(expect.objectContaining({
-                        via: expect.any(Array),
-                        order: expect.any(String),
-                    }));
+                    expect(content).toMatchObject(
+                        expect.objectContaining({
+                            via: expect.any(Array),
+                            order: expect.any(String),
+                        }),
+                    );
                     expect(Object.keys(rooms)).toContain(stateKey);
                     expect(stateKey).not.toEqual(tree.roomId);
 
-                    const stateEvent = parentState.find(e => e.getType() === eventType && e.getStateKey() === stateKey);
+                    const stateEvent = parentState.find(
+                        (e) => e.getType() === eventType && e.getStateKey() === stateKey,
+                    );
                     expect(stateEvent).toBeDefined();
                     stateEvent.getContent = () => content;
 
@@ -587,7 +615,7 @@ describe("MSC3089TreeSpace", () => {
             client.sendStateEvent = clientSendStateFn;
         });
 
-        it('should know when something is top level', () => {
+        it("should know when something is top level", () => {
             const a = "!a:example.org";
             addSubspace(a);
 
@@ -595,12 +623,12 @@ describe("MSC3089TreeSpace", () => {
             expect(childTrees[0].isTopLevel).toBe(false); // a bit of a hack to get at this, but it's fine
         });
 
-        it('should return -1 for top level spaces', () => {
+        it("should return -1 for top level spaces", () => {
             // The tree is what we've defined as top level, so it should work
             expect(tree.getOrder()).toEqual(-1);
         });
 
-        it('should throw when setting an order at the top level space', async () => {
+        it("should throw when setting an order at the top level space", async () => {
             try {
                 // The tree is what we've defined as top level, so it should work
                 await tree.setOrder(2);
@@ -612,7 +640,7 @@ describe("MSC3089TreeSpace", () => {
             }
         });
 
-        it('should return a stable order for unordered children', () => {
+        it("should return a stable order for unordered children", () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -627,7 +655,7 @@ describe("MSC3089TreeSpace", () => {
             expectOrder(c, 2);
         });
 
-        it('should return a stable order for ordered children', () => {
+        it("should return a stable order for ordered children", () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -642,7 +670,7 @@ describe("MSC3089TreeSpace", () => {
             expectOrder(a, 2);
         });
 
-        it('should return a stable order for partially ordered children', () => {
+        it("should return a stable order for partially ordered children", () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -660,7 +688,7 @@ describe("MSC3089TreeSpace", () => {
             expectOrder(a, 2);
         });
 
-        it('should return a stable order if the create event timestamps are the same', () => {
+        it("should return a stable order if the create event timestamps are the same", () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -675,7 +703,7 @@ describe("MSC3089TreeSpace", () => {
             expectOrder(c, 2);
         });
 
-        it('should return a stable order if there are no known create events', () => {
+        it("should return a stable order if there are no known create events", () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -692,7 +720,7 @@ describe("MSC3089TreeSpace", () => {
 
         // XXX: These tests rely on `getOrder()` re-calculating and not caching values.
 
-        it('should allow reordering within unordered children', async () => {
+        it("should allow reordering within unordered children", async () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -704,32 +732,47 @@ describe("MSC3089TreeSpace", () => {
 
             // Order of this state is validated by other tests.
 
-            const treeA = childTrees.find(c => c.roomId === a);
+            const treeA = childTrees.find((c) => c.roomId === a);
             expect(treeA).toBeDefined();
             await treeA!.setOrder(1);
 
             expect(clientSendStateFn).toHaveBeenCalledTimes(3);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-
-                // Because of how the reordering works (maintain stable ordering before moving), we end up calling this
-                // function twice for the same room.
-                order: DEFAULT_ALPHABET[0],
-            }), a);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: DEFAULT_ALPHABET[1],
-            }), b);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: DEFAULT_ALPHABET[2],
-            }), a);
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+
+                    // Because of how the reordering works (maintain stable ordering before moving), we end up calling this
+                    // function twice for the same room.
+                    order: DEFAULT_ALPHABET[0],
+                }),
+                a,
+            );
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: DEFAULT_ALPHABET[1],
+                }),
+                b,
+            );
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: DEFAULT_ALPHABET[2],
+                }),
+                a,
+            );
             expectOrder(a, 1);
             expectOrder(b, 0);
             expectOrder(c, 2);
         });
 
-        it('should allow reordering within ordered children', async () => {
+        it("should allow reordering within ordered children", async () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -741,21 +784,26 @@ describe("MSC3089TreeSpace", () => {
 
             // Order of this state is validated by other tests.
 
-            const treeA = childTrees.find(c => c.roomId === a);
+            const treeA = childTrees.find((c) => c.roomId === a);
             expect(treeA).toBeDefined();
             await treeA!.setOrder(1);
 
             expect(clientSendStateFn).toHaveBeenCalledTimes(1);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: 'Y',
-            }), a);
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: "Y",
+                }),
+                a,
+            );
             expectOrder(a, 1);
             expectOrder(b, 0);
             expectOrder(c, 2);
         });
 
-        it('should allow reordering within partially ordered children', async () => {
+        it("should allow reordering within partially ordered children", async () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -769,22 +817,27 @@ describe("MSC3089TreeSpace", () => {
 
             // Order of this state is validated by other tests.
 
-            const treeA = childTrees.find(c => c.roomId === a);
+            const treeA = childTrees.find((c) => c.roomId === a);
             expect(treeA).toBeDefined();
             await treeA!.setOrder(2);
 
             expect(clientSendStateFn).toHaveBeenCalledTimes(1);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: 'Z',
-            }), a);
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: "Z",
+                }),
+                a,
+            );
             expectOrder(a, 2);
             expectOrder(b, 3);
             expectOrder(c, 1);
             expectOrder(d, 0);
         });
 
-        it('should support moving upwards', async () => {
+        it("should support moving upwards", async () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -798,22 +851,27 @@ describe("MSC3089TreeSpace", () => {
 
             // Order of this state is validated by other tests.
 
-            const treeB = childTrees.find(c => c.roomId === b);
+            const treeB = childTrees.find((c) => c.roomId === b);
             expect(treeB).toBeDefined();
             await treeB!.setOrder(2);
 
             expect(clientSendStateFn).toHaveBeenCalledTimes(1);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: 'Y',
-            }), b);
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: "Y",
+                }),
+                b,
+            );
             expectOrder(a, 0);
             expectOrder(b, 2);
             expectOrder(c, 1);
             expectOrder(d, 3);
         });
 
-        it('should support moving downwards', async () => {
+        it("should support moving downwards", async () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -827,22 +885,27 @@ describe("MSC3089TreeSpace", () => {
 
             // Order of this state is validated by other tests.
 
-            const treeC = childTrees.find(ch => ch.roomId === c);
+            const treeC = childTrees.find((ch) => ch.roomId === c);
             expect(treeC).toBeDefined();
             await treeC!.setOrder(1);
 
             expect(clientSendStateFn).toHaveBeenCalledTimes(1);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: 'U',
-            }), c);
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: "U",
+                }),
+                c,
+            );
             expectOrder(a, 0);
             expectOrder(b, 2);
             expectOrder(c, 1);
             expectOrder(d, 3);
         });
 
-        it('should support moving over the partial ordering boundary', async () => {
+        it("should support moving over the partial ordering boundary", async () => {
             const a = "!a:example.org";
             const b = "!b:example.org";
             const c = "!c:example.org";
@@ -856,19 +919,29 @@ describe("MSC3089TreeSpace", () => {
 
             // Order of this state is validated by other tests.
 
-            const treeB = childTrees.find(ch => ch.roomId === b);
+            const treeB = childTrees.find((ch) => ch.roomId === b);
             expect(treeB).toBeDefined();
             await treeB!.setOrder(2);
 
             expect(clientSendStateFn).toHaveBeenCalledTimes(2);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: 'W',
-            }), c);
-            expect(clientSendStateFn).toHaveBeenCalledWith(tree.roomId, EventType.SpaceChild, expect.objectContaining({
-                via: [staticDomain], // should retain domain independent of client.getDomain()
-                order: 'X',
-            }), b);
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: "W",
+                }),
+                c,
+            );
+            expect(clientSendStateFn).toHaveBeenCalledWith(
+                tree.roomId,
+                EventType.SpaceChild,
+                expect.objectContaining({
+                    via: [staticDomain], // should retain domain independent of client.getDomain()
+                    order: "X",
+                }),
+                b,
+            );
             expectOrder(a, 0);
             expectOrder(b, 2);
             expectOrder(c, 1);
@@ -876,7 +949,7 @@ describe("MSC3089TreeSpace", () => {
         });
     });
 
-    it('should upload files', async () => {
+    it("should upload files", async () => {
         const mxc = "mxc://example.org/file";
         const fileInfo = {
             mimetype: "text/plain",
@@ -910,7 +983,8 @@ describe("MSC3089TreeSpace", () => {
         });
         client.sendMessage = sendMsgFn;
 
-        const sendStateFn = jest.fn()
+        const sendStateFn = jest
+            .fn()
             .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                 expect(roomId).toEqual(tree.roomId);
                 expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test to ensure we're definitely using unstable
@@ -935,7 +1009,7 @@ describe("MSC3089TreeSpace", () => {
         expect(sendStateFn).toHaveBeenCalledTimes(1);
     });
 
-    it('should upload file versions', async () => {
+    it("should upload file versions", async () => {
         const mxc = "mxc://example.org/file";
         const fileInfo = {
             mimetype: "text/plain",
@@ -972,7 +1046,8 @@ describe("MSC3089TreeSpace", () => {
         });
         client.sendMessage = sendMsgFn;
 
-        const sendStateFn = jest.fn()
+        const sendStateFn = jest
+            .fn()
             .mockImplementation((roomId: string, eventType: string, content: any, stateKey: string) => {
                 expect(roomId).toEqual(tree.roomId);
                 expect(eventType).toEqual(UNSTABLE_MSC3089_BRANCH.unstable); // test to ensure we're definitely using unstable
@@ -997,7 +1072,7 @@ describe("MSC3089TreeSpace", () => {
         expect(sendStateFn).toHaveBeenCalledTimes(1);
     });
 
-    it('should support getting files', () => {
+    it("should support getting files", () => {
         const fileEventId = "$file";
         const fileEvent = { forTest: true }; // MatrixEvent mock
         room.currentState = {
@@ -1013,7 +1088,7 @@ describe("MSC3089TreeSpace", () => {
         expect(file!.indexEvent).toBe(fileEvent);
     });
 
-    it('should return falsy for unknown files', () => {
+    it("should return falsy for unknown files", () => {
         const fileEventId = "$file";
         room.currentState = {
             getStateEvents: (eventType: string, stateKey?: string): MatrixEvent[] | MatrixEvent | null => {
@@ -1027,7 +1102,7 @@ describe("MSC3089TreeSpace", () => {
         expect(file).toBeFalsy();
     });
 
-    it('should list files', () => {
+    it("should list files", () => {
         const firstFile = { getContent: () => ({ active: true }) };
         const secondFile = { getContent: () => ({ active: false }) }; // deliberately inactive
         room.currentState = {
@@ -1044,7 +1119,7 @@ describe("MSC3089TreeSpace", () => {
         expect(files[0].indexEvent).toBe(firstFile);
     });
 
-    it('should list all files', () => {
+    it("should list all files", () => {
         const firstFile = { getContent: () => ({ active: true }) };
         const secondFile = { getContent: () => ({ active: false }) }; // deliberately inactive
         room.currentState = {
diff --git a/spec/unit/models/beacon.spec.ts b/spec/unit/models/beacon.spec.ts
index 2806ea26cb2..620e4a8fda1 100644
--- a/spec/unit/models/beacon.spec.ts
+++ b/spec/unit/models/beacon.spec.ts
@@ -18,50 +18,46 @@ import { REFERENCE_RELATION } from "matrix-events-sdk";
 
 import { MatrixEvent } from "../../../src";
 import { M_BEACON_INFO } from "../../../src/@types/beacon";
-import {
-    isTimestampInDuration,
-    Beacon,
-    BeaconEvent,
-} from "../../../src/models/beacon";
+import { isTimestampInDuration, Beacon, BeaconEvent } from "../../../src/models/beacon";
 import { makeBeaconEvent, makeBeaconInfoEvent } from "../../test-utils/beacon";
 
 jest.useFakeTimers();
 
-describe('Beacon', () => {
-    describe('isTimestampInDuration()', () => {
-        const startTs = new Date('2022-03-11T12:07:47.592Z').getTime();
+describe("Beacon", () => {
+    describe("isTimestampInDuration()", () => {
+        const startTs = new Date("2022-03-11T12:07:47.592Z").getTime();
         const HOUR_MS = 3600000;
-        it('returns false when timestamp is before start time', () => {
+        it("returns false when timestamp is before start time", () => {
             // day before
-            const timestamp = new Date('2022-03-10T12:07:47.592Z').getTime();
+            const timestamp = new Date("2022-03-10T12:07:47.592Z").getTime();
             expect(isTimestampInDuration(startTs, HOUR_MS, timestamp)).toBe(false);
         });
 
-        it('returns false when timestamp is after start time + duration', () => {
+        it("returns false when timestamp is after start time + duration", () => {
             // 1 second later
-            const timestamp = new Date('2022-03-10T12:07:48.592Z').getTime();
+            const timestamp = new Date("2022-03-10T12:07:48.592Z").getTime();
             expect(isTimestampInDuration(startTs, HOUR_MS, timestamp)).toBe(false);
         });
 
-        it('returns true when timestamp is exactly start time', () => {
+        it("returns true when timestamp is exactly start time", () => {
             expect(isTimestampInDuration(startTs, HOUR_MS, startTs)).toBe(true);
         });
 
-        it('returns true when timestamp is exactly the end of the duration', () => {
+        it("returns true when timestamp is exactly the end of the duration", () => {
             expect(isTimestampInDuration(startTs, HOUR_MS, startTs + HOUR_MS)).toBe(true);
         });
 
-        it('returns true when timestamp is within the duration', () => {
+        it("returns true when timestamp is within the duration", () => {
             const twoHourDuration = HOUR_MS * 2;
             const now = startTs + HOUR_MS;
             expect(isTimestampInDuration(startTs, twoHourDuration, now)).toBe(true);
         });
     });
 
-    describe('Beacon', () => {
-        const userId = '@user:server.org';
-        const userId2 = '@user2:server.org';
-        const roomId = '$room:server.org';
+    describe("Beacon", () => {
+        const userId = "@user:server.org";
+        const userId2 = "@user2:server.org";
+        const roomId = "$room:server.org";
         // 14.03.2022 16:15
         const now = 1647270879403;
         const HOUR_MS = 3600000;
@@ -75,7 +71,7 @@ describe('Beacon', () => {
 
         const advanceDateAndTime = (ms: number) => {
             // bc liveness check uses Date.now we have to advance this mock
-            jest.spyOn(global.Date, 'now').mockReturnValue(Date.now() + ms);
+            jest.spyOn(global.Date, "now").mockReturnValue(Date.now() + ms);
             // then advance time for the interval by the same amount
             jest.advanceTimersByTime(ms);
         };
@@ -89,7 +85,7 @@ describe('Beacon', () => {
                     isLive: true,
                     timestamp: now - HOUR_MS,
                 },
-                '$live123',
+                "$live123",
             );
             notLiveBeaconEvent = makeBeaconInfoEvent(
                 userId,
@@ -99,7 +95,7 @@ describe('Beacon', () => {
                     isLive: false,
                     timestamp: now - HOUR_MS,
                 },
-                '$dead123',
+                "$dead123",
             );
             user2BeaconEvent = makeBeaconInfoEvent(
                 userId2,
@@ -109,18 +105,18 @@ describe('Beacon', () => {
                     isLive: true,
                     timestamp: now - HOUR_MS,
                 },
-                '$user2live123',
+                "$user2live123",
             );
 
             // back to 'now'
-            jest.spyOn(global.Date, 'now').mockReturnValue(now);
+            jest.spyOn(global.Date, "now").mockReturnValue(now);
         });
 
         afterAll(() => {
-            jest.spyOn(global.Date, 'now').mockRestore();
+            jest.spyOn(global.Date, "now").mockRestore();
         });
 
-        it('creates beacon from event', () => {
+        it("creates beacon from event", () => {
             const beacon = new Beacon(liveBeaconEvent);
 
             expect(beacon.beaconInfoId).toEqual(liveBeaconEvent.getId());
@@ -132,7 +128,7 @@ describe('Beacon', () => {
             expect(beacon.beaconInfo).toBeTruthy();
         });
 
-        it('creates beacon without error from a malformed event', () => {
+        it("creates beacon without error from a malformed event", () => {
             const event = new MatrixEvent({
                 type: M_BEACON_INFO.name,
                 room_id: roomId,
@@ -150,13 +146,13 @@ describe('Beacon', () => {
             expect(beacon.beaconInfo).toBeTruthy();
         });
 
-        describe('isLive()', () => {
-            it('returns false when beacon is explicitly set to not live', () => {
+        describe("isLive()", () => {
+            it("returns false when beacon is explicitly set to not live", () => {
                 const beacon = new Beacon(notLiveBeaconEvent);
                 expect(beacon.isLive).toEqual(false);
             });
 
-            it('returns false when beacon is expired', () => {
+            it("returns false when beacon is expired", () => {
                 const expiredBeaconEvent = makeBeaconInfoEvent(
                     userId2,
                     roomId,
@@ -165,13 +161,13 @@ describe('Beacon', () => {
                         isLive: true,
                         timestamp: now - HOUR_MS * 2,
                     },
-                    '$user2live123',
+                    "$user2live123",
                 );
                 const beacon = new Beacon(expiredBeaconEvent);
                 expect(beacon.isLive).toEqual(false);
             });
 
-            it('returns false when beacon timestamp is in future by an hour', () => {
+            it("returns false when beacon timestamp is in future by an hour", () => {
                 const beaconStartsInHour = makeBeaconInfoEvent(
                     userId2,
                     roomId,
@@ -180,13 +176,13 @@ describe('Beacon', () => {
                         isLive: true,
                         timestamp: now + HOUR_MS,
                     },
-                    '$user2live123',
+                    "$user2live123",
                 );
                 const beacon = new Beacon(beaconStartsInHour);
                 expect(beacon.isLive).toEqual(false);
             });
 
-            it('returns true when beacon timestamp is one minute in the future', () => {
+            it("returns true when beacon timestamp is one minute in the future", () => {
                 const beaconStartsInOneMin = makeBeaconInfoEvent(
                     userId2,
                     roomId,
@@ -195,13 +191,13 @@ describe('Beacon', () => {
                         isLive: true,
                         timestamp: now + 60000,
                     },
-                    '$user2live123',
+                    "$user2live123",
                 );
                 const beacon = new Beacon(beaconStartsInOneMin);
                 expect(beacon.isLive).toEqual(true);
             });
 
-            it('returns true when beacon timestamp is one minute before expiry', () => {
+            it("returns true when beacon timestamp is one minute before expiry", () => {
                 // this test case is to check the start time leniency doesn't affect
                 // strict expiry time checks
                 const expiresInOneMin = makeBeaconInfoEvent(
@@ -212,13 +208,13 @@ describe('Beacon', () => {
                         isLive: true,
                         timestamp: now - HOUR_MS + 60000,
                     },
-                    '$user2live123',
+                    "$user2live123",
                 );
                 const beacon = new Beacon(expiresInOneMin);
                 expect(beacon.isLive).toEqual(true);
             });
 
-            it('returns false when beacon timestamp is one minute after expiry', () => {
+            it("returns false when beacon timestamp is one minute after expiry", () => {
                 // this test case is to check the start time leniency doesn't affect
                 // strict expiry time checks
                 const expiredOneMinAgo = makeBeaconInfoEvent(
@@ -229,21 +225,21 @@ describe('Beacon', () => {
                         isLive: true,
                         timestamp: now - HOUR_MS - 60000,
                     },
-                    '$user2live123',
+                    "$user2live123",
                 );
                 const beacon = new Beacon(expiredOneMinAgo);
                 expect(beacon.isLive).toEqual(false);
             });
 
-            it('returns true when beacon was created in past and not yet expired', () => {
+            it("returns true when beacon was created in past and not yet expired", () => {
                 // liveBeaconEvent was created 1 hour ago
                 const beacon = new Beacon(liveBeaconEvent);
                 expect(beacon.isLive).toEqual(true);
             });
         });
 
-        describe('update()', () => {
-            it('does not update with different event', () => {
+        describe("update()", () => {
+            it("does not update with different event", () => {
                 const beacon = new Beacon(liveBeaconEvent);
 
                 expect(beacon.beaconInfoId).toEqual(liveBeaconEvent.getId());
@@ -253,15 +249,12 @@ describe('Beacon', () => {
                 expect(beacon.identifier).toEqual(`${roomId}_${userId}`);
             });
 
-            it('does not update with an older event', () => {
+            it("does not update with an older event", () => {
                 const beacon = new Beacon(liveBeaconEvent);
-                const emitSpy = jest.spyOn(beacon, 'emit').mockClear();
+                const emitSpy = jest.spyOn(beacon, "emit").mockClear();
                 expect(beacon.beaconInfoId).toEqual(liveBeaconEvent.getId());
 
-                const oldUpdateEvent = makeBeaconInfoEvent(
-                    userId,
-                    roomId,
-                );
+                const oldUpdateEvent = makeBeaconInfoEvent(userId, roomId);
                 // less than the original event
                 oldUpdateEvent.event.origin_server_ts = liveBeaconEvent.event.origin_server_ts! - 1000;
 
@@ -271,23 +264,27 @@ describe('Beacon', () => {
                 expect(beacon.beaconInfoId).toEqual(liveBeaconEvent.getId());
             });
 
-            it('updates event', () => {
+            it("updates event", () => {
                 const beacon = new Beacon(liveBeaconEvent);
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 expect(beacon.isLive).toEqual(true);
 
                 const updatedBeaconEvent = makeBeaconInfoEvent(
-                    userId, roomId, { timeout: HOUR_MS * 3, isLive: false }, '$live123');
+                    userId,
+                    roomId,
+                    { timeout: HOUR_MS * 3, isLive: false },
+                    "$live123",
+                );
 
                 beacon.update(updatedBeaconEvent);
                 expect(beacon.isLive).toEqual(false);
                 expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.Update, updatedBeaconEvent, beacon);
             });
 
-            it('emits livenesschange event when beacon liveness changes', () => {
+            it("emits livenesschange event when beacon liveness changes", () => {
                 const beacon = new Beacon(liveBeaconEvent);
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 expect(beacon.isLive).toEqual(true);
 
@@ -304,12 +301,12 @@ describe('Beacon', () => {
             });
         });
 
-        describe('monitorLiveness()', () => {
-            it('does not set a monitor interval when beacon is not live', () => {
+        describe("monitorLiveness()", () => {
+            it("does not set a monitor interval when beacon is not live", () => {
                 // beacon was created an hour ago
                 // and has a 3hr duration
                 const beacon = new Beacon(notLiveBeaconEvent);
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 beacon.monitorLiveness();
 
@@ -321,7 +318,7 @@ describe('Beacon', () => {
                 expect(emitSpy).not.toHaveBeenCalled();
             });
 
-            it('checks liveness of beacon at expected start time', () => {
+            it("checks liveness of beacon at expected start time", () => {
                 const futureBeaconEvent = makeBeaconInfoEvent(
                     userId,
                     roomId,
@@ -331,12 +328,12 @@ describe('Beacon', () => {
                         // start timestamp hour in future
                         timestamp: now + HOUR_MS,
                     },
-                    '$live123',
+                    "$live123",
                 );
 
                 const beacon = new Beacon(futureBeaconEvent);
                 expect(beacon.isLive).toBeFalsy();
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 beacon.monitorLiveness();
 
@@ -355,12 +352,12 @@ describe('Beacon', () => {
                 expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.LivenessChange, false, beacon);
             });
 
-            it('checks liveness of beacon at expected expiry time', () => {
+            it("checks liveness of beacon at expected expiry time", () => {
                 // live beacon was created an hour ago
                 // and has a 3hr duration
                 const beacon = new Beacon(liveBeaconEvent);
                 expect(beacon.isLive).toBeTruthy();
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 beacon.monitorLiveness();
                 advanceDateAndTime(HOUR_MS * 2 + 1);
@@ -369,7 +366,7 @@ describe('Beacon', () => {
                 expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.LivenessChange, false, beacon);
             });
 
-            it('clears monitor interval when re-monitoring liveness', () => {
+            it("clears monitor interval when re-monitoring liveness", () => {
                 // live beacon was created an hour ago
                 // and has a 3hr duration
                 const beacon = new Beacon(liveBeaconEvent);
@@ -385,12 +382,12 @@ describe('Beacon', () => {
                 expect(beacon.livenessWatchTimeout).not.toEqual(oldMonitor);
             });
 
-            it('destroy kills liveness monitor and emits', () => {
+            it("destroy kills liveness monitor and emits", () => {
                 // live beacon was created an hour ago
                 // and has a 3hr duration
                 const beacon = new Beacon(liveBeaconEvent);
                 expect(beacon.isLive).toBeTruthy();
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 beacon.monitorLiveness();
 
@@ -407,10 +404,10 @@ describe('Beacon', () => {
             });
         });
 
-        describe('addLocations', () => {
-            it('ignores locations when beacon is not live', () => {
+        describe("addLocations", () => {
+            it("ignores locations when beacon is not live", () => {
                 const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: false }));
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 beacon.addLocations([
                     makeBeaconEvent(userId, { beaconInfoId: beacon.beaconInfoId, timestamp: now + 1 }),
@@ -420,9 +417,9 @@ describe('Beacon', () => {
                 expect(emitSpy).not.toHaveBeenCalled();
             });
 
-            it('ignores locations outside the beacon live duration', () => {
+            it("ignores locations outside the beacon live duration", () => {
                 const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 beacon.addLocations([
                     // beacon has now + 60000 live period
@@ -435,7 +432,7 @@ describe('Beacon', () => {
 
             it("should ignore invalid beacon events", () => {
                 const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 const ev = new MatrixEvent({
                     type: M_BEACON_INFO.name,
@@ -454,50 +451,48 @@ describe('Beacon', () => {
                 expect(emitSpy).not.toHaveBeenCalled();
             });
 
-            describe('when beacon is live with a start timestamp is in the future', () => {
-                it('ignores locations before the beacon start timestamp', () => {
+            describe("when beacon is live with a start timestamp is in the future", () => {
+                it("ignores locations before the beacon start timestamp", () => {
                     const startTimestamp = now + 60000;
-                    const beacon = new Beacon(makeBeaconInfoEvent(
-                        userId,
-                        roomId,
-                        { isLive: true, timeout: 60000, timestamp: startTimestamp },
-                    ));
-                    const emitSpy = jest.spyOn(beacon, 'emit');
+                    const beacon = new Beacon(
+                        makeBeaconInfoEvent(userId, roomId, {
+                            isLive: true,
+                            timeout: 60000,
+                            timestamp: startTimestamp,
+                        }),
+                    );
+                    const emitSpy = jest.spyOn(beacon, "emit");
 
                     beacon.addLocations([
                         // beacon has now + 60000 live period
-                        makeBeaconEvent(
-                            userId,
-                            {
-                                beaconInfoId: beacon.beaconInfoId,
-                                // now < location timestamp < beacon timestamp
-                                timestamp: now + 10,
-                            },
-                        ),
+                        makeBeaconEvent(userId, {
+                            beaconInfoId: beacon.beaconInfoId,
+                            // now < location timestamp < beacon timestamp
+                            timestamp: now + 10,
+                        }),
                     ]);
 
                     expect(beacon.latestLocationState).toBeFalsy();
                     expect(emitSpy).not.toHaveBeenCalled();
                 });
-                it('sets latest location when location timestamp is after startTimestamp', () => {
+                it("sets latest location when location timestamp is after startTimestamp", () => {
                     const startTimestamp = now + 60000;
-                    const beacon = new Beacon(makeBeaconInfoEvent(
-                        userId,
-                        roomId,
-                        { isLive: true, timeout: 600000, timestamp: startTimestamp },
-                    ));
-                    const emitSpy = jest.spyOn(beacon, 'emit');
+                    const beacon = new Beacon(
+                        makeBeaconInfoEvent(userId, roomId, {
+                            isLive: true,
+                            timeout: 600000,
+                            timestamp: startTimestamp,
+                        }),
+                    );
+                    const emitSpy = jest.spyOn(beacon, "emit");
 
                     beacon.addLocations([
                         // beacon has now + 600000 live period
-                        makeBeaconEvent(
-                            userId,
-                            {
-                                beaconInfoId: beacon.beaconInfoId,
-                                // now < beacon timestamp < location timestamp
-                                timestamp: startTimestamp + 10,
-                            },
-                        ),
+                        makeBeaconEvent(userId, {
+                            beaconInfoId: beacon.beaconInfoId,
+                            // now < beacon timestamp < location timestamp
+                            timestamp: startTimestamp + 10,
+                        }),
                     ]);
 
                     expect(beacon.latestLocationState).toBeTruthy();
@@ -505,23 +500,21 @@ describe('Beacon', () => {
                 });
             });
 
-            it('sets latest location state to most recent location', () => {
+            it("sets latest location state to most recent location", () => {
                 const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
-                const emitSpy = jest.spyOn(beacon, 'emit');
+                const emitSpy = jest.spyOn(beacon, "emit");
 
                 const locations = [
                     // older
-                    makeBeaconEvent(
-                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:foo', timestamp: now + 1 },
-                    ),
+                    makeBeaconEvent(userId, { beaconInfoId: beacon.beaconInfoId, uri: "geo:foo", timestamp: now + 1 }),
                     // newer
-                    makeBeaconEvent(
-                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:bar', timestamp: now + 10000 },
-                    ),
+                    makeBeaconEvent(userId, {
+                        beaconInfoId: beacon.beaconInfoId,
+                        uri: "geo:bar",
+                        timestamp: now + 10000,
+                    }),
                     // not valid
-                    makeBeaconEvent(
-                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:baz', timestamp: now - 5 },
-                    ),
+                    makeBeaconEvent(userId, { beaconInfoId: beacon.beaconInfoId, uri: "geo:baz", timestamp: now - 5 }),
                 ];
 
                 beacon.addLocations(locations);
@@ -529,7 +522,7 @@ describe('Beacon', () => {
                 const expectedLatestLocation = {
                     description: undefined,
                     timestamp: now + 10000,
-                    uri: 'geo:bar',
+                    uri: "geo:bar",
                 };
 
                 // the newest valid location
@@ -538,32 +531,40 @@ describe('Beacon', () => {
                 expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.LocationUpdate, expectedLatestLocation);
             });
 
-            it('ignores locations that are less recent that the current latest location', () => {
+            it("ignores locations that are less recent that the current latest location", () => {
                 const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
 
-                const olderLocation = makeBeaconEvent(
-                    userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:foo', timestamp: now + 1 },
-                );
-                const newerLocation = makeBeaconEvent(
-                    userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:bar', timestamp: now + 10000 },
-                );
+                const olderLocation = makeBeaconEvent(userId, {
+                    beaconInfoId: beacon.beaconInfoId,
+                    uri: "geo:foo",
+                    timestamp: now + 1,
+                });
+                const newerLocation = makeBeaconEvent(userId, {
+                    beaconInfoId: beacon.beaconInfoId,
+                    uri: "geo:bar",
+                    timestamp: now + 10000,
+                });
 
                 beacon.addLocations([newerLocation]);
                 // latest location set to newerLocation
-                expect(beacon.latestLocationState).toEqual(expect.objectContaining({
-                    uri: 'geo:bar',
-                }));
+                expect(beacon.latestLocationState).toEqual(
+                    expect.objectContaining({
+                        uri: "geo:bar",
+                    }),
+                );
                 expect(beacon.latestLocationEvent).toEqual(newerLocation);
 
-                const emitSpy = jest.spyOn(beacon, 'emit').mockClear();
+                const emitSpy = jest.spyOn(beacon, "emit").mockClear();
 
                 // add older location
                 beacon.addLocations([olderLocation]);
 
                 // no change
-                expect(beacon.latestLocationState).toEqual(expect.objectContaining({
-                    uri: 'geo:bar',
-                }));
+                expect(beacon.latestLocationState).toEqual(
+                    expect.objectContaining({
+                        uri: "geo:bar",
+                    }),
+                );
                 // no emit
                 expect(emitSpy).not.toHaveBeenCalled();
             });
diff --git a/spec/unit/models/event.spec.ts b/spec/unit/models/event.spec.ts
index 92d929fd4e7..da492b54225 100644
--- a/spec/unit/models/event.spec.ts
+++ b/spec/unit/models/event.spec.ts
@@ -19,8 +19,8 @@ import { emitPromise } from "../../test-utils/test-utils";
 import { EventType } from "../../../src";
 import { Crypto } from "../../../src/crypto";
 
-describe('MatrixEvent', () => {
-    it('should create copies of itself', () => {
+describe("MatrixEvent", () => {
+    it("should create copies of itself", () => {
         const a = new MatrixEvent({
             type: "com.example.test",
             content: {
@@ -38,7 +38,7 @@ describe('MatrixEvent', () => {
         // The other properties we're not super interested in, honestly.
     });
 
-    it('should compare itself to other events using json', () => {
+    it("should compare itself to other events using json", () => {
         const a = new MatrixEvent({
             type: "com.example.test",
             content: {
@@ -122,36 +122,37 @@ describe('MatrixEvent', () => {
 
     describe(".attemptDecryption", () => {
         let encryptedEvent: MatrixEvent;
-        const eventId = 'test_encrypted_event';
+        const eventId = "test_encrypted_event";
 
         beforeEach(() => {
             encryptedEvent = new MatrixEvent({
                 event_id: eventId,
-                type: 'm.room.encrypted',
+                type: "m.room.encrypted",
                 content: {
-                    ciphertext: 'secrets',
+                    ciphertext: "secrets",
                 },
             });
         });
 
-        it('should retry decryption if a retry is queued', async () => {
-            const eventAttemptDecryptionSpy = jest.spyOn(encryptedEvent, 'attemptDecryption');
+        it("should retry decryption if a retry is queued", async () => {
+            const eventAttemptDecryptionSpy = jest.spyOn(encryptedEvent, "attemptDecryption");
 
             const crypto = {
-                decryptEvent: jest.fn()
+                decryptEvent: jest
+                    .fn()
                     .mockImplementationOnce(() => {
                         // schedule a second decryption attempt while
                         // the first one is still running.
                         encryptedEvent.attemptDecryption(crypto);
 
                         const error = new Error("nope");
-                        error.name = 'DecryptionError';
+                        error.name = "DecryptionError";
                         return Promise.reject(error);
                     })
                     .mockImplementationOnce(() => {
                         return Promise.resolve({
                             clearEvent: {
-                                type: 'm.room.message',
+                                type: "m.room.message",
                             },
                         });
                     }),
@@ -161,7 +162,7 @@ describe('MatrixEvent', () => {
 
             expect(eventAttemptDecryptionSpy).toHaveBeenCalledTimes(2);
             expect(crypto.decryptEvent).toHaveBeenCalledTimes(2);
-            expect(encryptedEvent.getType()).toEqual('m.room.message');
+            expect(encryptedEvent.getType()).toEqual("m.room.message");
         });
     });
 });
diff --git a/spec/unit/models/thread.spec.ts b/spec/unit/models/thread.spec.ts
index 1ffb466370f..42b976cd6ac 100644
--- a/spec/unit/models/thread.spec.ts
+++ b/spec/unit/models/thread.spec.ts
@@ -22,7 +22,7 @@ import { TestClient } from "../../TestClient";
 import { emitPromise, mkMessage } from "../../test-utils/test-utils";
 import { EventStatus } from "../../../src";
 
-describe('Thread', () => {
+describe("Thread", () => {
     describe("constructor", () => {
         it("should explode for element-web#22141 logging", () => {
             // Logging/debugging for https://github.com/vector-im/element-web/issues/22141
@@ -34,13 +34,7 @@ describe('Thread', () => {
 
     it("includes pending events in replyCount", async () => {
         const myUserId = "@bob:example.org";
-        const testClient = new TestClient(
-            myUserId,
-            "DEVICE",
-            "ACCESS_TOKEN",
-            undefined,
-            { timelineSupport: false },
-        );
+        const testClient = new TestClient(myUserId, "DEVICE", "ACCESS_TOKEN", undefined, { timelineSupport: false });
         const client = testClient.client;
         const room = new Room("123", client, myUserId, {
             pendingEventOrdering: PendingEventOrdering.Detached,
@@ -82,13 +76,9 @@ describe('Thread', () => {
         let room: Room;
 
         beforeEach(() => {
-            const testClient = new TestClient(
-                myUserId,
-                "DEVICE",
-                "ACCESS_TOKEN",
-                undefined,
-                { timelineSupport: false },
-            );
+            const testClient = new TestClient(myUserId, "DEVICE", "ACCESS_TOKEN", undefined, {
+                timelineSupport: false,
+            });
             client = testClient.client;
             room = new Room("123", client, myUserId);
 
diff --git a/spec/unit/notifications.spec.ts b/spec/unit/notifications.spec.ts
index 02388f9f0dd..b94f9cd9c10 100644
--- a/spec/unit/notifications.spec.ts
+++ b/spec/unit/notifications.spec.ts
@@ -57,9 +57,9 @@ describe("fixNotificationCountOnDecryption", () => {
             decryptEventIfNeeded: jest.fn().mockResolvedValue(void 0),
             supportsExperimentalThreads: jest.fn().mockReturnValue(true),
         });
-        mockClient.reEmitter = mock(ReEmitter, 'ReEmitter');
+        mockClient.reEmitter = mock(ReEmitter, "ReEmitter");
         mockClient.canSupport = new Map();
-        Object.keys(Feature).forEach(feature => {
+        Object.keys(Feature).forEach((feature) => {
             mockClient.canSupport.set(feature as Feature, ServerSupport.Stable);
         });
 
@@ -67,14 +67,17 @@ describe("fixNotificationCountOnDecryption", () => {
         room.setUnreadNotificationCount(NotificationCountType.Total, 1);
         room.setUnreadNotificationCount(NotificationCountType.Highlight, 0);
 
-        event = mkEvent({
-            type: EventType.RoomMessage,
-            content: {
-                msgtype: MsgType.Text,
-                body: "Hello world!",
+        event = mkEvent(
+            {
+                type: EventType.RoomMessage,
+                content: {
+                    msgtype: MsgType.Text,
+                    body: "Hello world!",
+                },
+                event: true,
             },
-            event: true,
-        }, mockClient);
+            mockClient,
+        );
 
         THREAD_ID = event.getId()!;
         threadEvent = mkEvent({
diff --git a/spec/unit/pusher.spec.ts b/spec/unit/pusher.spec.ts
index dd46770a4aa..994ef767587 100644
--- a/spec/unit/pusher.spec.ts
+++ b/spec/unit/pusher.spec.ts
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import MockHttpBackend from 'matrix-mock-request';
+import MockHttpBackend from "matrix-mock-request";
 
 import { MatrixClient, PUSHER_ENABLED } from "../../src/matrix";
-import { mkPusher } from '../test-utils/test-utils';
+import { mkPusher } from "../test-utils/test-utils";
 
 const realSetTimeout = setTimeout;
 function flushPromises() {
-    return new Promise(r => {
+    return new Promise((r) => {
         realSetTimeout(r, 1);
     });
 }
diff --git a/spec/unit/pushprocessor.spec.ts b/spec/unit/pushprocessor.spec.ts
index a2b61255389..dd84f03820a 100644
--- a/spec/unit/pushprocessor.spec.ts
+++ b/spec/unit/pushprocessor.spec.ts
@@ -2,7 +2,7 @@ import * as utils from "../test-utils/test-utils";
 import { IActionsObject, PushProcessor } from "../../src/pushprocessor";
 import { EventType, IContent, MatrixClient, MatrixEvent } from "../../src";
 
-describe('NotificationService', function() {
+describe("NotificationService", function () {
     const testUserId = "@ali:matrix.org";
     const testDisplayName = "Alice M";
     const testRoomId = "!fl1bb13:localhost";
@@ -13,15 +13,15 @@ describe('NotificationService', function() {
 
     // These would be better if individual rules were configured in the tests themselves.
     const matrixClient = {
-        getRoom: function() {
+        getRoom: function () {
             return {
                 currentState: {
-                    getMember: function() {
+                    getMember: function () {
                         return {
                             name: testDisplayName,
                         };
                     },
-                    getJoinedMemberCount: function() {
+                    getJoinedMemberCount: function () {
                         return 0;
                     },
                     members: {},
@@ -32,136 +32,136 @@ describe('NotificationService', function() {
             userId: testUserId,
         },
         pushRules: {
-            "device": {},
-            "global": {
-                "content": [
+            device: {},
+            global: {
+                content: [
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                             {
-                                "set_tweak": "highlight",
+                                set_tweak: "highlight",
                             },
                         ],
-                        "enabled": true,
-                        "pattern": "ali",
-                        "rule_id": ".m.rule.contains_user_name",
+                        enabled: true,
+                        pattern: "ali",
+                        rule_id: ".m.rule.contains_user_name",
                     },
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                             {
-                                "set_tweak": "highlight",
+                                set_tweak: "highlight",
                             },
                         ],
-                        "enabled": true,
-                        "pattern": "coffee",
-                        "rule_id": "coffee",
+                        enabled: true,
+                        pattern: "coffee",
+                        rule_id: "coffee",
                     },
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                             {
-                                "set_tweak": "highlight",
+                                set_tweak: "highlight",
                             },
                         ],
-                        "enabled": true,
-                        "pattern": "foo*bar",
-                        "rule_id": "foobar",
+                        enabled: true,
+                        pattern: "foo*bar",
+                        rule_id: "foobar",
                     },
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                             {
-                                "set_tweak": "highlight",
+                                set_tweak: "highlight",
                             },
                         ],
-                        "enabled": true,
-                        "pattern": "p[io]ng",
-                        "rule_id": "pingpong",
+                        enabled: true,
+                        pattern: "p[io]ng",
+                        rule_id: "pingpong",
                     },
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                             {
-                                "set_tweak": "highlight",
+                                set_tweak: "highlight",
                             },
                         ],
-                        "enabled": true,
-                        "pattern": "I ate [0-9] pies",
-                        "rule_id": "pies",
+                        enabled: true,
+                        pattern: "I ate [0-9] pies",
+                        rule_id: "pies",
                     },
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                             {
-                                "set_tweak": "highlight",
+                                set_tweak: "highlight",
                             },
                         ],
-                        "enabled": true,
-                        "pattern": "b[!ai]ke",
-                        "rule_id": "bakebike",
+                        enabled: true,
+                        pattern: "b[!ai]ke",
+                        rule_id: "bakebike",
                     },
                 ],
-                "override": [
+                override: [
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                             {
-                                "set_tweak": "highlight",
+                                set_tweak: "highlight",
                             },
                         ],
-                        "conditions": [
+                        conditions: [
                             {
-                                "kind": "contains_display_name",
+                                kind: "contains_display_name",
                             },
                         ],
-                        "enabled": true,
-                        "rule_id": ".m.rule.contains_display_name",
+                        enabled: true,
+                        rule_id: ".m.rule.contains_display_name",
                     },
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "sound",
-                                "value": "default",
+                                set_tweak: "sound",
+                                value: "default",
                             },
                         ],
-                        "conditions": [
+                        conditions: [
                             {
-                                "is": "2",
-                                "kind": "room_member_count",
+                                is: "2",
+                                kind: "room_member_count",
                             },
                         ],
-                        "enabled": true,
-                        "rule_id": ".m.rule.room_one_to_one",
+                        enabled: true,
+                        rule_id: ".m.rule.room_one_to_one",
                     },
                     {
                         rule_id: ".org.matrix.msc3914.rule.room.call",
@@ -180,41 +180,39 @@ describe('NotificationService', function() {
                         actions: ["notify", { set_tweak: "sound", value: "default" }],
                     },
                 ],
-                "room": [],
-                "sender": [],
-                "underride": [
+                room: [],
+                sender: [],
+                underride: [
                     {
-                        "actions": [
-                            "dont-notify",
-                        ],
-                        "conditions": [
+                        actions: ["dont-notify"],
+                        conditions: [
                             {
-                                "key": "content.msgtype",
-                                "kind": "event_match",
-                                "pattern": "m.notice",
+                                key: "content.msgtype",
+                                kind: "event_match",
+                                pattern: "m.notice",
                             },
                         ],
-                        "enabled": true,
-                        "rule_id": ".m.rule.suppress_notices",
+                        enabled: true,
+                        rule_id: ".m.rule.suppress_notices",
                     },
                     {
-                        "actions": [
+                        actions: [
                             "notify",
                             {
-                                "set_tweak": "highlight",
-                                "value": false,
+                                set_tweak: "highlight",
+                                value: false,
                             },
                         ],
-                        "conditions": [],
-                        "enabled": true,
-                        "rule_id": ".m.rule.fallback",
+                        conditions: [],
+                        enabled: true,
+                        rule_id: ".m.rule.fallback",
                     },
                 ],
             },
         },
     } as unknown as MatrixClient;
 
-    beforeEach(function() {
+    beforeEach(function () {
         testEvent = utils.mkEvent({
             type: "m.room.message",
             room: testRoomId,
@@ -231,25 +229,25 @@ describe('NotificationService', function() {
 
     // User IDs
 
-    it('should bing on a user ID.', function() {
+    it("should bing on a user ID.", function () {
         testEvent.event.content!.body = "Hello @ali:matrix.org, how are you?";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on a partial user ID with an @.', function() {
+    it("should bing on a partial user ID with an @.", function () {
         testEvent.event.content!.body = "Hello @ali, how are you?";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on a partial user ID without @.', function() {
+    it("should bing on a partial user ID without @.", function () {
         testEvent.event.content!.body = "Hello ali, how are you?";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on a case-insensitive user ID.', function() {
+    it("should bing on a case-insensitive user ID.", function () {
         testEvent.event.content!.body = "Hello @AlI:matrix.org, how are you?";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
@@ -257,13 +255,13 @@ describe('NotificationService', function() {
 
     // Display names
 
-    it('should bing on a display name.', function() {
+    it("should bing on a display name.", function () {
         testEvent.event.content!.body = "Hello Alice M, how are you?";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on a case-insensitive display name.', function() {
+    it("should bing on a case-insensitive display name.", function () {
         testEvent.event.content!.body = "Hello ALICE M, how are you?";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
@@ -271,25 +269,25 @@ describe('NotificationService', function() {
 
     // Bing words
 
-    it('should bing on a bing word.', function() {
+    it("should bing on a bing word.", function () {
         testEvent.event.content!.body = "I really like coffee";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on case-insensitive bing words.', function() {
+    it("should bing on case-insensitive bing words.", function () {
         testEvent.event.content!.body = "Coffee is great";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on wildcard (.*) bing words.', function() {
+    it("should bing on wildcard (.*) bing words.", function () {
         testEvent.event.content!.body = "It was foomahbar I think.";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on character group ([abc]) bing words.', function() {
+    it("should bing on character group ([abc]) bing words.", function () {
         testEvent.event.content!.body = "Ping!";
         let actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
@@ -298,13 +296,13 @@ describe('NotificationService', function() {
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on character range ([a-z]) bing words.', function() {
+    it("should bing on character range ([a-z]) bing words.", function () {
         testEvent.event.content!.body = "I ate 6 pies";
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
     });
 
-    it('should bing on character negation ([!a]) bing words.', function() {
+    it("should bing on character negation ([!a]) bing words.", function () {
         testEvent.event.content!.body = "boke";
         let actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(true);
@@ -313,7 +311,7 @@ describe('NotificationService', function() {
         expect(actions.tweaks.highlight).toEqual(false);
     });
 
-    it('should not bing on room server ACL changes', function() {
+    it("should not bing on room server ACL changes", function () {
         testEvent = utils.mkEvent({
             type: EventType.RoomServerAcl,
             room: testRoomId,
@@ -331,31 +329,41 @@ describe('NotificationService', function() {
 
     // invalid
 
-    it('should gracefully handle bad input.', function() {
-        testEvent.event.content!.body = { "foo": "bar" };
+    it("should gracefully handle bad input.", function () {
+        testEvent.event.content!.body = { foo: "bar" };
         const actions = pushProcessor.actionsForEvent(testEvent);
         expect(actions.tweaks.highlight).toEqual(false);
     });
 
-    it("a rule with no conditions matches every event.", function() {
-        expect(pushProcessor.ruleMatchesEvent({
-            rule_id: "rule1",
-            actions: [],
-            conditions: [],
-            default: false,
-            enabled: true,
-        }, testEvent)).toBe(true);
-        expect(pushProcessor.ruleMatchesEvent({
-            rule_id: "rule1",
-            actions: [],
-            default: false,
-            enabled: true,
-        }, testEvent)).toBe(true);
+    it("a rule with no conditions matches every event.", function () {
+        expect(
+            pushProcessor.ruleMatchesEvent(
+                {
+                    rule_id: "rule1",
+                    actions: [],
+                    conditions: [],
+                    default: false,
+                    enabled: true,
+                },
+                testEvent,
+            ),
+        ).toBe(true);
+        expect(
+            pushProcessor.ruleMatchesEvent(
+                {
+                    rule_id: "rule1",
+                    actions: [],
+                    default: false,
+                    enabled: true,
+                },
+                testEvent,
+            ),
+        ).toBe(true);
     });
 
     describe("group call started push rule", () => {
         beforeEach(() => {
-            matrixClient.pushRules!.global!.underride!.find(r => r.rule_id === ".m.rule.fallback")!.enabled = false;
+            matrixClient.pushRules!.global!.underride!.find((r) => r.rule_id === ".m.rule.fallback")!.enabled = false;
         });
 
         const getActionsForEvent = (prevContent: IContent, content: IContent): IActionsObject => {
@@ -384,73 +392,104 @@ describe('NotificationService', function() {
             expect(actions?.tweaks?.highlight).toBeFalsy();
         };
 
-        it.each(
-            ["m.ring", "m.prompt"],
-        )("should notify when new group call event appears with %s intent", (intent: string) => {
-            assertDoesNotify(getActionsForEvent({}, {
-                "m.intent": intent,
-                "m.type": "m.voice",
-                "m.name": "Call",
-            }));
-        });
+        it.each(["m.ring", "m.prompt"])(
+            "should notify when new group call event appears with %s intent",
+            (intent: string) => {
+                assertDoesNotify(
+                    getActionsForEvent(
+                        {},
+                        {
+                            "m.intent": intent,
+                            "m.type": "m.voice",
+                            "m.name": "Call",
+                        },
+                    ),
+                );
+            },
+        );
 
         it("should notify when a call is un-terminated", () => {
-            assertDoesNotify(getActionsForEvent({
-                "m.intent": "m.ring",
-                "m.type": "m.voice",
-                "m.name": "Call",
-                "m.terminated": "All users left",
-            }, {
-                "m.intent": "m.ring",
-                "m.type": "m.voice",
-                "m.name": "Call",
-            }));
+            assertDoesNotify(
+                getActionsForEvent(
+                    {
+                        "m.intent": "m.ring",
+                        "m.type": "m.voice",
+                        "m.name": "Call",
+                        "m.terminated": "All users left",
+                    },
+                    {
+                        "m.intent": "m.ring",
+                        "m.type": "m.voice",
+                        "m.name": "Call",
+                    },
+                ),
+            );
         });
 
         it("should not notify when call is terminated", () => {
-            assertDoesNotNotify(getActionsForEvent({
-                "m.intent": "m.ring",
-                "m.type": "m.voice",
-                "m.name": "Call",
-            }, {
-                "m.intent": "m.ring",
-                "m.type": "m.voice",
-                "m.name": "Call",
-                "m.terminated": "All users left",
-            }));
+            assertDoesNotNotify(
+                getActionsForEvent(
+                    {
+                        "m.intent": "m.ring",
+                        "m.type": "m.voice",
+                        "m.name": "Call",
+                    },
+                    {
+                        "m.intent": "m.ring",
+                        "m.type": "m.voice",
+                        "m.name": "Call",
+                        "m.terminated": "All users left",
+                    },
+                ),
+            );
         });
 
         it("should ignore with m.room intent", () => {
-            assertDoesNotNotify(getActionsForEvent({}, {
-                "m.intent": "m.room",
-                "m.type": "m.voice",
-                "m.name": "Call",
-            }));
+            assertDoesNotNotify(
+                getActionsForEvent(
+                    {},
+                    {
+                        "m.intent": "m.room",
+                        "m.type": "m.voice",
+                        "m.name": "Call",
+                    },
+                ),
+            );
         });
 
         describe("ignoring non-relevant state changes", () => {
             it("should ignore intent changes", () => {
-                assertDoesNotNotify(getActionsForEvent({
-                    "m.intent": "m.ring",
-                    "m.type": "m.voice",
-                    "m.name": "Call",
-                }, {
-                    "m.intent": "m.ring",
-                    "m.type": "m.video",
-                    "m.name": "Call",
-                }));
+                assertDoesNotNotify(
+                    getActionsForEvent(
+                        {
+                            "m.intent": "m.ring",
+                            "m.type": "m.voice",
+                            "m.name": "Call",
+                        },
+                        {
+                            "m.intent": "m.ring",
+                            "m.type": "m.video",
+                            "m.name": "Call",
+                        },
+                    ),
+                );
             });
 
             it("should ignore name changes", () => {
-                assertDoesNotNotify(getActionsForEvent({
-                    "m.intent": "m.ring",
-                    "m.type": "m.voice",
-                    "m.name": "Call",
-                }, {
-                    "m.intent": "m.ring",
-                    "m.type": "m.voice",
-                    "m.name": "New call",
-                }));
+                assertDoesNotNotify(
+                    getActionsForEvent(
+                        {
+                            "m.intent": "m.ring",
+                            "m.type": "m.voice",
+                            "m.name": "Call",
+                        },
+                        {
+                            "m.intent": "m.ring",
+                            "m.type": "m.voice",
+                            "m.name": "New call",
+                        },
+                    ),
+                );
             });
         });
     });
diff --git a/spec/unit/queueToDevice.spec.ts b/spec/unit/queueToDevice.spec.ts
index 298f5341ca9..c09d6968703 100644
--- a/spec/unit/queueToDevice.spec.ts
+++ b/spec/unit/queueToDevice.spec.ts
@@ -14,21 +14,21 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import MockHttpBackend from 'matrix-mock-request';
-import { indexedDB as fakeIndexedDB } from 'fake-indexeddb';
+import MockHttpBackend from "matrix-mock-request";
+import { indexedDB as fakeIndexedDB } from "fake-indexeddb";
 
 import { IndexedDBStore, MatrixEvent, MemoryStore, Room } from "../../src";
 import { MatrixClient } from "../../src/client";
-import { ToDeviceBatch } from '../../src/models/ToDeviceMessage';
-import { logger } from '../../src/logger';
-import { IStore } from '../../src/store';
-import { flushPromises } from '../test-utils/flushPromises';
+import { ToDeviceBatch } from "../../src/models/ToDeviceMessage";
+import { logger } from "../../src/logger";
+import { IStore } from "../../src/store";
+import { flushPromises } from "../test-utils/flushPromises";
 import { removeElement } from "../../src/utils";
 
 const FAKE_USER = "@alice:example.org";
 const FAKE_DEVICE_ID = "AAAAAAAA";
 const FAKE_PAYLOAD = {
-    "foo": 42,
+    foo: 42,
 };
 const EXPECTED_BODY = {
     messages: {
@@ -45,8 +45,8 @@ const FAKE_MSG = {
 };
 
 enum StoreType {
-    Memory = 'Memory',
-    IndexedDB = 'IndexedDB',
+    Memory = "Memory",
+    IndexedDB = "IndexedDB",
 }
 
 async function flushAndRunTimersUntil(cond: () => boolean) {
@@ -57,13 +57,11 @@ async function flushAndRunTimersUntil(cond: () => boolean) {
     }
 }
 
-describe.each([
-    [StoreType.Memory], [StoreType.IndexedDB],
-])("queueToDevice (%s store)", function(storeType) {
+describe.each([[StoreType.Memory], [StoreType.IndexedDB]])("queueToDevice (%s store)", function (storeType) {
     let httpBackend: MockHttpBackend;
     let client: MatrixClient;
 
-    beforeEach(async function() {
+    beforeEach(async function () {
         jest.runOnlyPendingTimers();
         jest.useRealTimers();
         httpBackend = new MockHttpBackend();
@@ -85,23 +83,22 @@ describe.each([
         });
     });
 
-    afterEach(function() {
+    afterEach(function () {
         jest.useRealTimers();
         client.stopClient();
     });
 
-    it("sends a to-device message", async function() {
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).check((request) => {
-            expect(request.data).toEqual(EXPECTED_BODY);
-        }).respond(200, {});
+    it("sends a to-device message", async function () {
+        httpBackend
+            .when("PUT", "/sendToDevice/org.example.foo/")
+            .check((request) => {
+                expect(request.data).toEqual(EXPECTED_BODY);
+            })
+            .respond(200, {});
 
         await client.queueToDevice({
             eventType: "org.example.foo",
-            batch: [
-                FAKE_MSG,
-            ],
+            batch: [FAKE_MSG],
         });
 
         await httpBackend.flushAllExpected();
@@ -111,24 +108,21 @@ describe.each([
         await flushPromises();
     });
 
-    it("retries on error", async function() {
+    it("retries on error", async function () {
         jest.useFakeTimers();
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(500);
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(500);
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).check((request) => {
-            expect(request.data).toEqual(EXPECTED_BODY);
-        }).respond(200, {});
+        httpBackend
+            .when("PUT", "/sendToDevice/org.example.foo/")
+            .check((request) => {
+                expect(request.data).toEqual(EXPECTED_BODY);
+            })
+            .respond(200, {});
 
         await client.queueToDevice({
             eventType: "org.example.foo",
-            batch: [
-                FAKE_MSG,
-            ],
+            batch: [FAKE_MSG],
         });
         await flushAndRunTimersUntil(() => httpBackend.requests.length > 0);
         expect(httpBackend.flushSync(undefined, 1)).toEqual(1);
@@ -141,18 +135,14 @@ describe.each([
         await flushPromises();
     });
 
-    it("stops retrying on 4xx errors", async function() {
+    it("stops retrying on 4xx errors", async function () {
         jest.useFakeTimers();
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(400);
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(400);
 
         await client.queueToDevice({
             eventType: "org.example.foo",
-            batch: [
-                FAKE_MSG,
-            ],
+            batch: [FAKE_MSG],
         });
         await flushAndRunTimersUntil(() => httpBackend.requests.length > 0);
         expect(httpBackend.flushSync(undefined, 1)).toEqual(1);
@@ -166,29 +156,23 @@ describe.each([
         expect(httpBackend.requests.length).toEqual(0);
     });
 
-    it("honours ratelimiting", async function() {
+    it("honours ratelimiting", async function () {
         jest.useFakeTimers();
 
         // pick something obscure enough it's unlikley to clash with a
         // retry delay the algorithm uses anyway
         const retryDelay = 279 * 1000;
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(429, {
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(429, {
             errcode: "M_LIMIT_EXCEEDED",
             retry_after_ms: retryDelay,
         });
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(200, {});
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(200, {});
 
         await client.queueToDevice({
             eventType: "org.example.foo",
-            batch: [
-                FAKE_MSG,
-            ],
+            batch: [FAKE_MSG],
         });
         await flushAndRunTimersUntil(() => httpBackend.requests.length > 0);
         expect(httpBackend.flushSync(undefined, 1)).toEqual(1);
@@ -209,26 +193,20 @@ describe.each([
         expect(httpBackend.flushSync(undefined, 1)).toEqual(1);
     });
 
-    it("retries on retryImmediately()", async function() {
+    it("retries on retryImmediately()", async function () {
         httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
             versions: ["r0.0.1"],
         });
 
         await Promise.all([client.startClient(), httpBackend.flush(undefined, 1, 20)]);
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(500);
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(500);
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(200, {});
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(200, {});
 
         await client.queueToDevice({
             eventType: "org.example.foo",
-            batch: [
-                FAKE_MSG,
-            ],
+            batch: [FAKE_MSG],
         });
         expect(await httpBackend.flush(undefined, 1, 1)).toEqual(1);
         await flushPromises();
@@ -239,26 +217,20 @@ describe.each([
         expect(await httpBackend.flush(undefined, 1, 3000)).toEqual(1);
     });
 
-    it("retries on when client is started", async function() {
+    it("retries on when client is started", async function () {
         httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
             versions: ["r0.0.1"],
         });
 
         await Promise.all([client.startClient(), httpBackend.flush("/_matrix/client/versions", 1, 20)]);
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(500);
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(500);
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(200, {});
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(200, {});
 
         await client.queueToDevice({
             eventType: "org.example.foo",
-            batch: [
-                FAKE_MSG,
-            ],
+            batch: [FAKE_MSG],
         });
         expect(await httpBackend.flush(undefined, 1, 1)).toEqual(1);
         await flushPromises();
@@ -269,26 +241,20 @@ describe.each([
         expect(await httpBackend.flush(undefined, 1, 20)).toEqual(1);
     });
 
-    it("retries when a message is retried", async function() {
+    it("retries when a message is retried", async function () {
         httpBackend.when("GET", "/_matrix/client/versions").respond(200, {
             versions: ["r0.0.1"],
         });
 
         await Promise.all([client.startClient(), httpBackend.flush(undefined, 1, 20)]);
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(500);
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(500);
 
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).respond(200, {});
+        httpBackend.when("PUT", "/sendToDevice/org.example.foo/").respond(200, {});
 
         await client.queueToDevice({
             eventType: "org.example.foo",
-            batch: [
-                FAKE_MSG,
-            ],
+            batch: [FAKE_MSG],
         });
 
         expect(await httpBackend.flush(undefined, 1, 20)).toEqual(1);
@@ -305,7 +271,7 @@ describe.each([
         expect(await httpBackend.flush(undefined, 1, 20)).toEqual(1);
     });
 
-    it("splits many messages into multiple HTTP requests", async function() {
+    it("splits many messages into multiple HTTP requests", async function () {
         const batch: ToDeviceBatch = {
             eventType: "org.example.foo",
             batch: [],
@@ -320,16 +286,20 @@ describe.each([
         }
 
         const expectedCounts = [20, 1];
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).check((request) => {
-            expect(removeElement(expectedCounts, c => c === Object.keys(request.data.messages).length)).toBeTruthy();
-        }).respond(200, {});
-        httpBackend.when(
-            "PUT", "/sendToDevice/org.example.foo/",
-        ).check((request) => {
-            expect(Object.keys(request.data.messages).length).toEqual(1);
-        }).respond(200, {});
+        httpBackend
+            .when("PUT", "/sendToDevice/org.example.foo/")
+            .check((request) => {
+                expect(
+                    removeElement(expectedCounts, (c) => c === Object.keys(request.data.messages).length),
+                ).toBeTruthy();
+            })
+            .respond(200, {});
+        httpBackend
+            .when("PUT", "/sendToDevice/org.example.foo/")
+            .check((request) => {
+                expect(Object.keys(request.data.messages).length).toEqual(1);
+            })
+            .respond(200, {});
 
         await client.queueToDevice(batch);
         await httpBackend.flushAllExpected();
diff --git a/spec/unit/read-receipt.spec.ts b/spec/unit/read-receipt.spec.ts
index df902d13b1c..46e46b1b356 100644
--- a/spec/unit/read-receipt.spec.ts
+++ b/spec/unit/read-receipt.spec.ts
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import MockHttpBackend from 'matrix-mock-request';
+import MockHttpBackend from "matrix-mock-request";
 
-import { MAIN_ROOM_TIMELINE, ReceiptType } from '../../src/@types/read_receipts';
+import { MAIN_ROOM_TIMELINE, ReceiptType } from "../../src/@types/read_receipts";
 import { MatrixClient } from "../../src/client";
-import { Feature, ServerSupport } from '../../src/feature';
-import { EventType } from '../../src/matrix';
-import { synthesizeReceipt } from '../../src/models/read-receipt';
-import { encodeUri } from '../../src/utils';
+import { Feature, ServerSupport } from "../../src/feature";
+import { EventType } from "../../src/matrix";
+import { synthesizeReceipt } from "../../src/models/read-receipt";
+import { encodeUri } from "../../src/utils";
 import * as utils from "../test-utils/test-utils";
 
 // Jest now uses @sinonjs/fake-timers which exposes tickAsync() and a number of
@@ -32,7 +32,7 @@ import * as utils from "../test-utils/test-utils";
 // and avoids assuming anything about the app's behaviour.
 const realSetTimeout = setTimeout;
 function flushPromises() {
-    return new Promise(r => {
+    return new Promise((r) => {
         realSetTimeout(r, 1);
     });
 }
@@ -53,7 +53,7 @@ const threadEvent = utils.mkEvent({
         "m.relates_to": {
             "event_id": THREAD_ID,
             "m.in_reply_to": {
-                "event_id": THREAD_ID,
+                event_id: THREAD_ID,
             },
             "rel_type": "m.thread",
         },
@@ -66,7 +66,7 @@ const roomEvent = utils.mkEvent({
     user: "@bob:matrix.org",
     room: ROOM_ID,
     content: {
-        "body": "Hello from a room",
+        body: "Hello from a room",
     },
 });
 
@@ -87,15 +87,19 @@ describe("Read receipt", () => {
 
     describe("sendReceipt", () => {
         it("sends a thread read receipt", async () => {
-            httpBackend.when(
-                "POST", encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
-                    $roomId: ROOM_ID,
-                    $receiptType: ReceiptType.Read,
-                    $eventId: threadEvent.getId()!,
-                }),
-            ).check((request) => {
-                expect(request.data.thread_id).toEqual(THREAD_ID);
-            }).respond(200, {});
+            httpBackend
+                .when(
+                    "POST",
+                    encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
+                        $roomId: ROOM_ID,
+                        $receiptType: ReceiptType.Read,
+                        $eventId: threadEvent.getId()!,
+                    }),
+                )
+                .check((request) => {
+                    expect(request.data.thread_id).toEqual(THREAD_ID);
+                })
+                .respond(200, {});
 
             mockServerSideSupport(client, ServerSupport.Stable);
             client.sendReceipt(threadEvent, ReceiptType.Read, {});
@@ -105,15 +109,19 @@ describe("Read receipt", () => {
         });
 
         it("sends an unthreaded receipt", async () => {
-            httpBackend.when(
-                "POST", encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
-                    $roomId: ROOM_ID,
-                    $receiptType: ReceiptType.Read,
-                    $eventId: threadEvent.getId()!,
-                }),
-            ).check((request) => {
-                expect(request.data.thread_id).toBeUndefined();
-            }).respond(200, {});
+            httpBackend
+                .when(
+                    "POST",
+                    encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
+                        $roomId: ROOM_ID,
+                        $receiptType: ReceiptType.Read,
+                        $eventId: threadEvent.getId()!,
+                    }),
+                )
+                .check((request) => {
+                    expect(request.data.thread_id).toBeUndefined();
+                })
+                .respond(200, {});
 
             mockServerSideSupport(client, ServerSupport.Stable);
             client.sendReadReceipt(threadEvent, ReceiptType.Read, true);
@@ -123,15 +131,19 @@ describe("Read receipt", () => {
         });
 
         it("sends a room read receipt", async () => {
-            httpBackend.when(
-                "POST", encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
-                    $roomId: ROOM_ID,
-                    $receiptType: ReceiptType.Read,
-                    $eventId: roomEvent.getId()!,
-                }),
-            ).check((request) => {
-                expect(request.data.thread_id).toEqual(MAIN_ROOM_TIMELINE);
-            }).respond(200, {});
+            httpBackend
+                .when(
+                    "POST",
+                    encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
+                        $roomId: ROOM_ID,
+                        $receiptType: ReceiptType.Read,
+                        $eventId: roomEvent.getId()!,
+                    }),
+                )
+                .check((request) => {
+                    expect(request.data.thread_id).toEqual(MAIN_ROOM_TIMELINE);
+                })
+                .respond(200, {});
 
             mockServerSideSupport(client, ServerSupport.Stable);
             client.sendReceipt(roomEvent, ReceiptType.Read, {});
@@ -141,15 +153,19 @@ describe("Read receipt", () => {
         });
 
         it("sends a room read receipt when there's no server support", async () => {
-            httpBackend.when(
-                "POST", encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
-                    $roomId: ROOM_ID,
-                    $receiptType: ReceiptType.Read,
-                    $eventId: threadEvent.getId()!,
-                }),
-            ).check((request) => {
-                expect(request.data.thread_id).toBeUndefined();
-            }).respond(200, {});
+            httpBackend
+                .when(
+                    "POST",
+                    encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
+                        $roomId: ROOM_ID,
+                        $receiptType: ReceiptType.Read,
+                        $eventId: threadEvent.getId()!,
+                    }),
+                )
+                .check((request) => {
+                    expect(request.data.thread_id).toBeUndefined();
+                })
+                .respond(200, {});
 
             mockServerSideSupport(client, ServerSupport.Unsupported);
             client.sendReceipt(threadEvent, ReceiptType.Read, {});
@@ -159,15 +175,19 @@ describe("Read receipt", () => {
         });
 
         it("sends a valid room read receipt even when body omitted", async () => {
-            httpBackend.when(
-                "POST", encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
-                    $roomId: ROOM_ID,
-                    $receiptType: ReceiptType.Read,
-                    $eventId: threadEvent.getId()!,
-                }),
-            ).check((request) => {
-                expect(request.data).toEqual({});
-            }).respond(200, {});
+            httpBackend
+                .when(
+                    "POST",
+                    encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
+                        $roomId: ROOM_ID,
+                        $receiptType: ReceiptType.Read,
+                        $eventId: threadEvent.getId()!,
+                    }),
+                )
+                .check((request) => {
+                    expect(request.data).toEqual({});
+                })
+                .respond(200, {});
 
             mockServerSideSupport(client, ServerSupport.Unsupported);
             client.sendReceipt(threadEvent, ReceiptType.Read, undefined);
diff --git a/spec/unit/realtime-callbacks.spec.ts b/spec/unit/realtime-callbacks.spec.ts
index dfbbfc9f77a..7cb1806a39c 100644
--- a/spec/unit/realtime-callbacks.spec.ts
+++ b/spec/unit/realtime-callbacks.spec.ts
@@ -19,14 +19,14 @@ import * as callbacks from "../../src/realtime-callbacks";
 let wallTime = 1234567890;
 jest.useFakeTimers().setSystemTime(wallTime);
 
-describe("realtime-callbacks", function() {
+describe("realtime-callbacks", function () {
     function tick(millis: number): void {
         wallTime += millis;
         jest.advanceTimersByTime(millis);
     }
 
-    describe("setTimeout", function() {
-        it("should call the callback after the timeout", function() {
+    describe("setTimeout", function () {
+        it("should call the callback after the timeout", function () {
             const callback = jest.fn();
             callbacks.setTimeout(callback, 100);
 
@@ -35,7 +35,7 @@ describe("realtime-callbacks", function() {
             expect(callback).toHaveBeenCalled();
         });
 
-        it("should default to a zero timeout", function() {
+        it("should default to a zero timeout", function () {
             const callback = jest.fn();
             callbacks.setTimeout(callback, 0);
 
@@ -44,16 +44,16 @@ describe("realtime-callbacks", function() {
             expect(callback).toHaveBeenCalled();
         });
 
-        it("should pass any parameters to the callback", function() {
+        it("should pass any parameters to the callback", function () {
             const callback = jest.fn();
             callbacks.setTimeout(callback, 0, "a", "b", "c");
             tick(0);
             expect(callback).toHaveBeenCalledWith("a", "b", "c");
         });
 
-        it("should set 'this' to the global object", function() {
+        it("should set 'this' to the global object", function () {
             let passed = false;
-            const callback = function(this: typeof global) {
+            const callback = function (this: typeof global) {
                 expect(this).toBe(global); // eslint-disable-line @typescript-eslint/no-invalid-this
                 expect(this.console).toBeTruthy(); // eslint-disable-line @typescript-eslint/no-invalid-this
                 passed = true;
@@ -63,7 +63,7 @@ describe("realtime-callbacks", function() {
             expect(passed).toBe(true);
         });
 
-        it("should handle timeouts of several seconds", function() {
+        it("should handle timeouts of several seconds", function () {
             const callback = jest.fn();
             callbacks.setTimeout(callback, 2000);
 
@@ -74,7 +74,7 @@ describe("realtime-callbacks", function() {
             expect(callback).toHaveBeenCalled();
         });
 
-        it("should call multiple callbacks in the right order", function() {
+        it("should call multiple callbacks in the right order", function () {
             const callback1 = jest.fn();
             const callback2 = jest.fn();
             const callback3 = jest.fn();
@@ -99,12 +99,12 @@ describe("realtime-callbacks", function() {
             expect(callback3).toHaveBeenCalled();
         });
 
-        it("should treat -ve timeouts the same as a zero timeout", function() {
+        it("should treat -ve timeouts the same as a zero timeout", function () {
             const callback1 = jest.fn();
             const callback2 = jest.fn();
 
             // check that cb1 is called before cb2
-            callback1.mockImplementation(function() {
+            callback1.mockImplementation(function () {
                 expect(callback2).not.toHaveBeenCalled();
             });
 
@@ -118,9 +118,9 @@ describe("realtime-callbacks", function() {
             expect(callback2).toHaveBeenCalled();
         });
 
-        it("should not get confused by chained calls", function() {
+        it("should not get confused by chained calls", function () {
             const callback2 = jest.fn();
-            const callback1 = jest.fn(function() {
+            const callback1 = jest.fn(function () {
                 callbacks.setTimeout(callback2, 0);
                 expect(callback2).not.toHaveBeenCalled();
             });
@@ -136,8 +136,8 @@ describe("realtime-callbacks", function() {
             expect(callback2).toHaveBeenCalled();
         });
 
-        it("should be immune to exceptions", function() {
-            const callback1 = jest.fn(function() {
+        it("should be immune to exceptions", function () {
+            const callback1 = jest.fn(function () {
                 throw new Error("prepare to die");
             });
             const callback2 = jest.fn();
@@ -152,8 +152,8 @@ describe("realtime-callbacks", function() {
         });
     });
 
-    describe("cancelTimeout", function() {
-        it("should cancel a pending timeout", function() {
+    describe("cancelTimeout", function () {
+        it("should cancel a pending timeout", function () {
             const callback = jest.fn();
             const k = callbacks.setTimeout(callback, 10);
             callbacks.clearTimeout(k);
@@ -161,7 +161,7 @@ describe("realtime-callbacks", function() {
             expect(callback).not.toHaveBeenCalled();
         });
 
-        it("should not affect sooner timeouts", function() {
+        it("should not affect sooner timeouts", function () {
             const callback1 = jest.fn();
             const callback2 = jest.fn();
 
diff --git a/spec/unit/relations.spec.ts b/spec/unit/relations.spec.ts
index 022f8c0c503..91b77dd1212 100644
--- a/spec/unit/relations.spec.ts
+++ b/spec/unit/relations.spec.ts
@@ -20,22 +20,22 @@ import { Room } from "../../src/models/room";
 import { Relations } from "../../src/models/relations";
 import { TestClient } from "../TestClient";
 
-describe("Relations", function() {
-    it("should deduplicate annotations", function() {
+describe("Relations", function () {
+    it("should deduplicate annotations", function () {
         const room = new Room("room123", null!, null!);
         const relations = new Relations("m.annotation", "m.reaction", room);
 
         // Create an instance of an annotation
         const eventData = {
-            "sender": "@bob:example.com",
-            "type": "m.reaction",
-            "event_id": "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
-            "room_id": "!pzVjCQSoQPpXQeHpmK:example.com",
-            "content": {
+            sender: "@bob:example.com",
+            type: "m.reaction",
+            event_id: "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
+            room_id: "!pzVjCQSoQPpXQeHpmK:example.com",
+            content: {
                 "m.relates_to": {
-                    "event_id": "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
-                    "key": "👍️",
-                    "rel_type": "m.annotation",
+                    event_id: "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
+                    key: "👍️",
+                    rel_type: "m.annotation",
                 },
             },
         };
@@ -75,24 +75,24 @@ describe("Relations", function() {
         }
     });
 
-    it("should emit created regardless of ordering", async function() {
+    it("should emit created regardless of ordering", async function () {
         const targetEvent = new MatrixEvent({
-            "sender": "@bob:example.com",
-            "type": "m.room.message",
-            "event_id": "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
-            "room_id": "!pzVjCQSoQPpXQeHpmK:example.com",
-            "content": {},
+            sender: "@bob:example.com",
+            type: "m.room.message",
+            event_id: "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
+            room_id: "!pzVjCQSoQPpXQeHpmK:example.com",
+            content: {},
         });
         const relationEvent = new MatrixEvent({
-            "sender": "@bob:example.com",
-            "type": "m.reaction",
-            "event_id": "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
-            "room_id": "!pzVjCQSoQPpXQeHpmK:example.com",
-            "content": {
+            sender: "@bob:example.com",
+            type: "m.reaction",
+            event_id: "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
+            room_id: "!pzVjCQSoQPpXQeHpmK:example.com",
+            content: {
                 "m.relates_to": {
-                    "event_id": "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
-                    "key": "👍️",
-                    "rel_type": "m.annotation",
+                    event_id: "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
+                    key: "👍️",
+                    rel_type: "m.annotation",
                 },
             },
         });
@@ -100,7 +100,7 @@ describe("Relations", function() {
         // Add the target event first, then the relation event
         {
             const room = new Room("room123", null!, null!);
-            const relationsCreated = new Promise(resolve => {
+            const relationsCreated = new Promise((resolve) => {
                 targetEvent.once(MatrixEventEvent.RelationsCreated, resolve);
             });
 
@@ -114,7 +114,7 @@ describe("Relations", function() {
         // Add the relation event first, then the target event
         {
             const room = new Room("room123", null!, null!);
-            const relationsCreated = new Promise(resolve => {
+            const relationsCreated = new Promise((resolve) => {
                 targetEvent.once(MatrixEventEvent.RelationsCreated, resolve);
             });
 
@@ -141,31 +141,31 @@ describe("Relations", function() {
 
         // Create an instance of a state event with rel_type m.replace
         const originalTopic = new MatrixEvent({
-            "sender": userId,
-            "type": "m.room.topic",
-            "event_id": "$orig",
-            "room_id": room.roomId,
-            "content": {
-                "topic": "orig",
+            sender: userId,
+            type: "m.room.topic",
+            event_id: "$orig",
+            room_id: room.roomId,
+            content: {
+                topic: "orig",
             },
-            "state_key": "",
+            state_key: "",
         });
         const badlyEditedTopic = new MatrixEvent({
-            "sender": userId,
-            "type": "m.room.topic",
-            "event_id": "$orig",
-            "room_id": room.roomId,
-            "content": {
+            sender: userId,
+            type: "m.room.topic",
+            event_id: "$orig",
+            room_id: room.roomId,
+            content: {
                 "topic": "topic",
                 "m.new_content": {
-                    "topic": "edit",
+                    topic: "edit",
                 },
                 "m.relates_to": {
-                    "event_id": "$orig",
-                    "rel_type": "m.replace",
+                    event_id: "$orig",
+                    rel_type: "m.replace",
                 },
             },
-            "state_key": "",
+            state_key: "",
         });
 
         await relations.setTargetEvent(originalTopic);
@@ -188,14 +188,14 @@ describe("Relations", function() {
 
         // Create an instance of an annotation
         const eventData = {
-            "sender": "@bob:example.com",
-            "type": "m.room.message",
-            "event_id": "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
-            "room_id": "!pzVjCQSoQPpXQeHpmK:example.com",
-            "content": {
+            sender: "@bob:example.com",
+            type: "m.room.message",
+            event_id: "$cZ1biX33ENJqIm00ks0W_hgiO_6CHrsAc3ZQrnLeNTw",
+            room_id: "!pzVjCQSoQPpXQeHpmK:example.com",
+            content: {
                 "m.relates_to": {
-                    "event_id": "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
-                    "rel_type": "m.replace",
+                    event_id: "$2s4yYpEkVQrPglSCSqB_m6E8vDhWsg0yFNyOJdVIb_o",
+                    rel_type: "m.replace",
                 },
             },
         };
diff --git a/spec/unit/rendezvous/DummyTransport.ts b/spec/unit/rendezvous/DummyTransport.ts
index 617b0380c71..caa8eaa0d01 100644
--- a/spec/unit/rendezvous/DummyTransport.ts
+++ b/spec/unit/rendezvous/DummyTransport.ts
@@ -21,7 +21,7 @@ import {
     RendezvousTransport,
     RendezvousTransportDetails,
 } from "../../../src/rendezvous";
-import { sleep } from '../../../src/utils';
+import { sleep } from "../../../src/utils";
 
 export class DummyTransport<D extends RendezvousTransportDetails, T> implements RendezvousTransport<T> {
     otherParty?: DummyTransport<D, T>;
@@ -41,8 +41,9 @@ export class DummyTransport<D extends RendezvousTransportDetails, T> implements
 
     async send(data: T): Promise<void> {
         logger.info(
-            `[${this.name}] => [${this.otherParty?.name}] Attempting to send data: ${
-                JSON.stringify(data)} where etag matches ${this.etag}`,
+            `[${this.name}] => [${this.otherParty?.name}] Attempting to send data: ${JSON.stringify(
+                data,
+            )} where etag matches ${this.etag}`,
         );
         // eslint-disable-next-line no-constant-condition
         while (!this.cancelled) {
@@ -68,12 +69,13 @@ export class DummyTransport<D extends RendezvousTransportDetails, T> implements
                 this.lastEtagReceived = this.etag;
                 logger.info(
                     `[${this.otherParty?.name}] => [${this.name}] Received data: ` +
-                    `${JSON.stringify(this.data)} with etag ${this.etag}`,
+                        `${JSON.stringify(this.data)} with etag ${this.etag}`,
                 );
                 return this.data;
             }
-            logger.info(`[${this.name}] Sleeping to retry receive after etag ${
-                this.lastEtagReceived} as remote is ${this.etag}`);
+            logger.info(
+                `[${this.name}] Sleeping to retry receive after etag ${this.lastEtagReceived} as remote is ${this.etag}`,
+            );
             await sleep(250);
         }
 
diff --git a/spec/unit/rendezvous/ecdh.spec.ts b/spec/unit/rendezvous/ecdh.spec.ts
index b8f40b52c3b..f0b2daa1da3 100644
--- a/spec/unit/rendezvous/ecdh.spec.ts
+++ b/spec/unit/rendezvous/ecdh.spec.ts
@@ -14,25 +14,25 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import '../../olm-loader';
+import "../../olm-loader";
 import { RendezvousFailureReason, RendezvousIntent } from "../../../src/rendezvous";
-import { MSC3903ECDHPayload, MSC3903ECDHv1RendezvousChannel } from '../../../src/rendezvous/channels';
-import { decodeBase64 } from '../../../src/crypto/olmlib';
-import { DummyTransport } from './DummyTransport';
+import { MSC3903ECDHPayload, MSC3903ECDHv1RendezvousChannel } from "../../../src/rendezvous/channels";
+import { decodeBase64 } from "../../../src/crypto/olmlib";
+import { DummyTransport } from "./DummyTransport";
 
 function makeTransport(name: string) {
-    return new DummyTransport<any, MSC3903ECDHPayload>(name, { type: 'dummy' });
+    return new DummyTransport<any, MSC3903ECDHPayload>(name, { type: "dummy" });
 }
 
-describe('ECDHv1', function() {
-    beforeAll(async function() {
+describe("ECDHv1", function () {
+    beforeAll(async function () {
         await global.Olm.init();
     });
 
-    describe('with crypto', () => {
-        it("initiator wants to sign in", async function() {
-            const aliceTransport = makeTransport('Alice');
-            const bobTransport = makeTransport('Bob');
+    describe("with crypto", () => {
+        it("initiator wants to sign in", async function () {
+            const aliceTransport = makeTransport("Alice");
+            const bobTransport = makeTransport("Bob");
             aliceTransport.otherParty = bobTransport;
             bobTransport.otherParty = aliceTransport;
 
@@ -55,9 +55,9 @@ describe('ECDHv1', function() {
             await bob.cancel(RendezvousFailureReason.Unknown);
         });
 
-        it("initiator wants to reciprocate", async function() {
-            const aliceTransport = makeTransport('Alice');
-            const bobTransport = makeTransport('Bob');
+        it("initiator wants to reciprocate", async function () {
+            const aliceTransport = makeTransport("Alice");
+            const bobTransport = makeTransport("Bob");
             aliceTransport.otherParty = bobTransport;
             bobTransport.otherParty = aliceTransport;
 
@@ -80,9 +80,9 @@ describe('ECDHv1', function() {
             await bob.cancel(RendezvousFailureReason.Unknown);
         });
 
-        it("double connect", async function() {
-            const aliceTransport = makeTransport('Alice');
-            const bobTransport = makeTransport('Bob');
+        it("double connect", async function () {
+            const aliceTransport = makeTransport("Alice");
+            const bobTransport = makeTransport("Bob");
             aliceTransport.otherParty = bobTransport;
             bobTransport.otherParty = aliceTransport;
 
@@ -102,9 +102,9 @@ describe('ECDHv1', function() {
             await bob.cancel(RendezvousFailureReason.Unknown);
         });
 
-        it("closed", async function() {
-            const aliceTransport = makeTransport('Alice');
-            const bobTransport = makeTransport('Bob');
+        it("closed", async function () {
+            const aliceTransport = makeTransport("Alice");
+            const bobTransport = makeTransport("Bob");
             aliceTransport.otherParty = bobTransport;
             bobTransport.otherParty = aliceTransport;
 
@@ -128,9 +128,9 @@ describe('ECDHv1', function() {
             await bob.cancel(RendezvousFailureReason.Unknown);
         });
 
-        it("require ciphertext", async function() {
-            const aliceTransport = makeTransport('Alice');
-            const bobTransport = makeTransport('Bob');
+        it("require ciphertext", async function () {
+            const aliceTransport = makeTransport("Alice");
+            const bobTransport = makeTransport("Bob");
             aliceTransport.otherParty = bobTransport;
             bobTransport.otherParty = aliceTransport;
 
@@ -152,9 +152,9 @@ describe('ECDHv1', function() {
             await bob.cancel(RendezvousFailureReason.Unknown);
         });
 
-        it("ciphertext before set up", async function() {
-            const aliceTransport = makeTransport('Alice');
-            const bobTransport = makeTransport('Bob');
+        it("ciphertext before set up", async function () {
+            const aliceTransport = makeTransport("Alice");
+            const bobTransport = makeTransport("Bob");
             aliceTransport.otherParty = bobTransport;
             bobTransport.otherParty = aliceTransport;
 
diff --git a/spec/unit/rendezvous/rendezvous.spec.ts b/spec/unit/rendezvous/rendezvous.spec.ts
index bca7385982b..8586040a626 100644
--- a/spec/unit/rendezvous/rendezvous.spec.ts
+++ b/spec/unit/rendezvous/rendezvous.spec.ts
@@ -16,13 +16,8 @@ limitations under the License.
 
 import MockHttpBackend from "matrix-mock-request";
 
-import '../../olm-loader';
-import {
-    MSC3906Rendezvous,
-    RendezvousCode,
-    RendezvousFailureReason,
-    RendezvousIntent,
-} from "../../../src/rendezvous";
+import "../../olm-loader";
+import { MSC3906Rendezvous, RendezvousCode, RendezvousFailureReason, RendezvousIntent } from "../../../src/rendezvous";
 import {
     ECDHv1RendezvousCode,
     MSC3903ECDHPayload,
@@ -46,7 +41,11 @@ function makeMockClient(opts: {
     msc3886Enabled: boolean;
     devices?: Record<string, Partial<DeviceInfo>>;
     verificationFunction?: (
-        userId: string, deviceId: string, verified: boolean, blocked: boolean, known: boolean,
+        userId: string,
+        deviceId: string,
+        verified: boolean,
+        blocked: boolean,
+        known: boolean,
     ) => void;
     crossSigningIds?: Record<string, string>;
 }): MatrixClient {
@@ -59,9 +58,15 @@ function makeMockClient(opts: {
                 },
             };
         },
-        getUserId() { return opts.userId; },
-        getDeviceId() { return opts.deviceId; },
-        getDeviceEd25519Key() { return opts.deviceKey; },
+        getUserId() {
+            return opts.userId;
+        },
+        getDeviceId() {
+            return opts.deviceId;
+        },
+        getDeviceEd25519Key() {
+            return opts.deviceKey;
+        },
         baseUrl: "https://example.com",
         crypto: {
             getStoredDevice(userId: string, deviceId: string) {
@@ -77,12 +82,12 @@ function makeMockClient(opts: {
     } as unknown as MatrixClient;
 }
 
-function makeTransport(name: string, uri = 'https://test.rz/123456') {
-    return new DummyTransport<any, MSC3903ECDHPayload>(name, { type: 'http.v1', uri });
+function makeTransport(name: string, uri = "https://test.rz/123456") {
+    return new DummyTransport<any, MSC3903ECDHPayload>(name, { type: "http.v1", uri });
 }
 
-describe("Rendezvous", function() {
-    beforeAll(async function() {
+describe("Rendezvous", function () {
+    beforeAll(async function () {
         await global.Olm.init();
     });
 
@@ -90,17 +95,17 @@ describe("Rendezvous", function() {
     let fetchFn: typeof global.fetch;
     let transports: DummyTransport<any, MSC3903ECDHPayload>[];
 
-    beforeEach(function() {
+    beforeEach(function () {
         httpBackend = new MockHttpBackend();
         fetchFn = httpBackend.fetchFn as typeof global.fetch;
         transports = [];
     });
 
-    afterEach(function() {
-        transports.forEach(x => x.cleanup());
+    afterEach(function () {
+        transports.forEach((x) => x.cleanup());
     });
 
-    it("generate and cancel", async function() {
+    it("generate and cancel", async function () {
         const alice = makeMockClient({
             userId: "@alice:example.com",
             deviceId: "DEVICEID",
@@ -127,11 +132,11 @@ describe("Rendezvous", function() {
         expect(aliceRz.code).toBeUndefined();
 
         const codePromise = aliceRz.generateCode();
-        await httpBackend.flush('');
+        await httpBackend.flush("");
 
         await aliceRz.generateCode();
 
-        expect(typeof aliceRz.code).toBe('string');
+        expect(typeof aliceRz.code).toBe("string");
 
         await codePromise;
 
@@ -140,8 +145,9 @@ describe("Rendezvous", function() {
         expect(code.intent).toEqual(RendezvousIntent.RECIPROCATE_LOGIN_ON_EXISTING_DEVICE);
         expect(code.rendezvous?.algorithm).toEqual("org.matrix.msc3903.rendezvous.v1.curve25519-aes-sha256");
         expect(code.rendezvous?.transport.type).toEqual("org.matrix.msc3886.http.v1");
-        expect((code.rendezvous?.transport as MSC3886SimpleHttpRendezvousTransportDetails).uri)
-            .toEqual("https://fallbackserver/rz/123");
+        expect((code.rendezvous?.transport as MSC3886SimpleHttpRendezvousTransportDetails).uri).toEqual(
+            "https://fallbackserver/rz/123",
+        );
 
         httpBackend.when("DELETE", "https://fallbackserver/rz").response = {
             body: null,
@@ -152,7 +158,7 @@ describe("Rendezvous", function() {
         };
 
         const cancelPromise = aliceRz.cancel(RendezvousFailureReason.UserDeclined);
-        await httpBackend.flush('');
+        await httpBackend.flush("");
         expect(cancelPromise).resolves.toBeUndefined();
         httpBackend.verifyNoOutstandingExpectation();
         httpBackend.verifyNoOutstandingRequests();
@@ -160,9 +166,9 @@ describe("Rendezvous", function() {
         await aliceRz.close();
     });
 
-    it("no protocols", async function() {
-        const aliceTransport = makeTransport('Alice');
-        const bobTransport = makeTransport('Bob', 'https://test.rz/999999');
+    it("no protocols", async function () {
+        const aliceTransport = makeTransport("Alice");
+        const bobTransport = makeTransport("Bob", "https://test.rz/999999");
         transports.push(aliceTransport, bobTransport);
         aliceTransport.otherParty = bobTransport;
         bobTransport.otherParty = aliceTransport;
@@ -199,14 +205,14 @@ describe("Rendezvous", function() {
             // await bobEcdh.send({ type: 'm.login.progress', intent: RendezvousIntent.LOGIN_ON_NEW_DEVICE });
 
             // wait for protocols
-            logger.info('Bob waiting for protocols');
+            logger.info("Bob waiting for protocols");
             const protocols = await bobEcdh.receive();
 
             logger.info(`Bob protocols: ${JSON.stringify(protocols)}`);
 
             expect(protocols).toEqual({
-                type: 'm.login.finish',
-                outcome: 'unsupported',
+                type: "m.login.finish",
+                outcome: "unsupported",
             });
         })();
 
@@ -214,9 +220,9 @@ describe("Rendezvous", function() {
         await bobStartPromise;
     });
 
-    it("new device declines protocol", async function() {
-        const aliceTransport = makeTransport('Alice', 'https://test.rz/123456');
-        const bobTransport = makeTransport('Bob', 'https://test.rz/999999');
+    it("new device declines protocol", async function () {
+        const aliceTransport = makeTransport("Alice", "https://test.rz/123456");
+        const bobTransport = makeTransport("Bob", "https://test.rz/999999");
         transports.push(aliceTransport, bobTransport);
         aliceTransport.otherParty = bobTransport;
         bobTransport.otherParty = aliceTransport;
@@ -253,17 +259,17 @@ describe("Rendezvous", function() {
             // await bobEcdh.send({ type: 'm.login.progress', intent: RendezvousIntent.LOGIN_ON_NEW_DEVICE });
 
             // wait for protocols
-            logger.info('Bob waiting for protocols');
+            logger.info("Bob waiting for protocols");
             const protocols = await bobEcdh.receive();
 
             logger.info(`Bob protocols: ${JSON.stringify(protocols)}`);
 
             expect(protocols).toEqual({
-                type: 'm.login.progress',
-                protocols: ['org.matrix.msc3906.login_token'],
+                type: "m.login.progress",
+                protocols: ["org.matrix.msc3906.login_token"],
             });
 
-            await bobEcdh.send({ type: 'm.login.finish', outcome: 'unsupported' });
+            await bobEcdh.send({ type: "m.login.finish", outcome: "unsupported" });
         })();
 
         await aliceStartProm;
@@ -272,9 +278,9 @@ describe("Rendezvous", function() {
         expect(aliceOnFailure).toHaveBeenCalledWith(RendezvousFailureReason.UnsupportedAlgorithm);
     });
 
-    it("new device declines protocol", async function() {
-        const aliceTransport = makeTransport('Alice', 'https://test.rz/123456');
-        const bobTransport = makeTransport('Bob', 'https://test.rz/999999');
+    it("new device declines protocol", async function () {
+        const aliceTransport = makeTransport("Alice", "https://test.rz/123456");
+        const bobTransport = makeTransport("Bob", "https://test.rz/999999");
         transports.push(aliceTransport, bobTransport);
         aliceTransport.otherParty = bobTransport;
         bobTransport.otherParty = aliceTransport;
@@ -311,17 +317,17 @@ describe("Rendezvous", function() {
             // await bobEcdh.send({ type: 'm.login.progress', intent: RendezvousIntent.LOGIN_ON_NEW_DEVICE });
 
             // wait for protocols
-            logger.info('Bob waiting for protocols');
+            logger.info("Bob waiting for protocols");
             const protocols = await bobEcdh.receive();
 
             logger.info(`Bob protocols: ${JSON.stringify(protocols)}`);
 
             expect(protocols).toEqual({
-                type: 'm.login.progress',
-                protocols: ['org.matrix.msc3906.login_token'],
+                type: "m.login.progress",
+                protocols: ["org.matrix.msc3906.login_token"],
             });
 
-            await bobEcdh.send({ type: 'm.login.progress', protocol: 'bad protocol' });
+            await bobEcdh.send({ type: "m.login.progress", protocol: "bad protocol" });
         })();
 
         await aliceStartProm;
@@ -330,9 +336,9 @@ describe("Rendezvous", function() {
         expect(aliceOnFailure).toHaveBeenCalledWith(RendezvousFailureReason.UnsupportedAlgorithm);
     });
 
-    it("decline on existing device", async function() {
-        const aliceTransport = makeTransport('Alice', 'https://test.rz/123456');
-        const bobTransport = makeTransport('Bob', 'https://test.rz/999999');
+    it("decline on existing device", async function () {
+        const aliceTransport = makeTransport("Alice", "https://test.rz/123456");
+        const bobTransport = makeTransport("Bob", "https://test.rz/999999");
         transports.push(aliceTransport, bobTransport);
         aliceTransport.otherParty = bobTransport;
         bobTransport.otherParty = aliceTransport;
@@ -369,17 +375,17 @@ describe("Rendezvous", function() {
             // await bobEcdh.send({ type: 'm.login.progress', intent: RendezvousIntent.LOGIN_ON_NEW_DEVICE });
 
             // wait for protocols
-            logger.info('Bob waiting for protocols');
+            logger.info("Bob waiting for protocols");
             const protocols = await bobEcdh.receive();
 
             logger.info(`Bob protocols: ${JSON.stringify(protocols)}`);
 
             expect(protocols).toEqual({
-                type: 'm.login.progress',
-                protocols: ['org.matrix.msc3906.login_token'],
+                type: "m.login.progress",
+                protocols: ["org.matrix.msc3906.login_token"],
             });
 
-            await bobEcdh.send({ type: 'm.login.progress', protocol: 'org.matrix.msc3906.login_token' });
+            await bobEcdh.send({ type: "m.login.progress", protocol: "org.matrix.msc3906.login_token" });
         })();
 
         await aliceStartProm;
@@ -387,12 +393,12 @@ describe("Rendezvous", function() {
 
         await aliceRz.declineLoginOnExistingDevice();
         const loginToken = await bobEcdh.receive();
-        expect(loginToken).toEqual({ type: 'm.login.finish', outcome: 'declined' });
+        expect(loginToken).toEqual({ type: "m.login.finish", outcome: "declined" });
     });
 
-    it("approve on existing device + no verification", async function() {
-        const aliceTransport = makeTransport('Alice', 'https://test.rz/123456');
-        const bobTransport = makeTransport('Bob', 'https://test.rz/999999');
+    it("approve on existing device + no verification", async function () {
+        const aliceTransport = makeTransport("Alice", "https://test.rz/123456");
+        const bobTransport = makeTransport("Bob", "https://test.rz/999999");
         transports.push(aliceTransport, bobTransport);
         aliceTransport.otherParty = bobTransport;
         bobTransport.otherParty = aliceTransport;
@@ -429,17 +435,17 @@ describe("Rendezvous", function() {
             // await bobEcdh.send({ type: 'm.login.progress', intent: RendezvousIntent.LOGIN_ON_NEW_DEVICE });
 
             // wait for protocols
-            logger.info('Bob waiting for protocols');
+            logger.info("Bob waiting for protocols");
             const protocols = await bobEcdh.receive();
 
             logger.info(`Bob protocols: ${JSON.stringify(protocols)}`);
 
             expect(protocols).toEqual({
-                type: 'm.login.progress',
-                protocols: ['org.matrix.msc3906.login_token'],
+                type: "m.login.progress",
+                protocols: ["org.matrix.msc3906.login_token"],
             });
 
-            await bobEcdh.send({ type: 'm.login.progress', protocol: 'org.matrix.msc3906.login_token' });
+            await bobEcdh.send({ type: "m.login.progress", protocol: "org.matrix.msc3906.login_token" });
         })();
 
         await aliceStartProm;
@@ -449,8 +455,8 @@ describe("Rendezvous", function() {
 
         const bobCompleteProm = (async () => {
             const loginToken = await bobEcdh.receive();
-            expect(loginToken).toEqual({ type: 'm.login.progress', login_token: 'token', homeserver: alice.baseUrl });
-            await bobEcdh.send({ type: 'm.login.finish', outcome: 'success' });
+            expect(loginToken).toEqual({ type: "m.login.progress", login_token: "token", homeserver: alice.baseUrl });
+            await bobEcdh.send({ type: "m.login.finish", outcome: "success" });
         })();
 
         await confirmProm;
@@ -458,8 +464,8 @@ describe("Rendezvous", function() {
     });
 
     async function completeLogin(devices: Record<string, Partial<DeviceInfo>>) {
-        const aliceTransport = makeTransport('Alice', 'https://test.rz/123456');
-        const bobTransport = makeTransport('Bob', 'https://test.rz/999999');
+        const aliceTransport = makeTransport("Alice", "https://test.rz/123456");
+        const bobTransport = makeTransport("Bob", "https://test.rz/999999");
         transports.push(aliceTransport, bobTransport);
         aliceTransport.otherParty = bobTransport;
         bobTransport.otherParty = aliceTransport;
@@ -473,10 +479,10 @@ describe("Rendezvous", function() {
             msc3882Enabled: true,
             msc3886Enabled: false,
             devices,
-            deviceKey: 'aaaa',
+            deviceKey: "aaaa",
             verificationFunction: aliceVerification,
             crossSigningIds: {
-                master: 'mmmmm',
+                master: "mmmmm",
             },
         });
         const aliceEcdh = new MSC3903ECDHv1RendezvousChannel(aliceTransport, undefined, aliceOnFailure);
@@ -503,17 +509,17 @@ describe("Rendezvous", function() {
             // await bobEcdh.send({ type: 'm.login.progress', intent: RendezvousIntent.LOGIN_ON_NEW_DEVICE });
 
             // wait for protocols
-            logger.info('Bob waiting for protocols');
+            logger.info("Bob waiting for protocols");
             const protocols = await bobEcdh.receive();
 
             logger.info(`Bob protocols: ${JSON.stringify(protocols)}`);
 
             expect(protocols).toEqual({
-                type: 'm.login.progress',
-                protocols: ['org.matrix.msc3906.login_token'],
+                type: "m.login.progress",
+                protocols: ["org.matrix.msc3906.login_token"],
             });
 
-            await bobEcdh.send({ type: 'm.login.progress', protocol: 'org.matrix.msc3906.login_token' });
+            await bobEcdh.send({ type: "m.login.progress", protocol: "org.matrix.msc3906.login_token" });
         })();
 
         await aliceStartProm;
@@ -523,11 +529,11 @@ describe("Rendezvous", function() {
 
         const bobLoginProm = (async () => {
             const loginToken = await bobEcdh.receive();
-            expect(loginToken).toEqual({ type: 'm.login.progress', login_token: 'token', homeserver: alice.baseUrl });
-            await bobEcdh.send({ type: 'm.login.finish', outcome: 'success', device_id: 'BOB', device_key: 'bbbb' });
+            expect(loginToken).toEqual({ type: "m.login.progress", login_token: "token", homeserver: alice.baseUrl });
+            await bobEcdh.send({ type: "m.login.finish", outcome: "success", device_id: "BOB", device_key: "bbbb" });
         })();
 
-        expect(await confirmProm).toEqual('BOB');
+        expect(await confirmProm).toEqual("BOB");
         await bobLoginProm;
 
         return {
@@ -539,7 +545,7 @@ describe("Rendezvous", function() {
         };
     }
 
-    it("approve on existing device + verification", async function() {
+    it("approve on existing device + verification", async function () {
         const { bobEcdh, aliceRz } = await completeLogin({
             BOB: {
                 getFingerprint: () => "bbbb",
@@ -550,11 +556,11 @@ describe("Rendezvous", function() {
         const bobVerifyProm = (async () => {
             const verified = await bobEcdh.receive();
             expect(verified).toEqual({
-                type: 'm.login.finish',
-                outcome: 'verified',
-                verifying_device_id: 'ALICE',
-                verifying_device_key: 'aaaa',
-                master_key: 'mmmmm',
+                type: "m.login.finish",
+                outcome: "verified",
+                verifying_device_id: "ALICE",
+                verifying_device_key: "aaaa",
+                master_key: "mmmmm",
             });
         })();
 
@@ -562,12 +568,12 @@ describe("Rendezvous", function() {
         await bobVerifyProm;
     });
 
-    it("device not online within timeout", async function() {
+    it("device not online within timeout", async function () {
         const { aliceRz } = await completeLogin({});
         expect(aliceRz.verifyNewDeviceOnExistingDevice(1000)).rejects.toThrowError();
     });
 
-    it("device appears online within timeout", async function() {
+    it("device appears online within timeout", async function () {
         const devices: Record<string, Partial<DeviceInfo>> = {};
         const { aliceRz } = await completeLogin(devices);
         // device appears after 1 second
@@ -579,7 +585,7 @@ describe("Rendezvous", function() {
         await aliceRz.verifyNewDeviceOnExistingDevice(2000);
     });
 
-    it("device appears online after timeout", async function() {
+    it("device appears online after timeout", async function () {
         const devices: Record<string, Partial<DeviceInfo>> = {};
         const { aliceRz } = await completeLogin(devices);
         // device appears after 1 second
@@ -591,7 +597,7 @@ describe("Rendezvous", function() {
         expect(aliceRz.verifyNewDeviceOnExistingDevice(1000)).rejects.toThrowError();
     });
 
-    it("mismatched device key", async function() {
+    it("mismatched device key", async function () {
         const { aliceRz } = await completeLogin({
             BOB: {
                 getFingerprint: () => "XXXX",
diff --git a/spec/unit/rendezvous/simpleHttpTransport.spec.ts b/spec/unit/rendezvous/simpleHttpTransport.spec.ts
index 9542cb1d1cd..69a38cbdeb5 100644
--- a/spec/unit/rendezvous/simpleHttpTransport.spec.ts
+++ b/spec/unit/rendezvous/simpleHttpTransport.spec.ts
@@ -20,13 +20,17 @@ import type { MatrixClient } from "../../../src";
 import { RendezvousFailureReason } from "../../../src/rendezvous";
 import { MSC3886SimpleHttpRendezvousTransport } from "../../../src/rendezvous/transports";
 
-function makeMockClient(opts: { userId: string, deviceId: string, msc3886Enabled: boolean}): MatrixClient {
+function makeMockClient(opts: { userId: string; deviceId: string; msc3886Enabled: boolean }): MatrixClient {
     return {
         doesServerSupportUnstableFeature(feature: string) {
             return Promise.resolve(opts.msc3886Enabled && feature === "org.matrix.msc3886");
         },
-        getUserId() { return opts.userId; },
-        getDeviceId() { return opts.deviceId; },
+        getUserId() {
+            return opts.userId;
+        },
+        getDeviceId() {
+            return opts.deviceId;
+        },
         requestLoginToken() {
             return Promise.resolve({ login_token: "token" });
         },
@@ -34,11 +38,11 @@ function makeMockClient(opts: { userId: string, deviceId: string, msc3886Enabled
     } as unknown as MatrixClient;
 }
 
-describe("SimpleHttpRendezvousTransport", function() {
+describe("SimpleHttpRendezvousTransport", function () {
     let httpBackend: MockHttpBackend;
     let fetchFn: typeof global.fetch;
 
-    beforeEach(function() {
+    beforeEach(function () {
         httpBackend = new MockHttpBackend();
         fetchFn = httpBackend.fetchFn as typeof global.fetch;
     });
@@ -51,10 +55,11 @@ describe("SimpleHttpRendezvousTransport", function() {
     ) {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({ client, fallbackRzServer, fetchFn });
-        { // initial POST
-            const expectedPostLocation = msc3886Enabled ?
-                `${client.baseUrl}/_matrix/client/unstable/org.matrix.msc3886/rendezvous` :
-                fallbackRzServer;
+        {
+            // initial POST
+            const expectedPostLocation = msc3886Enabled
+                ? `${client.baseUrl}/_matrix/client/unstable/org.matrix.msc3886/rendezvous`
+                : fallbackRzServer;
 
             const prom = simpleHttpTransport.send({});
             httpBackend.when("POST", expectedPostLocation).response = {
@@ -66,13 +71,14 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             await prom;
         }
         const details = await simpleHttpTransport.details();
         expect(details.uri).toBe(expectedFinalLocation);
 
-        { // first GET without etag
+        {
+            // first GET without etag
             const prom = simpleHttpTransport.receive();
             httpBackend.when("GET", expectedFinalLocation).response = {
                 body: {},
@@ -83,19 +89,19 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             expect(await prom).toEqual({});
             httpBackend.verifyNoOutstandingRequests();
             httpBackend.verifyNoOutstandingExpectation();
         }
     }
-    it("should throw an error when no server available", function() {
+    it("should throw an error when no server available", function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({ client, fetchFn });
         expect(simpleHttpTransport.send({})).rejects.toThrowError("Invalid rendezvous URI");
     });
 
-    it("POST to fallback server", async function() {
+    it("POST to fallback server", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
@@ -112,11 +118,11 @@ describe("SimpleHttpRendezvousTransport", function() {
                 },
             },
         };
-        await httpBackend.flush('');
+        await httpBackend.flush("");
         expect(await prom).toStrictEqual(undefined);
     });
 
-    it("POST with no location", async function() {
+    it("POST with no location", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
@@ -132,19 +138,14 @@ describe("SimpleHttpRendezvousTransport", function() {
                 headers: {},
             },
         };
-        await httpBackend.flush('');
+        await httpBackend.flush("");
     });
 
-    it("POST with absolute path response", async function() {
-        await postAndCheckLocation(
-            false,
-            "https://fallbackserver/rz",
-            "/123",
-            "https://fallbackserver/123",
-        );
+    it("POST with absolute path response", async function () {
+        await postAndCheckLocation(false, "https://fallbackserver/rz", "/123", "https://fallbackserver/123");
     });
 
-    it("POST to built-in MSC3886 implementation", async function() {
+    it("POST to built-in MSC3886 implementation", async function () {
         await postAndCheckLocation(
             true,
             "https://fallbackserver/rz",
@@ -153,7 +154,7 @@ describe("SimpleHttpRendezvousTransport", function() {
         );
     });
 
-    it("POST with relative path response including parent", async function() {
+    it("POST with relative path response including parent", async function () {
         await postAndCheckLocation(
             false,
             "https://fallbackserver/rz/abc",
@@ -162,7 +163,7 @@ describe("SimpleHttpRendezvousTransport", function() {
         );
     });
 
-    it("POST with relative path response including parent", async function() {
+    it("POST with relative path response including parent", async function () {
         await postAndCheckLocation(
             false,
             "https://fallbackserver/rz/abc",
@@ -171,7 +172,7 @@ describe("SimpleHttpRendezvousTransport", function() {
         );
     });
 
-    it("POST to follow 307 to other server", async function() {
+    it("POST to follow 307 to other server", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
@@ -198,18 +199,19 @@ describe("SimpleHttpRendezvousTransport", function() {
                 },
             },
         };
-        await httpBackend.flush('');
+        await httpBackend.flush("");
         expect(await prom).toStrictEqual(undefined);
     });
 
-    it("POST and GET", async function() {
+    it("POST and GET", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
             fallbackRzServer: "https://fallbackserver/rz",
             fetchFn,
         });
-        { // initial POST
+        {
+            // initial POST
             const prom = simpleHttpTransport.send({ foo: "baa" });
             httpBackend.when("POST", "https://fallbackserver/rz").check(({ headers, data }) => {
                 expect(headers["content-type"]).toEqual("application/json");
@@ -223,10 +225,11 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             expect(await prom).toStrictEqual(undefined);
         }
-        { // first GET without etag
+        {
+            // first GET without etag
             const prom = simpleHttpTransport.receive();
             httpBackend.when("GET", "https://fallbackserver/rz/123").response = {
                 body: { foo: "baa" },
@@ -238,10 +241,11 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             expect(await prom).toEqual({ foo: "baa" });
         }
-        { // subsequent GET which should have etag from previous request
+        {
+            // subsequent GET which should have etag from previous request
             const prom = simpleHttpTransport.receive();
             httpBackend.when("GET", "https://fallbackserver/rz/123").check(({ headers }) => {
                 expect(headers["if-none-match"]).toEqual("aaa");
@@ -255,19 +259,20 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             expect(await prom).toEqual({ foo: "baa" });
         }
     });
 
-    it("POST and PUTs", async function() {
+    it("POST and PUTs", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
             fallbackRzServer: "https://fallbackserver/rz",
             fetchFn,
         });
-        { // initial POST
+        {
+            // initial POST
             const prom = simpleHttpTransport.send({ foo: "baa" });
             httpBackend.when("POST", "https://fallbackserver/rz").check(({ headers, data }) => {
                 expect(headers["content-type"]).toEqual("application/json");
@@ -281,10 +286,11 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('', 1);
+            await httpBackend.flush("", 1);
             await prom;
         }
-        { // first PUT without etag
+        {
+            // first PUT without etag
             const prom = simpleHttpTransport.send({ a: "b" });
             httpBackend.when("PUT", "https://fallbackserver/rz/123").check(({ headers, data }) => {
                 expect(headers["if-match"]).toBeUndefined();
@@ -294,14 +300,15 @@ describe("SimpleHttpRendezvousTransport", function() {
                 response: {
                     statusCode: 202,
                     headers: {
-                        "etag": "aaa",
+                        etag: "aaa",
                     },
                 },
             };
-            await httpBackend.flush('', 1);
+            await httpBackend.flush("", 1);
             await prom;
         }
-        { // subsequent PUT which should have etag from previous request
+        {
+            // subsequent PUT which should have etag from previous request
             const prom = simpleHttpTransport.send({ c: "d" });
             httpBackend.when("PUT", "https://fallbackserver/rz/123").check(({ headers }) => {
                 expect(headers["if-match"]).toEqual("aaa");
@@ -310,23 +317,24 @@ describe("SimpleHttpRendezvousTransport", function() {
                 response: {
                     statusCode: 202,
                     headers: {
-                        "etag": "bbb",
+                        etag: "bbb",
                     },
                 },
             };
-            await httpBackend.flush('', 1);
+            await httpBackend.flush("", 1);
             await prom;
         }
     });
 
-    it("POST and DELETE", async function() {
+    it("POST and DELETE", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
             fallbackRzServer: "https://fallbackserver/rz",
             fetchFn,
         });
-        { // Create
+        {
+            // Create
             const prom = simpleHttpTransport.send({ foo: "baa" });
             httpBackend.when("POST", "https://fallbackserver/rz").check(({ headers, data }) => {
                 expect(headers["content-type"]).toEqual("application/json");
@@ -340,10 +348,11 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             expect(await prom).toStrictEqual(undefined);
         }
-        { // Cancel
+        {
+            // Cancel
             const prom = simpleHttpTransport.cancel(RendezvousFailureReason.UserDeclined);
             httpBackend.when("DELETE", "https://fallbackserver/rz/123").response = {
                 body: null,
@@ -352,12 +361,12 @@ describe("SimpleHttpRendezvousTransport", function() {
                     headers: {},
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             await prom;
         }
     });
 
-    it("details before ready", async function() {
+    it("details before ready", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
@@ -367,7 +376,7 @@ describe("SimpleHttpRendezvousTransport", function() {
         expect(simpleHttpTransport.details()).rejects.toThrowError();
     });
 
-    it("send after cancelled", async function() {
+    it("send after cancelled", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
@@ -378,7 +387,7 @@ describe("SimpleHttpRendezvousTransport", function() {
         expect(simpleHttpTransport.send({})).resolves.toBeUndefined();
     });
 
-    it("receive before ready", async function() {
+    it("receive before ready", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
             client,
@@ -388,7 +397,7 @@ describe("SimpleHttpRendezvousTransport", function() {
         expect(simpleHttpTransport.receive()).rejects.toThrowError();
     });
 
-    it("404 failure callback", async function() {
+    it("404 failure callback", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const onFailure = jest.fn();
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
@@ -406,11 +415,11 @@ describe("SimpleHttpRendezvousTransport", function() {
                 headers: {},
             },
         };
-        await httpBackend.flush('', 1);
+        await httpBackend.flush("", 1);
         expect(onFailure).toBeCalledWith(RendezvousFailureReason.Unknown);
     });
 
-    it("404 failure callback mapped to expired", async function() {
+    it("404 failure callback mapped to expired", async function () {
         const client = makeMockClient({ userId: "@alice:example.com", deviceId: "DEVICEID", msc3886Enabled: false });
         const onFailure = jest.fn();
         const simpleHttpTransport = new MSC3886SimpleHttpRendezvousTransport({
@@ -420,7 +429,8 @@ describe("SimpleHttpRendezvousTransport", function() {
             onFailure,
         });
 
-        { // initial POST
+        {
+            // initial POST
             const prom = simpleHttpTransport.send({ foo: "baa" });
             httpBackend.when("POST", "https://fallbackserver/rz").response = {
                 body: null,
@@ -432,10 +442,11 @@ describe("SimpleHttpRendezvousTransport", function() {
                     },
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             await prom;
         }
-        { // GET with 404 to simulate expiry
+        {
+            // GET with 404 to simulate expiry
             expect(simpleHttpTransport.receive()).resolves.toBeUndefined();
             httpBackend.when("GET", "https://fallbackserver/rz/123").response = {
                 body: { foo: "baa" },
@@ -444,7 +455,7 @@ describe("SimpleHttpRendezvousTransport", function() {
                     headers: {},
                 },
             };
-            await httpBackend.flush('');
+            await httpBackend.flush("");
             expect(onFailure).toBeCalledWith(RendezvousFailureReason.Expired);
         }
     });
diff --git a/spec/unit/room-member.spec.ts b/spec/unit/room-member.spec.ts
index 0ed96339bc2..bc8a27344b2 100644
--- a/spec/unit/room-member.spec.ts
+++ b/spec/unit/room-member.spec.ts
@@ -18,21 +18,21 @@ import * as utils from "../test-utils/test-utils";
 import { RoomMember, RoomMemberEvent } from "../../src/models/room-member";
 import { EventType, RoomState } from "../../src";
 
-describe("RoomMember", function() {
+describe("RoomMember", function () {
     const roomId = "!foo:bar";
     const userA = "@alice:bar";
     const userB = "@bertha:bar";
     const userC = "@clarissa:bar";
     let member = new RoomMember(roomId, userA);
 
-    beforeEach(function() {
+    beforeEach(function () {
         member = new RoomMember(roomId, userA);
     });
 
-    describe("getAvatarUrl", function() {
+    describe("getAvatarUrl", function () {
         const hsUrl = "https://my.home.server";
 
-        it("should return the URL from m.room.member preferentially", function() {
+        it("should return the URL from m.room.member preferentially", function () {
             member.events.member = utils.mkEvent({
                 event: true,
                 type: "m.room.member",
@@ -44,21 +44,20 @@ describe("RoomMember", function() {
                     avatar_url: "mxc://flibble/wibble",
                 },
             });
-            const url = member.getAvatarUrl(hsUrl, 1, 1, '', false, false);
+            const url = member.getAvatarUrl(hsUrl, 1, 1, "", false, false);
             // we don't care about how the mxc->http conversion is done, other
             // than it contains the mxc body.
             expect(url?.indexOf("flibble/wibble")).not.toEqual(-1);
         });
 
-        it("should return nothing if there is no m.room.member and allowDefault=false",
-            function() {
-                const url = member.getAvatarUrl(hsUrl, 64, 64, "crop", false, false);
-                expect(url).toEqual(null);
-            });
+        it("should return nothing if there is no m.room.member and allowDefault=false", function () {
+            const url = member.getAvatarUrl(hsUrl, 64, 64, "crop", false, false);
+            expect(url).toEqual(null);
+        });
     });
 
-    describe("setPowerLevelEvent", function() {
-        it("should set 'powerLevel' and 'powerLevelNorm'.", function() {
+    describe("setPowerLevelEvent", function () {
+        it("should set 'powerLevel' and 'powerLevelNorm'.", function () {
             const event = utils.mkEvent({
                 type: "m.room.power_levels",
                 room: roomId,
@@ -67,7 +66,7 @@ describe("RoomMember", function() {
                     users_default: 20,
                     users: {
                         "@bertha:bar": 200,
-                        "@invalid:user": 10,  // shouldn't barf on this.
+                        "@invalid:user": 10, // shouldn't barf on this.
                     },
                 },
                 event: true,
@@ -82,67 +81,35 @@ describe("RoomMember", function() {
             expect(memberB.powerLevelNorm).toEqual(100);
         });
 
-        it("should emit 'RoomMember.powerLevel' if the power level changes.",
-            function() {
-                const event = utils.mkEvent({
-                    type: "m.room.power_levels",
-                    room: roomId,
-                    user: userA,
-                    content: {
-                        users_default: 20,
-                        users: {
-                            "@bertha:bar": 200,
-                            "@invalid:user": 10,  // shouldn't barf on this.
-                        },
+        it("should emit 'RoomMember.powerLevel' if the power level changes.", function () {
+            const event = utils.mkEvent({
+                type: "m.room.power_levels",
+                room: roomId,
+                user: userA,
+                content: {
+                    users_default: 20,
+                    users: {
+                        "@bertha:bar": 200,
+                        "@invalid:user": 10, // shouldn't barf on this.
                     },
-                    event: true,
-                });
-                let emitCount = 0;
-
-                member.on(RoomMemberEvent.PowerLevel, function(emitEvent, emitMember) {
-                    emitCount += 1;
-                    expect(emitMember).toEqual(member);
-                    expect(emitEvent).toEqual(event);
-                });
-
-                member.setPowerLevelEvent(event);
-                expect(emitCount).toEqual(1);
-                member.setPowerLevelEvent(event); // no-op
-                expect(emitCount).toEqual(1);
+                },
+                event: true,
             });
+            let emitCount = 0;
 
-        it("should honour power levels of zero.",
-            function() {
-                const event = utils.mkEvent({
-                    type: "m.room.power_levels",
-                    room: roomId,
-                    user: userA,
-                    content: {
-                        users_default: 20,
-                        users: {
-                            "@alice:bar": 0,
-                        },
-                    },
-                    event: true,
-                });
-                let emitCount = 0;
-
-                // set the power level to something other than zero or we
-                // won't get an event
-                member.powerLevel = 1;
-                member.on(RoomMemberEvent.PowerLevel, function(emitEvent, emitMember) {
-                    emitCount += 1;
-                    expect(emitMember.userId).toEqual('@alice:bar');
-                    expect(emitMember.powerLevel).toEqual(0);
-                    expect(emitEvent).toEqual(event);
-                });
-
-                member.setPowerLevelEvent(event);
-                expect(member.powerLevel).toEqual(0);
-                expect(emitCount).toEqual(1);
+            member.on(RoomMemberEvent.PowerLevel, function (emitEvent, emitMember) {
+                emitCount += 1;
+                expect(emitMember).toEqual(member);
+                expect(emitEvent).toEqual(event);
             });
 
-        it("should not honor string power levels.", function() {
+            member.setPowerLevelEvent(event);
+            expect(emitCount).toEqual(1);
+            member.setPowerLevelEvent(event); // no-op
+            expect(emitCount).toEqual(1);
+        });
+
+        it("should honour power levels of zero.", function () {
             const event = utils.mkEvent({
                 type: "m.room.power_levels",
                 room: roomId,
@@ -150,30 +117,31 @@ describe("RoomMember", function() {
                 content: {
                     users_default: 20,
                     users: {
-                        "@alice:bar": "5",
+                        "@alice:bar": 0,
                     },
                 },
                 event: true,
             });
             let emitCount = 0;
 
-            member.on(RoomMemberEvent.PowerLevel, function(emitEvent, emitMember) {
+            // set the power level to something other than zero or we
+            // won't get an event
+            member.powerLevel = 1;
+            member.on(RoomMemberEvent.PowerLevel, function (emitEvent, emitMember) {
                 emitCount += 1;
-                expect(emitMember.userId).toEqual('@alice:bar');
-                expect(emitMember.powerLevel).toEqual(20);
+                expect(emitMember.userId).toEqual("@alice:bar");
+                expect(emitMember.powerLevel).toEqual(0);
                 expect(emitEvent).toEqual(event);
             });
 
             member.setPowerLevelEvent(event);
-            expect(member.powerLevel).toEqual(20);
+            expect(member.powerLevel).toEqual(0);
             expect(emitCount).toEqual(1);
         });
 
-        it("should no-op if given a non-state or unrelated event", () => {
-            const fn = jest.spyOn(member, "emit");
-            expect(fn).not.toHaveBeenCalledWith(RoomMemberEvent.PowerLevel);
-            member.setPowerLevelEvent(utils.mkEvent({
-                type: EventType.RoomPowerLevels,
+        it("should not honor string power levels.", function () {
+            const event = utils.mkEvent({
+                type: "m.room.power_levels",
                 room: roomId,
                 user: userA,
                 content: {
@@ -182,9 +150,40 @@ describe("RoomMember", function() {
                         "@alice:bar": "5",
                     },
                 },
-                skey: "invalid",
                 event: true,
-            }));
+            });
+            let emitCount = 0;
+
+            member.on(RoomMemberEvent.PowerLevel, function (emitEvent, emitMember) {
+                emitCount += 1;
+                expect(emitMember.userId).toEqual("@alice:bar");
+                expect(emitMember.powerLevel).toEqual(20);
+                expect(emitEvent).toEqual(event);
+            });
+
+            member.setPowerLevelEvent(event);
+            expect(member.powerLevel).toEqual(20);
+            expect(emitCount).toEqual(1);
+        });
+
+        it("should no-op if given a non-state or unrelated event", () => {
+            const fn = jest.spyOn(member, "emit");
+            expect(fn).not.toHaveBeenCalledWith(RoomMemberEvent.PowerLevel);
+            member.setPowerLevelEvent(
+                utils.mkEvent({
+                    type: EventType.RoomPowerLevels,
+                    room: roomId,
+                    user: userA,
+                    content: {
+                        users_default: 20,
+                        users: {
+                            "@alice:bar": "5",
+                        },
+                    },
+                    skey: "invalid",
+                    event: true,
+                }),
+            );
             const nonStateEv = utils.mkEvent({
                 type: EventType.RoomPowerLevels,
                 room: roomId,
@@ -199,19 +198,21 @@ describe("RoomMember", function() {
             });
             delete nonStateEv.event.state_key;
             member.setPowerLevelEvent(nonStateEv);
-            member.setPowerLevelEvent(utils.mkEvent({
-                type: EventType.Sticker,
-                room: roomId,
-                user: userA,
-                content: {},
-                event: true,
-            }));
+            member.setPowerLevelEvent(
+                utils.mkEvent({
+                    type: EventType.Sticker,
+                    room: roomId,
+                    user: userA,
+                    content: {},
+                    event: true,
+                }),
+            );
             expect(fn).not.toHaveBeenCalledWith(RoomMemberEvent.PowerLevel);
         });
     });
 
-    describe("setTypingEvent", function() {
-        it("should set 'typing'", function() {
+    describe("setTypingEvent", function () {
+        it("should set 'typing'", function () {
             member.typing = false;
             const memberB = new RoomMember(roomId, userB);
             memberB.typing = true;
@@ -223,9 +224,7 @@ describe("RoomMember", function() {
                 user: userA,
                 room: roomId,
                 content: {
-                    user_ids: [
-                        userA, userC,
-                    ],
+                    user_ids: [userA, userC],
                 },
                 event: true,
             });
@@ -238,34 +237,31 @@ describe("RoomMember", function() {
             expect(memberC.typing).toEqual(true);
         });
 
-        it("should emit 'RoomMember.typing' if the typing state changes",
-            function() {
-                const event = utils.mkEvent({
-                    type: "m.typing",
-                    room: roomId,
-                    content: {
-                        user_ids: [
-                            userA, userC,
-                        ],
-                    },
-                    event: true,
-                });
-                let emitCount = 0;
-                member.on(RoomMemberEvent.Typing, function(ev, mem) {
-                    expect(mem).toEqual(member);
-                    expect(ev).toEqual(event);
-                    emitCount += 1;
-                });
-                member.typing = false;
-                member.setTypingEvent(event);
-                expect(emitCount).toEqual(1);
-                member.setTypingEvent(event); // no-op
-                expect(emitCount).toEqual(1);
+        it("should emit 'RoomMember.typing' if the typing state changes", function () {
+            const event = utils.mkEvent({
+                type: "m.typing",
+                room: roomId,
+                content: {
+                    user_ids: [userA, userC],
+                },
+                event: true,
+            });
+            let emitCount = 0;
+            member.on(RoomMemberEvent.Typing, function (ev, mem) {
+                expect(mem).toEqual(member);
+                expect(ev).toEqual(event);
+                emitCount += 1;
             });
+            member.typing = false;
+            member.setTypingEvent(event);
+            expect(emitCount).toEqual(1);
+            member.setTypingEvent(event); // no-op
+            expect(emitCount).toEqual(1);
+        });
     });
 
-    describe("isOutOfBand", function() {
-        it("should be set by markOutOfBand", function() {
+    describe("isOutOfBand", function () {
+        it("should be set by markOutOfBand", function () {
             const member = new RoomMember(roomId, userA);
             expect(member.isOutOfBand()).toEqual(false);
             member.markOutOfBand();
@@ -346,7 +342,7 @@ describe("RoomMember", function() {
         });
     });
 
-    describe("setMembershipEvent", function() {
+    describe("setMembershipEvent", function () {
         const joinEvent = utils.mkMembership({
             event: true,
             mship: "join",
@@ -363,35 +359,39 @@ describe("RoomMember", function() {
             room: roomId,
         });
 
-        it("should set 'membership' and assign the event to 'events.member'.",
-            function() {
-                member.setMembershipEvent(inviteEvent);
-                expect(member.membership).toEqual("invite");
-                expect(member.events.member).toEqual(inviteEvent);
-                member.setMembershipEvent(joinEvent);
-                expect(member.membership).toEqual("join");
-                expect(member.events.member).toEqual(joinEvent);
-            });
+        it("should set 'membership' and assign the event to 'events.member'.", function () {
+            member.setMembershipEvent(inviteEvent);
+            expect(member.membership).toEqual("invite");
+            expect(member.events.member).toEqual(inviteEvent);
+            member.setMembershipEvent(joinEvent);
+            expect(member.membership).toEqual("join");
+            expect(member.events.member).toEqual(joinEvent);
+        });
 
-        it("should set 'name' based on user_id, displayname and room state", function() {
+        it("should set 'name' based on user_id, displayname and room state", function () {
             const roomState = {
-                getStateEvents: function(type: string) {
+                getStateEvents: function (type: string) {
                     if (type !== "m.room.member") {
                         return [];
                     }
                     return [
                         utils.mkMembership({
-                            event: true, mship: "join", room: roomId,
+                            event: true,
+                            mship: "join",
+                            room: roomId,
                             user: userB,
                         }),
                         utils.mkMembership({
-                            event: true, mship: "join", room: roomId,
-                            user: userC, name: "Alice",
+                            event: true,
+                            mship: "join",
+                            room: roomId,
+                            user: userC,
+                            name: "Alice",
                         }),
                         joinEvent,
                     ];
                 },
-                getUserIdsWithDisplayName: function(displayName: string) {
+                getUserIdsWithDisplayName: function (displayName: string) {
                     return [userA, userC];
                 },
             } as unknown as RoomState;
@@ -404,9 +404,9 @@ describe("RoomMember", function() {
             expect(member.name.indexOf(userA)).not.toEqual(-1);
         });
 
-        it("should emit 'RoomMember.membership' if the membership changes", function() {
+        it("should emit 'RoomMember.membership' if the membership changes", function () {
             let emitCount = 0;
-            member.on(RoomMemberEvent.Membership, function(ev, mem) {
+            member.on(RoomMemberEvent.Membership, function (ev, mem) {
                 emitCount += 1;
                 expect(mem).toEqual(member);
                 expect(ev).toEqual(inviteEvent);
@@ -417,9 +417,9 @@ describe("RoomMember", function() {
             expect(emitCount).toEqual(1);
         });
 
-        it("should emit 'RoomMember.name' if the name changes", function() {
+        it("should emit 'RoomMember.name' if the name changes", function () {
             let emitCount = 0;
-            member.on(RoomMemberEvent.Name, function(ev, mem) {
+            member.on(RoomMemberEvent.Name, function (ev, mem) {
                 emitCount += 1;
                 expect(mem).toEqual(member);
                 expect(ev).toEqual(joinEvent);
@@ -430,7 +430,7 @@ describe("RoomMember", function() {
             expect(emitCount).toEqual(1);
         });
 
-        it("should set 'name' to user_id if it is just whitespace", function() {
+        it("should set 'name' to user_id if it is just whitespace", function () {
             const joinEvent = utils.mkMembership({
                 event: true,
                 mship: "join",
@@ -444,7 +444,7 @@ describe("RoomMember", function() {
             expect(member.name).toEqual(userA); // it should fallback because all whitespace
         });
 
-        it("should disambiguate users on a fuzzy displayname match", function() {
+        it("should disambiguate users on a fuzzy displayname match", function () {
             const joinEvent = utils.mkMembership({
                 event: true,
                 mship: "join",
@@ -454,19 +454,22 @@ describe("RoomMember", function() {
             });
 
             const roomState = {
-                getStateEvents: function(type: string) {
+                getStateEvents: function (type: string) {
                     if (type !== "m.room.member") {
                         return [];
                     }
                     return [
                         utils.mkMembership({
-                            event: true, mship: "join", room: roomId,
-                            user: userC, name: "Alice",
+                            event: true,
+                            mship: "join",
+                            room: roomId,
+                            user: userC,
+                            name: "Alice",
                         }),
                         joinEvent,
                     ];
                 },
-                getUserIdsWithDisplayName: function(displayName: string) {
+                getUserIdsWithDisplayName: function (displayName: string) {
                     return [userA, userC];
                 },
             } as unknown as RoomState;
diff --git a/spec/unit/room-state.spec.ts b/spec/unit/room-state.spec.ts
index 1ac3721a121..0b8a5abf0b3 100644
--- a/spec/unit/room-state.spec.ts
+++ b/spec/unit/room-state.spec.ts
@@ -14,26 +14,19 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MockedObject } from 'jest-mock';
+import { MockedObject } from "jest-mock";
 
 import * as utils from "../test-utils/test-utils";
 import { makeBeaconEvent, makeBeaconInfoEvent } from "../test-utils/beacon";
 import { filterEmitCallsByEventType } from "../test-utils/emitter";
 import { RoomState, RoomStateEvent } from "../../src/models/room-state";
-import {
-    Beacon,
-    BeaconEvent,
-    getBeaconInfoIdentifier,
-} from "../../src/models/beacon";
+import { Beacon, BeaconEvent, getBeaconInfoIdentifier } from "../../src/models/beacon";
 import { EventType, RelationType, UNSTABLE_MSC2716_MARKER } from "../../src/@types/event";
-import {
-    MatrixEvent,
-    MatrixEventEvent,
-} from "../../src/models/event";
+import { MatrixEvent, MatrixEventEvent } from "../../src/models/event";
 import { M_BEACON } from "../../src/@types/beacon";
 import { MatrixClient } from "../../src/client";
 
-describe("RoomState", function() {
+describe("RoomState", function () {
     const roomId = "!foo:bar";
     const userA = "@alice:bar";
     const userB = "@bob:bar";
@@ -42,35 +35,53 @@ describe("RoomState", function() {
 
     let state = new RoomState(roomId);
 
-    beforeEach(function() {
+    beforeEach(function () {
         state = new RoomState(roomId);
         state.setStateEvents([
-            utils.mkMembership({  // userA joined
-                event: true, mship: "join", user: userA, room: roomId,
+            utils.mkMembership({
+                // userA joined
+                event: true,
+                mship: "join",
+                user: userA,
+                room: roomId,
             }),
-            utils.mkMembership({  // userB joined
-                event: true, mship: "join", user: userB, room: roomId,
+            utils.mkMembership({
+                // userB joined
+                event: true,
+                mship: "join",
+                user: userB,
+                room: roomId,
             }),
-            utils.mkEvent({  // Room name is "Room name goes here"
-                type: "m.room.name", user: userA, room: roomId, event: true, content: {
+            utils.mkEvent({
+                // Room name is "Room name goes here"
+                type: "m.room.name",
+                user: userA,
+                room: roomId,
+                event: true,
+                content: {
                     name: "Room name goes here",
                 },
             }),
-            utils.mkEvent({  // Room creation
-                type: "m.room.create", user: userA, room: roomId, event: true, content: {
+            utils.mkEvent({
+                // Room creation
+                type: "m.room.create",
+                user: userA,
+                room: roomId,
+                event: true,
+                content: {
                     creator: userA,
                 },
             }),
         ]);
     });
 
-    describe("getMembers", function() {
-        it("should return an empty list if there are no members", function() {
+    describe("getMembers", function () {
+        it("should return an empty list if there are no members", function () {
             state = new RoomState(roomId);
             expect(state.getMembers().length).toEqual(0);
         });
 
-        it("should return a member for each m.room.member event", function() {
+        it("should return a member for each m.room.member event", function () {
             const members = state.getMembers();
             expect(members.length).toEqual(2);
             // ordering unimportant
@@ -79,23 +90,26 @@ describe("RoomState", function() {
         });
     });
 
-    describe("getMember", function() {
-        it("should return null if there is no member", function() {
+    describe("getMember", function () {
+        it("should return null if there is no member", function () {
             expect(state.getMember("@no-one:here")).toEqual(null);
         });
 
-        it("should return a member if they exist", function() {
+        it("should return a member if they exist", function () {
             expect(state.getMember(userB)).toBeTruthy();
         });
 
-        it("should return a member which changes as state changes", function() {
+        it("should return a member which changes as state changes", function () {
             const member = state.getMember(userB);
             expect(member?.membership).toEqual("join");
             expect(member?.name).toEqual(userB);
 
             state.setStateEvents([
                 utils.mkMembership({
-                    room: roomId, user: userB, mship: "leave", event: true,
+                    room: roomId,
+                    user: userB,
+                    mship: "leave",
+                    event: true,
                     name: "BobGone",
                 }),
             ]);
@@ -105,71 +119,75 @@ describe("RoomState", function() {
         });
     });
 
-    describe("getSentinelMember", function() {
-        it("should return a member with the user id as name", function() {
+    describe("getSentinelMember", function () {
+        it("should return a member with the user id as name", function () {
             expect(state.getSentinelMember("@no-one:here")?.name).toEqual("@no-one:here");
         });
 
-        it("should return a member which doesn't change when the state is updated",
-            function() {
-                const preLeaveUser = state.getSentinelMember(userA);
-                state.setStateEvents([
-                    utils.mkMembership({
-                        room: roomId, user: userA, mship: "leave", event: true,
-                        name: "AliceIsGone",
-                    }),
-                ]);
-                const postLeaveUser = state.getSentinelMember(userA);
-
-                expect(preLeaveUser?.membership).toEqual("join");
-                expect(preLeaveUser?.name).toEqual(userA);
-
-                expect(postLeaveUser?.membership).toEqual("leave");
-                expect(postLeaveUser?.name).toEqual("AliceIsGone");
-            });
+        it("should return a member which doesn't change when the state is updated", function () {
+            const preLeaveUser = state.getSentinelMember(userA);
+            state.setStateEvents([
+                utils.mkMembership({
+                    room: roomId,
+                    user: userA,
+                    mship: "leave",
+                    event: true,
+                    name: "AliceIsGone",
+                }),
+            ]);
+            const postLeaveUser = state.getSentinelMember(userA);
+
+            expect(preLeaveUser?.membership).toEqual("join");
+            expect(preLeaveUser?.name).toEqual(userA);
+
+            expect(postLeaveUser?.membership).toEqual("leave");
+            expect(postLeaveUser?.name).toEqual("AliceIsGone");
+        });
     });
 
-    describe("getStateEvents", function() {
-        it("should return null if a state_key was specified and there was no match",
-            function() {
-                expect(state.getStateEvents("foo.bar.baz", "keyname")).toEqual(null);
-            });
+    describe("getStateEvents", function () {
+        it("should return null if a state_key was specified and there was no match", function () {
+            expect(state.getStateEvents("foo.bar.baz", "keyname")).toEqual(null);
+        });
 
-        it("should return an empty list if a state_key was not specified and there" +
-            " was no match", function() {
+        it("should return an empty list if a state_key was not specified and there" + " was no match", function () {
             expect(state.getStateEvents("foo.bar.baz")).toEqual([]);
         });
 
-        it("should return a list of matching events if no state_key was specified",
-            function() {
-                const events = state.getStateEvents("m.room.member");
-                expect(events.length).toEqual(2);
-                // ordering unimportant
-                expect([userA, userB].indexOf(events[0].getStateKey() as string)).not.toEqual(-1);
-                expect([userA, userB].indexOf(events[1].getStateKey() as string)).not.toEqual(-1);
-            });
+        it("should return a list of matching events if no state_key was specified", function () {
+            const events = state.getStateEvents("m.room.member");
+            expect(events.length).toEqual(2);
+            // ordering unimportant
+            expect([userA, userB].indexOf(events[0].getStateKey() as string)).not.toEqual(-1);
+            expect([userA, userB].indexOf(events[1].getStateKey() as string)).not.toEqual(-1);
+        });
 
-        it("should return a single MatrixEvent if a state_key was specified",
-            function() {
-                const event = state.getStateEvents("m.room.member", userA);
-                expect(event?.getContent()).toMatchObject({
-                    membership: "join",
-                });
+        it("should return a single MatrixEvent if a state_key was specified", function () {
+            const event = state.getStateEvents("m.room.member", userA);
+            expect(event?.getContent()).toMatchObject({
+                membership: "join",
             });
+        });
     });
 
-    describe("setStateEvents", function() {
-        it("should emit 'RoomState.members' for each m.room.member event", function() {
+    describe("setStateEvents", function () {
+        it("should emit 'RoomState.members' for each m.room.member event", function () {
             const memberEvents = [
                 utils.mkMembership({
-                    user: "@cleo:bar", mship: "invite", room: roomId, event: true,
+                    user: "@cleo:bar",
+                    mship: "invite",
+                    room: roomId,
+                    event: true,
                 }),
                 utils.mkMembership({
-                    user: "@daisy:bar", mship: "join", room: roomId, event: true,
+                    user: "@daisy:bar",
+                    mship: "join",
+                    room: roomId,
+                    event: true,
                 }),
             ];
             let emitCount = 0;
-            state.on(RoomStateEvent.Members, function(ev, st, mem) {
+            state.on(RoomStateEvent.Members, function (ev, st, mem) {
                 expect(ev).toEqual(memberEvents[emitCount]);
                 expect(st).toEqual(state);
                 expect(mem).toEqual(state.getMember(ev.getSender()!));
@@ -179,43 +197,58 @@ describe("RoomState", function() {
             expect(emitCount).toEqual(2);
         });
 
-        it("should emit 'RoomState.newMember' for each new member added", function() {
+        it("should emit 'RoomState.newMember' for each new member added", function () {
             const memberEvents = [
                 utils.mkMembership({
-                    user: "@cleo:bar", mship: "invite", room: roomId, event: true,
+                    user: "@cleo:bar",
+                    mship: "invite",
+                    room: roomId,
+                    event: true,
                 }),
                 utils.mkMembership({
-                    user: "@daisy:bar", mship: "join", room: roomId, event: true,
+                    user: "@daisy:bar",
+                    mship: "join",
+                    room: roomId,
+                    event: true,
                 }),
             ];
             let emitCount = 0;
-            state.on(RoomStateEvent.NewMember, function(ev, st, mem) {
+            state.on(RoomStateEvent.NewMember, function (ev, st, mem) {
                 expect(state.getMember(mem.userId)).toEqual(mem);
                 expect(mem.userId).toEqual(memberEvents[emitCount].getSender());
-                expect(mem.membership).toBeFalsy();  // not defined yet
+                expect(mem.membership).toBeFalsy(); // not defined yet
                 emitCount += 1;
             });
             state.setStateEvents(memberEvents);
             expect(emitCount).toEqual(2);
         });
 
-        it("should emit 'RoomState.events' for each state event", function() {
+        it("should emit 'RoomState.events' for each state event", function () {
             const events = [
                 utils.mkMembership({
-                    user: "@cleo:bar", mship: "invite", room: roomId, event: true,
+                    user: "@cleo:bar",
+                    mship: "invite",
+                    room: roomId,
+                    event: true,
                 }),
                 utils.mkEvent({
-                    user: userB, room: roomId, type: "m.room.topic", event: true,
+                    user: userB,
+                    room: roomId,
+                    type: "m.room.topic",
+                    event: true,
                     content: {
                         topic: "boo!",
                     },
                 }),
-                utils.mkMessage({  // Not a state event
-                    user: userA, room: roomId, event: true,
+                utils.mkMessage({
+                    // Not a state event
+                    user: userA,
+                    room: roomId,
+                    event: true,
                 }),
             ];
             let emitCount = 0;
-            state.on(RoomStateEvent.Events, function(ev, st) {
+            state.on(RoomStateEvent.Events, function (ev, st) {
                 expect(ev).toEqual(events[emitCount]);
                 expect(st).toEqual(state);
                 emitCount += 1;
@@ -224,9 +257,12 @@ describe("RoomState", function() {
             expect(emitCount).toEqual(2);
         });
 
-        it("should call setPowerLevelEvent on each RoomMember for m.room.power_levels", function() {
+        it("should call setPowerLevelEvent on each RoomMember for m.room.power_levels", function () {
             const powerLevelEvent = utils.mkEvent({
-                type: "m.room.power_levels", room: roomId, user: userA, event: true,
+                type: "m.room.power_levels",
+                room: roomId,
+                user: userA,
+                event: true,
                 content: {
                     users_default: 10,
                     state_default: 50,
@@ -243,12 +279,18 @@ describe("RoomState", function() {
             expect(state.members[userB].setPowerLevelEvent).toHaveBeenCalledWith(powerLevelEvent);
         });
 
-        it("should call setPowerLevelEvent on a new RoomMember if power levels exist", function() {
+        it("should call setPowerLevelEvent on a new RoomMember if power levels exist", function () {
             const memberEvent = utils.mkMembership({
-                mship: "join", user: userC, room: roomId, event: true,
+                mship: "join",
+                user: userC,
+                room: roomId,
+                event: true,
             });
             const powerLevelEvent = utils.mkEvent({
-                type: "m.room.power_levels", room: roomId, user: userA, event: true,
+                type: "m.room.power_levels",
+                room: roomId,
+                user: userA,
+                event: true,
                 content: {
                     users_default: 10,
                     state_default: 50,
@@ -266,9 +308,12 @@ describe("RoomState", function() {
             expect(state.members[userC].powerLevel).toEqual(10);
         });
 
-        it("should call setMembershipEvent on the right RoomMember", function() {
+        it("should call setMembershipEvent on the right RoomMember", function () {
             const memberEvent = utils.mkMembership({
-                user: userB, mship: "leave", room: roomId, event: true,
+                user: userB,
+                mship: "leave",
+                room: roomId,
+                event: true,
             });
             // spy on the room members
             jest.spyOn(state.members[userA], "setMembershipEvent");
@@ -276,12 +321,10 @@ describe("RoomState", function() {
             state.setStateEvents([memberEvent]);
 
             expect(state.members[userA].setMembershipEvent).not.toHaveBeenCalled();
-            expect(state.members[userB].setMembershipEvent).toHaveBeenCalledWith(
-                memberEvent, state,
-            );
+            expect(state.members[userB].setMembershipEvent).toHaveBeenCalledWith(memberEvent, state);
         });
 
-        it("should emit `RoomStateEvent.Marker` for each marker event", function() {
+        it("should emit `RoomStateEvent.Marker` for each marker event", function () {
             const events = [
                 utils.mkEvent({
                     event: true,
@@ -295,7 +338,7 @@ describe("RoomState", function() {
                 }),
             ];
             let emitCount = 0;
-            state.on(RoomStateEvent.Marker, function(markerEvent, markerFoundOptions) {
+            state.on(RoomStateEvent.Marker, function (markerEvent, markerFoundOptions) {
                 expect(markerEvent).toEqual(events[emitCount]);
                 expect(markerFoundOptions).toEqual({ timelineWasEmpty: true });
                 emitCount += 1;
@@ -305,10 +348,10 @@ describe("RoomState", function() {
         });
     });
 
-    describe('beacon events', () => {
-        it('adds new beacon info events to state and emits', () => {
+    describe("beacon events", () => {
+        it("adds new beacon info events to state and emits", () => {
             const beaconEvent = makeBeaconInfoEvent(userA, roomId);
-            const emitSpy = jest.spyOn(state, 'emit');
+            const emitSpy = jest.spyOn(state, "emit");
 
             state.setStateEvents([beaconEvent]);
 
@@ -318,11 +361,11 @@ describe("RoomState", function() {
             expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.New, beaconEvent, beaconInstance);
         });
 
-        it('does not add redacted beacon info events to state', () => {
+        it("does not add redacted beacon info events to state", () => {
             const redactedBeaconEvent = makeBeaconInfoEvent(userA, roomId);
-            const redactionEvent = new MatrixEvent({ type: 'm.room.redaction' });
+            const redactionEvent = new MatrixEvent({ type: "m.room.redaction" });
             redactedBeaconEvent.makeRedacted(redactionEvent);
-            const emitSpy = jest.spyOn(state, 'emit');
+            const emitSpy = jest.spyOn(state, "emit");
 
             state.setStateEvents([redactedBeaconEvent]);
 
@@ -333,8 +376,8 @@ describe("RoomState", function() {
             expect(filterEmitCallsByEventType(BeaconEvent.New, emitSpy).length).toBeFalsy();
         });
 
-        it('updates existing beacon info events in state', () => {
-            const beaconId = '$beacon1';
+        it("updates existing beacon info events in state", () => {
+            const beaconId = "$beacon1";
             const beaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId);
             const updatedBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: false }, beaconId);
 
@@ -350,16 +393,16 @@ describe("RoomState", function() {
             expect(state.beacons.get(getBeaconInfoIdentifier(beaconEvent))?.isLive).toEqual(false);
         });
 
-        it('destroys and removes redacted beacon events', () => {
-            const beaconId = '$beacon1';
+        it("destroys and removes redacted beacon events", () => {
+            const beaconId = "$beacon1";
             const beaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId);
             const redactedBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, beaconId);
-            const redactionEvent = new MatrixEvent({ type: 'm.room.redaction', redacts: beaconEvent.getId() });
+            const redactionEvent = new MatrixEvent({ type: "m.room.redaction", redacts: beaconEvent.getId() });
             redactedBeaconEvent.makeRedacted(redactionEvent);
 
             state.setStateEvents([beaconEvent]);
             const beaconInstance = state.beacons.get(getBeaconInfoIdentifier(beaconEvent));
-            const destroySpy = jest.spyOn(beaconInstance as Beacon, 'destroy');
+            const destroySpy = jest.spyOn(beaconInstance as Beacon, "destroy");
             expect(beaconInstance?.isLive).toEqual(true);
 
             state.setStateEvents([redactedBeaconEvent]);
@@ -368,11 +411,11 @@ describe("RoomState", function() {
             expect(state.beacons.get(getBeaconInfoIdentifier(beaconEvent))).toBe(undefined);
         });
 
-        it('updates live beacon ids once after setting state events', () => {
-            const liveBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, '$beacon1');
-            const deadBeaconEvent = makeBeaconInfoEvent(userB, roomId, { isLive: false }, '$beacon2');
+        it("updates live beacon ids once after setting state events", () => {
+            const liveBeaconEvent = makeBeaconInfoEvent(userA, roomId, { isLive: true }, "$beacon1");
+            const deadBeaconEvent = makeBeaconInfoEvent(userB, roomId, { isLive: false }, "$beacon2");
 
-            const emitSpy = jest.spyOn(state, 'emit');
+            const emitSpy = jest.spyOn(state, "emit");
 
             state.setStateEvents([liveBeaconEvent, deadBeaconEvent]);
 
@@ -381,7 +424,10 @@ describe("RoomState", function() {
 
             // live beacon is now not live
             const updatedLiveBeaconEvent = makeBeaconInfoEvent(
-                userA, roomId, { isLive: false }, liveBeaconEvent.getId(),
+                userA,
+                roomId,
+                { isLive: false },
+                liveBeaconEvent.getId(),
             );
 
             state.setStateEvents([updatedLiveBeaconEvent]);
@@ -392,10 +438,13 @@ describe("RoomState", function() {
         });
     });
 
-    describe("setOutOfBandMembers", function() {
-        it("should add a new member", function() {
+    describe("setOutOfBandMembers", function () {
+        it("should add a new member", function () {
             const oobMemberEvent = utils.mkMembership({
-                user: userLazy, mship: "join", room: roomId, event: true,
+                user: userLazy,
+                mship: "join",
+                room: roomId,
+                event: true,
             });
             state.markOutOfBandMembersStarted();
             state.setOutOfBandMembers([oobMemberEvent]);
@@ -404,17 +453,25 @@ describe("RoomState", function() {
             expect(member?.isOutOfBand()).toEqual(true);
         });
 
-        it("should have no effect when not in correct status", function() {
-            state.setOutOfBandMembers([utils.mkMembership({
-                user: userLazy, mship: "join", room: roomId, event: true,
-            })]);
+        it("should have no effect when not in correct status", function () {
+            state.setOutOfBandMembers([
+                utils.mkMembership({
+                    user: userLazy,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                }),
+            ]);
             expect(state.getMember(userLazy)).toBeFalsy();
         });
 
-        it("should emit newMember when adding a member", function() {
+        it("should emit newMember when adding a member", function () {
             const userLazy = "@oob:hs";
             const oobMemberEvent = utils.mkMembership({
-                user: userLazy, mship: "join", room: roomId, event: true,
+                user: userLazy,
+                mship: "join",
+                room: roomId,
+                event: true,
             });
             let eventReceived = false;
             state.once(RoomStateEvent.NewMember, (_event, _state, member) => {
@@ -426,9 +483,12 @@ describe("RoomState", function() {
             expect(eventReceived).toEqual(true);
         });
 
-        it("should never overwrite existing members", function() {
+        it("should never overwrite existing members", function () {
             const oobMemberEvent = utils.mkMembership({
-                user: userA, mship: "join", room: roomId, event: true,
+                user: userA,
+                mship: "join",
+                room: roomId,
+                event: true,
             });
             state.markOutOfBandMembersStarted();
             state.setOutOfBandMembers([oobMemberEvent]);
@@ -437,10 +497,13 @@ describe("RoomState", function() {
             expect(memberA?.isOutOfBand()).toEqual(false);
         });
 
-        it("should emit members when updating a member", function() {
+        it("should emit members when updating a member", function () {
             const doesntExistYetUserId = "@doesntexistyet:hs";
             const oobMemberEvent = utils.mkMembership({
-                user: doesntExistYetUserId, mship: "join", room: roomId, event: true,
+                user: doesntExistYetUserId,
+                mship: "join",
+                room: roomId,
+                event: true,
             });
             let eventReceived = false;
             state.once(RoomStateEvent.Members, (_event, _state, member) => {
@@ -454,13 +517,18 @@ describe("RoomState", function() {
         });
     });
 
-    describe("clone", function() {
-        it("should contain same information as original", function() {
+    describe("clone", function () {
+        it("should contain same information as original", function () {
             // include OOB members in copy
             state.markOutOfBandMembersStarted();
-            state.setOutOfBandMembers([utils.mkMembership({
-                user: userLazy, mship: "join", room: roomId, event: true,
-            })]);
+            state.setOutOfBandMembers([
+                utils.mkMembership({
+                    user: userLazy,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                }),
+            ]);
             const copy = state.clone();
             // check individual members
             [userA, userB, userLazy].forEach((userId) => {
@@ -475,24 +543,39 @@ describe("RoomState", function() {
             expect(state.getJoinedMemberCount()).toEqual(copy.getJoinedMemberCount());
         });
 
-        it("should mark old copy as not waiting for out of band anymore", function() {
+        it("should mark old copy as not waiting for out of band anymore", function () {
             state.markOutOfBandMembersStarted();
             const copy = state.clone();
-            copy.setOutOfBandMembers([utils.mkMembership({
-                user: userA, mship: "join", room: roomId, event: true,
-            })]);
+            copy.setOutOfBandMembers([
+                utils.mkMembership({
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                }),
+            ]);
             // should have no effect as it should be marked in status finished just like copy
-            state.setOutOfBandMembers([utils.mkMembership({
-                user: userLazy, mship: "join", room: roomId, event: true,
-            })]);
+            state.setOutOfBandMembers([
+                utils.mkMembership({
+                    user: userLazy,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                }),
+            ]);
             expect(state.getMember(userLazy)).toBeFalsy();
         });
 
-        it("should return copy independent of original", function() {
+        it("should return copy independent of original", function () {
             const copy = state.clone();
-            copy.setStateEvents([utils.mkMembership({
-                user: userLazy, mship: "join", room: roomId, event: true,
-            })]);
+            copy.setStateEvents([
+                utils.mkMembership({
+                    user: userLazy,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                }),
+            ]);
 
             expect(state.getMember(userLazy)).toBeFalsy();
             expect(state.getJoinedMemberCount()).toEqual(2);
@@ -500,10 +583,13 @@ describe("RoomState", function() {
         });
     });
 
-    describe("setTypingEvent", function() {
-        it("should call setTypingEvent on each RoomMember", function() {
+    describe("setTypingEvent", function () {
+        it("should call setTypingEvent on each RoomMember", function () {
             const typingEvent = utils.mkEvent({
-                type: "m.typing", room: roomId, event: true, content: {
+                type: "m.typing",
+                room: roomId,
+                event: true,
+                content: {
                     user_ids: [userA],
                 },
             });
@@ -517,261 +603,229 @@ describe("RoomState", function() {
         });
     });
 
-    describe("maySendStateEvent", function() {
-        it("should say any member may send state with no power level event",
-            function() {
-                expect(state.maySendStateEvent('m.room.name', userA)).toEqual(true);
-            });
-
-        it("should say members with power >=50 may send state with power level event " +
-        "but no state default",
-        function() {
-            const powerLevelEvent = new MatrixEvent({
-                type: "m.room.power_levels", room_id: roomId, sender: userA,
-                state_key: "",
-                content: {
-                    users_default: 10,
-                    // state_default: 50, "intentionally left blank"
-                    events_default: 25,
-                    users: {
-                        [userA]: 50,
-                    },
-                },
-            });
-
-            state.setStateEvents([powerLevelEvent]);
-
-            expect(state.maySendStateEvent('m.room.name', userA)).toEqual(true);
-            expect(state.maySendStateEvent('m.room.name', userB)).toEqual(false);
+    describe("maySendStateEvent", function () {
+        it("should say any member may send state with no power level event", function () {
+            expect(state.maySendStateEvent("m.room.name", userA)).toEqual(true);
         });
 
-        it("should obey state_default",
-            function() {
+        it(
+            "should say members with power >=50 may send state with power level event " + "but no state default",
+            function () {
                 const powerLevelEvent = new MatrixEvent({
-                    type: "m.room.power_levels", room_id: roomId, sender: userA,
+                    type: "m.room.power_levels",
+                    room_id: roomId,
+                    sender: userA,
                     state_key: "",
                     content: {
                         users_default: 10,
-                        state_default: 30,
+                        // state_default: 50, "intentionally left blank"
                         events_default: 25,
                         users: {
-                            [userA]: 30,
-                            [userB]: 29,
+                            [userA]: 50,
                         },
                     },
                 });
 
                 state.setStateEvents([powerLevelEvent]);
 
-                expect(state.maySendStateEvent('m.room.name', userA)).toEqual(true);
-                expect(state.maySendStateEvent('m.room.name', userB)).toEqual(false);
-            });
+                expect(state.maySendStateEvent("m.room.name", userA)).toEqual(true);
+                expect(state.maySendStateEvent("m.room.name", userB)).toEqual(false);
+            },
+        );
 
-        it("should honour explicit event power levels in the power_levels event",
-            function() {
-                const powerLevelEvent = new MatrixEvent({
-                    type: "m.room.power_levels", room_id: roomId, sender: userA,
-                    state_key: "", content: {
-                        events: {
-                            "m.room.other_thing": 76,
-                        },
-                        users_default: 10,
-                        state_default: 50,
-                        events_default: 25,
-                        users: {
-                            [userA]: 80,
-                            [userB]: 50,
-                        },
+        it("should obey state_default", function () {
+            const powerLevelEvent = new MatrixEvent({
+                type: "m.room.power_levels",
+                room_id: roomId,
+                sender: userA,
+                state_key: "",
+                content: {
+                    users_default: 10,
+                    state_default: 30,
+                    events_default: 25,
+                    users: {
+                        [userA]: 30,
+                        [userB]: 29,
                     },
-                });
+                },
+            });
 
-                state.setStateEvents([powerLevelEvent]);
+            state.setStateEvents([powerLevelEvent]);
 
-                expect(state.maySendStateEvent('m.room.name', userA)).toEqual(true);
-                expect(state.maySendStateEvent('m.room.name', userB)).toEqual(true);
+            expect(state.maySendStateEvent("m.room.name", userA)).toEqual(true);
+            expect(state.maySendStateEvent("m.room.name", userB)).toEqual(false);
+        });
 
-                expect(state.maySendStateEvent('m.room.other_thing', userA)).toEqual(true);
-                expect(state.maySendStateEvent('m.room.other_thing', userB)).toEqual(false);
+        it("should honour explicit event power levels in the power_levels event", function () {
+            const powerLevelEvent = new MatrixEvent({
+                type: "m.room.power_levels",
+                room_id: roomId,
+                sender: userA,
+                state_key: "",
+                content: {
+                    events: {
+                        "m.room.other_thing": 76,
+                    },
+                    users_default: 10,
+                    state_default: 50,
+                    events_default: 25,
+                    users: {
+                        [userA]: 80,
+                        [userB]: 50,
+                    },
+                },
             });
+
+            state.setStateEvents([powerLevelEvent]);
+
+            expect(state.maySendStateEvent("m.room.name", userA)).toEqual(true);
+            expect(state.maySendStateEvent("m.room.name", userB)).toEqual(true);
+
+            expect(state.maySendStateEvent("m.room.other_thing", userA)).toEqual(true);
+            expect(state.maySendStateEvent("m.room.other_thing", userB)).toEqual(false);
+        });
     });
 
-    describe("getJoinedMemberCount", function() {
+    describe("getJoinedMemberCount", function () {
         beforeEach(() => {
             state = new RoomState(roomId);
         });
 
-        it("should update after adding joined member", function() {
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "join",
-                    user: userA, room: roomId }),
-            ]);
+        it("should update after adding joined member", function () {
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "join", user: userA, room: roomId })]);
             expect(state.getJoinedMemberCount()).toEqual(1);
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "join",
-                    user: userC, room: roomId }),
-            ]);
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "join", user: userC, room: roomId })]);
             expect(state.getJoinedMemberCount()).toEqual(2);
         });
     });
 
-    describe("getInvitedMemberCount", function() {
+    describe("getInvitedMemberCount", function () {
         beforeEach(() => {
             state = new RoomState(roomId);
         });
 
-        it("should update after adding invited member", function() {
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "invite",
-                    user: userA, room: roomId }),
-            ]);
+        it("should update after adding invited member", function () {
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "invite", user: userA, room: roomId })]);
             expect(state.getInvitedMemberCount()).toEqual(1);
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "invite",
-                    user: userC, room: roomId }),
-            ]);
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "invite", user: userC, room: roomId })]);
             expect(state.getInvitedMemberCount()).toEqual(2);
         });
     });
 
-    describe("setJoinedMemberCount", function() {
+    describe("setJoinedMemberCount", function () {
         beforeEach(() => {
             state = new RoomState(roomId);
         });
 
-        it("should, once used, override counting members from state", function() {
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "join",
-                    user: userA, room: roomId }),
-            ]);
+        it("should, once used, override counting members from state", function () {
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "join", user: userA, room: roomId })]);
             expect(state.getJoinedMemberCount()).toEqual(1);
             state.setJoinedMemberCount(100);
             expect(state.getJoinedMemberCount()).toEqual(100);
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "join",
-                    user: userC, room: roomId }),
-            ]);
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "join", user: userC, room: roomId })]);
             expect(state.getJoinedMemberCount()).toEqual(100);
         });
 
-        it("should, once used, override counting members from state, " +
-        "also after clone", function() {
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "join",
-                    user: userA, room: roomId }),
-            ]);
+        it("should, once used, override counting members from state, " + "also after clone", function () {
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "join", user: userA, room: roomId })]);
             state.setJoinedMemberCount(100);
             const copy = state.clone();
-            copy.setStateEvents([
-                utils.mkMembership({ event: true, mship: "join",
-                    user: userC, room: roomId }),
-            ]);
+            copy.setStateEvents([utils.mkMembership({ event: true, mship: "join", user: userC, room: roomId })]);
             expect(state.getJoinedMemberCount()).toEqual(100);
         });
     });
 
-    describe("setInvitedMemberCount", function() {
+    describe("setInvitedMemberCount", function () {
         beforeEach(() => {
             state = new RoomState(roomId);
         });
 
-        it("should, once used, override counting members from state", function() {
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "invite",
-                    user: userB, room: roomId }),
-            ]);
+        it("should, once used, override counting members from state", function () {
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "invite", user: userB, room: roomId })]);
             expect(state.getInvitedMemberCount()).toEqual(1);
             state.setInvitedMemberCount(100);
             expect(state.getInvitedMemberCount()).toEqual(100);
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "invite",
-                    user: userC, room: roomId }),
-            ]);
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "invite", user: userC, room: roomId })]);
             expect(state.getInvitedMemberCount()).toEqual(100);
         });
 
-        it("should, once used, override counting members from state, " +
-        "also after clone", function() {
-            state.setStateEvents([
-                utils.mkMembership({ event: true, mship: "invite",
-                    user: userB, room: roomId }),
-            ]);
+        it("should, once used, override counting members from state, " + "also after clone", function () {
+            state.setStateEvents([utils.mkMembership({ event: true, mship: "invite", user: userB, room: roomId })]);
             state.setInvitedMemberCount(100);
             const copy = state.clone();
-            copy.setStateEvents([
-                utils.mkMembership({ event: true, mship: "invite",
-                    user: userC, room: roomId }),
-            ]);
+            copy.setStateEvents([utils.mkMembership({ event: true, mship: "invite", user: userC, room: roomId })]);
             expect(state.getInvitedMemberCount()).toEqual(100);
         });
     });
 
-    describe("maySendEvent", function() {
-        it("should say any member may send events with no power level event",
-            function() {
-                expect(state.maySendEvent('m.room.message', userA)).toEqual(true);
-                expect(state.maySendMessage(userA)).toEqual(true);
-            });
+    describe("maySendEvent", function () {
+        it("should say any member may send events with no power level event", function () {
+            expect(state.maySendEvent("m.room.message", userA)).toEqual(true);
+            expect(state.maySendMessage(userA)).toEqual(true);
+        });
 
-        it("should obey events_default",
-            function() {
-                const powerLevelEvent = new MatrixEvent({
-                    type: "m.room.power_levels", room_id: roomId, sender: userA,
-                    state_key: "",
-                    content: {
-                        users_default: 10,
-                        state_default: 30,
-                        events_default: 25,
-                        users: {
-                            [userA]: 26,
-                            [userB]: 24,
-                        },
+        it("should obey events_default", function () {
+            const powerLevelEvent = new MatrixEvent({
+                type: "m.room.power_levels",
+                room_id: roomId,
+                sender: userA,
+                state_key: "",
+                content: {
+                    users_default: 10,
+                    state_default: 30,
+                    events_default: 25,
+                    users: {
+                        [userA]: 26,
+                        [userB]: 24,
                     },
-                });
+                },
+            });
 
-                state.setStateEvents([powerLevelEvent]);
+            state.setStateEvents([powerLevelEvent]);
 
-                expect(state.maySendEvent('m.room.message', userA)).toEqual(true);
-                expect(state.maySendEvent('m.room.message', userB)).toEqual(false);
+            expect(state.maySendEvent("m.room.message", userA)).toEqual(true);
+            expect(state.maySendEvent("m.room.message", userB)).toEqual(false);
 
-                expect(state.maySendMessage(userA)).toEqual(true);
-                expect(state.maySendMessage(userB)).toEqual(false);
-            });
+            expect(state.maySendMessage(userA)).toEqual(true);
+            expect(state.maySendMessage(userB)).toEqual(false);
+        });
 
-        it("should honour explicit event power levels in the power_levels event",
-            function() {
-                const powerLevelEvent = new MatrixEvent({
-                    type: "m.room.power_levels", room_id: roomId, sender: userA,
-                    state_key: "",
-                    content: {
-                        events: {
-                            "m.room.other_thing": 33,
-                        },
-                        users_default: 10,
-                        state_default: 50,
-                        events_default: 25,
-                        users: {
-                            [userA]: 40,
-                            [userB]: 30,
-                        },
+        it("should honour explicit event power levels in the power_levels event", function () {
+            const powerLevelEvent = new MatrixEvent({
+                type: "m.room.power_levels",
+                room_id: roomId,
+                sender: userA,
+                state_key: "",
+                content: {
+                    events: {
+                        "m.room.other_thing": 33,
                     },
-                });
+                    users_default: 10,
+                    state_default: 50,
+                    events_default: 25,
+                    users: {
+                        [userA]: 40,
+                        [userB]: 30,
+                    },
+                },
+            });
 
-                state.setStateEvents([powerLevelEvent]);
+            state.setStateEvents([powerLevelEvent]);
 
-                expect(state.maySendEvent('m.room.message', userA)).toEqual(true);
-                expect(state.maySendEvent('m.room.message', userB)).toEqual(true);
+            expect(state.maySendEvent("m.room.message", userA)).toEqual(true);
+            expect(state.maySendEvent("m.room.message", userB)).toEqual(true);
 
-                expect(state.maySendMessage(userA)).toEqual(true);
-                expect(state.maySendMessage(userB)).toEqual(true);
+            expect(state.maySendMessage(userA)).toEqual(true);
+            expect(state.maySendMessage(userB)).toEqual(true);
 
-                expect(state.maySendEvent('m.room.other_thing', userA)).toEqual(true);
-                expect(state.maySendEvent('m.room.other_thing', userB)).toEqual(false);
-            });
+            expect(state.maySendEvent("m.room.other_thing", userA)).toEqual(true);
+            expect(state.maySendEvent("m.room.other_thing", userB)).toEqual(false);
+        });
     });
 
-    describe('processBeaconEvents', () => {
-        const beacon1 = makeBeaconInfoEvent(userA, roomId, {}, '$beacon1');
-        const beacon2 = makeBeaconInfoEvent(userB, roomId, {}, '$beacon2');
+    describe("processBeaconEvents", () => {
+        const beacon1 = makeBeaconInfoEvent(userA, roomId, {}, "$beacon1");
+        const beacon2 = makeBeaconInfoEvent(userB, roomId, {}, "$beacon2");
 
         const mockClient = { decryptEventIfNeeded: jest.fn() } as unknown as MockedObject<MatrixClient>;
 
@@ -779,68 +833,70 @@ describe("RoomState", function() {
             mockClient.decryptEventIfNeeded.mockClear();
         });
 
-        it('does nothing when state has no beacons', () => {
-            const emitSpy = jest.spyOn(state, 'emit');
-            state.processBeaconEvents([makeBeaconEvent(userA, { beaconInfoId: '$beacon1' })], mockClient);
+        it("does nothing when state has no beacons", () => {
+            const emitSpy = jest.spyOn(state, "emit");
+            state.processBeaconEvents([makeBeaconEvent(userA, { beaconInfoId: "$beacon1" })], mockClient);
             expect(emitSpy).not.toHaveBeenCalled();
             expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
         });
 
-        it('does nothing when there are no events', () => {
+        it("does nothing when there are no events", () => {
             state.setStateEvents([beacon1, beacon2]);
-            const emitSpy = jest.spyOn(state, 'emit').mockClear();
+            const emitSpy = jest.spyOn(state, "emit").mockClear();
             state.processBeaconEvents([], mockClient);
             expect(emitSpy).not.toHaveBeenCalled();
             expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
         });
 
-        describe('without encryption', () => {
-            it('discards events for beacons that are not in state', () => {
+        describe("without encryption", () => {
+            it("discards events for beacons that are not in state", () => {
                 const location = makeBeaconEvent(userA, {
-                    beaconInfoId: 'some-other-beacon',
+                    beaconInfoId: "some-other-beacon",
                 });
                 const otherRelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessage,
                     content: {
-                        ['m.relates_to']: {
-                            event_id: 'whatever',
+                        ["m.relates_to"]: {
+                            event_id: "whatever",
                         },
                     },
                 });
                 state.setStateEvents([beacon1, beacon2]);
-                const emitSpy = jest.spyOn(state, 'emit').mockClear();
+                const emitSpy = jest.spyOn(state, "emit").mockClear();
                 state.processBeaconEvents([location, otherRelatedEvent], mockClient);
                 expect(emitSpy).not.toHaveBeenCalled();
             });
 
-            it('discards events that are not beacon type', () => {
+            it("discards events that are not beacon type", () => {
                 // related to beacon1
                 const otherRelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessage,
                     content: {
-                        ['m.relates_to']: {
+                        ["m.relates_to"]: {
                             rel_type: RelationType.Reference,
                             event_id: beacon1.getId(),
                         },
                     },
                 });
                 state.setStateEvents([beacon1, beacon2]);
-                const emitSpy = jest.spyOn(state, 'emit').mockClear();
+                const emitSpy = jest.spyOn(state, "emit").mockClear();
                 state.processBeaconEvents([otherRelatedEvent], mockClient);
                 expect(emitSpy).not.toHaveBeenCalled();
             });
 
-            it('adds locations to beacons', () => {
+            it("adds locations to beacons", () => {
                 const location1 = makeBeaconEvent(userA, {
-                    beaconInfoId: '$beacon1', timestamp: Date.now() + 1,
+                    beaconInfoId: "$beacon1",
+                    timestamp: Date.now() + 1,
                 });
                 const location2 = makeBeaconEvent(userA, {
-                    beaconInfoId: '$beacon1', timestamp: Date.now() + 2,
+                    beaconInfoId: "$beacon1",
+                    timestamp: Date.now() + 2,
                 });
                 const location3 = makeBeaconEvent(userB, {
-                    beaconInfoId: 'some-other-beacon',
+                    beaconInfoId: "some-other-beacon",
                 });
 
                 state.setStateEvents([beacon1, beacon2]);
@@ -848,7 +904,7 @@ describe("RoomState", function() {
                 expect(state.beacons.size).toEqual(2);
 
                 const beaconInstance = state.beacons.get(getBeaconInfoIdentifier(beacon1)) as Beacon;
-                const addLocationsSpy = jest.spyOn(beaconInstance, 'addLocations');
+                const addLocationsSpy = jest.spyOn(beaconInstance, "addLocations");
 
                 state.processBeaconEvents([location1, location2, location3], mockClient);
 
@@ -859,11 +915,13 @@ describe("RoomState", function() {
             });
         });
 
-        describe('with encryption', () => {
-            const beacon1RelationContent = { ['m.relates_to']: {
-                rel_type: RelationType.Reference,
-                event_id: beacon1.getId(),
-            } };
+        describe("with encryption", () => {
+            const beacon1RelationContent = {
+                ["m.relates_to"]: {
+                    rel_type: RelationType.Reference,
+                    event_id: beacon1.getId(),
+                },
+            };
             const relatedEncryptedEvent = new MatrixEvent({
                 sender: userA,
                 type: EventType.RoomMessageEncrypted,
@@ -874,53 +932,53 @@ describe("RoomState", function() {
                 type: EventType.RoomMessageEncrypted,
                 content: beacon1RelationContent,
             });
-            jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+            jest.spyOn(decryptingRelatedEvent, "isBeingDecrypted").mockReturnValue(true);
 
             const failedDecryptionRelatedEvent = new MatrixEvent({
                 sender: userA,
                 type: EventType.RoomMessageEncrypted,
                 content: beacon1RelationContent,
             });
-            jest.spyOn(failedDecryptionRelatedEvent, 'isDecryptionFailure').mockReturnValue(true);
+            jest.spyOn(failedDecryptionRelatedEvent, "isDecryptionFailure").mockReturnValue(true);
 
-            it('discards events without relations', () => {
+            it("discards events without relations", () => {
                 const unrelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessageEncrypted,
                 });
                 state.setStateEvents([beacon1, beacon2]);
-                const emitSpy = jest.spyOn(state, 'emit').mockClear();
+                const emitSpy = jest.spyOn(state, "emit").mockClear();
                 state.processBeaconEvents([unrelatedEvent], mockClient);
                 expect(emitSpy).not.toHaveBeenCalled();
                 // discard unrelated events early
                 expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
             });
 
-            it('discards events for beacons that are not in state', () => {
+            it("discards events for beacons that are not in state", () => {
                 const location = makeBeaconEvent(userA, {
-                    beaconInfoId: 'some-other-beacon',
+                    beaconInfoId: "some-other-beacon",
                 });
                 const otherRelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessageEncrypted,
                     content: {
-                        ['m.relates_to']: {
+                        ["m.relates_to"]: {
                             rel_type: RelationType.Reference,
-                            event_id: 'whatever',
+                            event_id: "whatever",
                         },
                     },
                 });
                 state.setStateEvents([beacon1, beacon2]);
 
                 const beacon = state.beacons.get(getBeaconInfoIdentifier(beacon1)) as Beacon;
-                const addLocationsSpy = jest.spyOn(beacon, 'addLocations').mockClear();
+                const addLocationsSpy = jest.spyOn(beacon, "addLocations").mockClear();
                 state.processBeaconEvents([location, otherRelatedEvent], mockClient);
                 expect(addLocationsSpy).not.toHaveBeenCalled();
                 // discard unrelated events early
                 expect(mockClient.decryptEventIfNeeded).not.toHaveBeenCalled();
             });
 
-            it('decrypts related events if needed', () => {
+            it("decrypts related events if needed", () => {
                 const location = makeBeaconEvent(userA, {
                     beaconInfoId: beacon1.getId(),
                 });
@@ -930,15 +988,15 @@ describe("RoomState", function() {
                 expect(mockClient.decryptEventIfNeeded).toHaveBeenCalledTimes(2);
             });
 
-            it('listens for decryption on events that are being decrypted', () => {
+            it("listens for decryption on events that are being decrypted", () => {
                 const decryptingRelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessageEncrypted,
                     content: beacon1RelationContent,
                 });
-                jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+                jest.spyOn(decryptingRelatedEvent, "isBeingDecrypted").mockReturnValue(true);
                 // spy on event.once
-                const eventOnceSpy = jest.spyOn(decryptingRelatedEvent, 'once');
+                const eventOnceSpy = jest.spyOn(decryptingRelatedEvent, "once");
 
                 state.setStateEvents([beacon1, beacon2]);
                 state.processBeaconEvents([decryptingRelatedEvent], mockClient);
@@ -947,15 +1005,15 @@ describe("RoomState", function() {
                 expect(eventOnceSpy).toHaveBeenCalled();
             });
 
-            it('listens for decryption on events that have decryption failure', () => {
+            it("listens for decryption on events that have decryption failure", () => {
                 const failedDecryptionRelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessageEncrypted,
                     content: beacon1RelationContent,
                 });
-                jest.spyOn(failedDecryptionRelatedEvent, 'isDecryptionFailure').mockReturnValue(true);
+                jest.spyOn(failedDecryptionRelatedEvent, "isDecryptionFailure").mockReturnValue(true);
                 // spy on event.once
-                const eventOnceSpy = jest.spyOn(decryptingRelatedEvent, 'once');
+                const eventOnceSpy = jest.spyOn(decryptingRelatedEvent, "once");
 
                 state.setStateEvents([beacon1, beacon2]);
                 state.processBeaconEvents([decryptingRelatedEvent], mockClient);
@@ -964,16 +1022,16 @@ describe("RoomState", function() {
                 expect(eventOnceSpy).toHaveBeenCalled();
             });
 
-            it('discard events that are not m.beacon type after decryption', () => {
+            it("discard events that are not m.beacon type after decryption", () => {
                 const decryptingRelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessageEncrypted,
                     content: beacon1RelationContent,
                 });
-                jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+                jest.spyOn(decryptingRelatedEvent, "isBeingDecrypted").mockReturnValue(true);
                 state.setStateEvents([beacon1, beacon2]);
                 const beacon = state.beacons.get(getBeaconInfoIdentifier(beacon1)) as Beacon;
-                const addLocationsSpy = jest.spyOn(beacon, 'addLocations').mockClear();
+                const addLocationsSpy = jest.spyOn(beacon, "addLocations").mockClear();
                 state.processBeaconEvents([decryptingRelatedEvent], mockClient);
 
                 // this event is a message after decryption
@@ -983,19 +1041,20 @@ describe("RoomState", function() {
                 expect(addLocationsSpy).not.toHaveBeenCalled();
             });
 
-            it('adds locations to beacons after decryption', () => {
+            it("adds locations to beacons after decryption", () => {
                 const decryptingRelatedEvent = new MatrixEvent({
                     sender: userA,
                     type: EventType.RoomMessageEncrypted,
                     content: beacon1RelationContent,
                 });
                 const locationEvent = makeBeaconEvent(userA, {
-                    beaconInfoId: '$beacon1', timestamp: Date.now() + 1,
+                    beaconInfoId: "$beacon1",
+                    timestamp: Date.now() + 1,
                 });
-                jest.spyOn(decryptingRelatedEvent, 'isBeingDecrypted').mockReturnValue(true);
+                jest.spyOn(decryptingRelatedEvent, "isBeingDecrypted").mockReturnValue(true);
                 state.setStateEvents([beacon1, beacon2]);
                 const beacon = state.beacons.get(getBeaconInfoIdentifier(beacon1)) as Beacon;
-                const addLocationsSpy = jest.spyOn(beacon, 'addLocations').mockClear();
+                const addLocationsSpy = jest.spyOn(beacon, "addLocations").mockClear();
                 state.processBeaconEvents([decryptingRelatedEvent], mockClient);
 
                 // update type after '''decryption'''
@@ -1010,17 +1069,21 @@ describe("RoomState", function() {
 
     describe("mayClientSendStateEvent", () => {
         it("should return false if the user isn't authenticated", () => {
-            expect(state.mayClientSendStateEvent("m.room.message", {
-                isGuest: jest.fn().mockReturnValue(false),
-                credentials: {},
-            } as unknown as MatrixClient)).toBeFalsy();
+            expect(
+                state.mayClientSendStateEvent("m.room.message", {
+                    isGuest: jest.fn().mockReturnValue(false),
+                    credentials: {},
+                } as unknown as MatrixClient),
+            ).toBeFalsy();
         });
 
         it("should return false if the user is a guest", () => {
-            expect(state.mayClientSendStateEvent("m.room.message", {
-                isGuest: jest.fn().mockReturnValue(true),
-                credentials: { userId: userA },
-            } as unknown as MatrixClient)).toBeFalsy();
+            expect(
+                state.mayClientSendStateEvent("m.room.message", {
+                    isGuest: jest.fn().mockReturnValue(true),
+                    credentials: { userId: userA },
+                } as unknown as MatrixClient),
+            ).toBeFalsy();
         });
     });
 });
diff --git a/spec/unit/room.spec.ts b/spec/unit/room.spec.ts
index ad74a285352..8fd3c22b936 100644
--- a/spec/unit/room.spec.ts
+++ b/spec/unit/room.spec.ts
@@ -27,7 +27,8 @@ import {
     DuplicateStrategy,
     EventStatus,
     EventTimelineSet,
-    EventType, IContent,
+    EventType,
+    IContent,
     IStateEventWithRoomId,
     JoinRule,
     MatrixEvent,
@@ -46,7 +47,7 @@ import { ReceiptType, WrappedReceipt } from "../../src/@types/read_receipts";
 import { FeatureSupport, Thread, THREAD_RELATION_TYPE, ThreadEvent } from "../../src/models/thread";
 import { Crypto } from "../../src/crypto";
 
-describe("Room", function() {
+describe("Room", function () {
     const roomId = "!foo:bar";
     const userA = "@alice:bar";
     const userB = "@bertha:bar";
@@ -54,85 +55,109 @@ describe("Room", function() {
     const userD = "@dorothy:bar";
     let room: Room;
 
-    const mkMessage = () => utils.mkMessage({
-        event: true,
-        user: userA,
-        room: roomId,
-    }, room.client);
-
-    const mkReply = (target: MatrixEvent) => utils.mkEvent({
-        event: true,
-        type: EventType.RoomMessage,
-        user: userA,
-        room: roomId,
-        content: {
-            "body": "Reply :: " + Math.random(),
-            "m.relates_to": {
-                "m.in_reply_to": {
-                    "event_id": target.getId()!,
+    const mkMessage = () =>
+        utils.mkMessage(
+            {
+                event: true,
+                user: userA,
+                room: roomId,
+            },
+            room.client,
+        );
+
+    const mkReply = (target: MatrixEvent) =>
+        utils.mkEvent(
+            {
+                event: true,
+                type: EventType.RoomMessage,
+                user: userA,
+                room: roomId,
+                content: {
+                    "body": "Reply :: " + Math.random(),
+                    "m.relates_to": {
+                        "m.in_reply_to": {
+                            event_id: target.getId()!,
+                        },
+                    },
                 },
             },
-        },
-    }, room.client);
-
-    const mkEdit = (target: MatrixEvent, salt = Math.random()) => utils.mkEvent({
-        event: true,
-        type: EventType.RoomMessage,
-        user: userA,
-        room: roomId,
-        content: {
-            "body": "* Edit of :: " + target.getId() + " :: " + salt,
-            "m.new_content": {
-                body: "Edit of :: " + target.getId() + " :: " + salt,
+            room.client,
+        );
+
+    const mkEdit = (target: MatrixEvent, salt = Math.random()) =>
+        utils.mkEvent(
+            {
+                event: true,
+                type: EventType.RoomMessage,
+                user: userA,
+                room: roomId,
+                content: {
+                    "body": "* Edit of :: " + target.getId() + " :: " + salt,
+                    "m.new_content": {
+                        body: "Edit of :: " + target.getId() + " :: " + salt,
+                    },
+                    "m.relates_to": {
+                        rel_type: RelationType.Replace,
+                        event_id: target.getId()!,
+                    },
+                },
             },
-            "m.relates_to": {
-                rel_type: RelationType.Replace,
-                event_id: target.getId()!,
+            room.client,
+        );
+
+    const mkThreadResponse = (root: MatrixEvent) =>
+        utils.mkEvent(
+            {
+                event: true,
+                type: EventType.RoomMessage,
+                user: userA,
+                room: roomId,
+                content: {
+                    "body": "Thread response :: " + Math.random(),
+                    "m.relates_to": {
+                        "event_id": root.getId()!,
+                        "m.in_reply_to": {
+                            event_id: root.getId()!,
+                        },
+                        "rel_type": "m.thread",
+                    },
+                },
             },
-        },
-    }, room.client);
-
-    const mkThreadResponse = (root: MatrixEvent) => utils.mkEvent({
-        event: true,
-        type: EventType.RoomMessage,
-        user: userA,
-        room: roomId,
-        content: {
-            "body": "Thread response :: " + Math.random(),
-            "m.relates_to": {
-                "event_id": root.getId()!,
-                "m.in_reply_to": {
-                    "event_id": root.getId()!,
+            room.client,
+        );
+
+    const mkReaction = (target: MatrixEvent) =>
+        utils.mkEvent(
+            {
+                event: true,
+                type: EventType.Reaction,
+                user: userA,
+                room: roomId,
+                content: {
+                    "m.relates_to": {
+                        rel_type: RelationType.Annotation,
+                        event_id: target.getId()!,
+                        key: Math.random().toString(),
+                    },
                 },
-                "rel_type": "m.thread",
             },
-        },
-    }, room.client);
-
-    const mkReaction = (target: MatrixEvent) => utils.mkEvent({
-        event: true,
-        type: EventType.Reaction,
-        user: userA,
-        room: roomId,
-        content: {
-            "m.relates_to": {
-                "rel_type": RelationType.Annotation,
-                "event_id": target.getId()!,
-                "key": Math.random().toString(),
+            room.client,
+        );
+
+    const mkRedaction = (target: MatrixEvent) =>
+        utils.mkEvent(
+            {
+                event: true,
+                type: EventType.RoomRedaction,
+                user: userA,
+                room: roomId,
+                redacts: target.getId()!,
+                content: {},
             },
-        },
-    }, room.client);
-
-    const mkRedaction = (target: MatrixEvent) => utils.mkEvent({
-        event: true,
-        type: EventType.RoomRedaction,
-        user: userA,
-        room: roomId,
-        redacts: target.getId()!,
-        content: {},
-    }, room.client);
-
-    beforeEach(function() {
+            room.client,
+        );
+
+    beforeEach(function () {
         room = new Room(roomId, new TestClient(userA, "device").client, userA);
         // mock RoomStates
         // @ts-ignore
@@ -141,10 +166,10 @@ describe("Room", function() {
         room.currentState = room.getLiveTimeline().endState = utils.mock(RoomState, "currentState");
     });
 
-    describe('getCreator', () => {
-        it("should return the creator from m.room.create", function() {
+    describe("getCreator", () => {
+        it("should return the creator from m.room.create", function () {
             // @ts-ignore - mocked doesn't handle overloads sanely
-            mocked(room.currentState.getStateEvents).mockImplementation(function(type, key) {
+            mocked(room.currentState.getStateEvents).mockImplementation(function (type, key) {
                 if (type === EventType.RoomCreate && key === "") {
                     return utils.mkEvent({
                         event: true,
@@ -163,12 +188,12 @@ describe("Room", function() {
         });
     });
 
-    describe("getAvatarUrl", function() {
+    describe("getAvatarUrl", function () {
         const hsUrl = "https://my.home.server";
 
-        it("should return the URL from m.room.avatar preferentially", function() {
+        it("should return the URL from m.room.avatar preferentially", function () {
             // @ts-ignore - mocked doesn't handle overloads sanely
-            mocked(room.currentState.getStateEvents).mockImplementation(function(type, key) {
+            mocked(room.currentState.getStateEvents).mockImplementation(function (type, key) {
                 if (type === EventType.RoomAvatar && key === "") {
                     return utils.mkEvent({
                         event: true,
@@ -188,41 +213,48 @@ describe("Room", function() {
             expect(url?.indexOf("flibble/wibble")).not.toEqual(-1);
         });
 
-        it("should return nothing if there is no m.room.avatar and allowDefault=false",
-            function() {
-                const url = room.getAvatarUrl(hsUrl, 64, 64, "crop", false);
-                expect(url).toEqual(null);
-            });
+        it("should return nothing if there is no m.room.avatar and allowDefault=false", function () {
+            const url = room.getAvatarUrl(hsUrl, 64, 64, "crop", false);
+            expect(url).toEqual(null);
+        });
     });
 
-    describe("getMember", function() {
-        beforeEach(function() {
-            mocked(room.currentState.getMember).mockImplementation(function(userId) {
-                return {
-                    "@alice:bar": {
-                        userId: userA,
-                        roomId: roomId,
-                    } as unknown as RoomMember,
-                }[userId] || null;
+    describe("getMember", function () {
+        beforeEach(function () {
+            mocked(room.currentState.getMember).mockImplementation(function (userId) {
+                return (
+                    {
+                        "@alice:bar": {
+                            userId: userA,
+                            roomId: roomId,
+                        } as unknown as RoomMember,
+                    }[userId] || null
+                );
             });
         });
 
-        it("should return null if the member isn't in current state", function() {
+        it("should return null if the member isn't in current state", function () {
             expect(room.getMember("@bar:foo")).toEqual(null);
         });
 
-        it("should return the member from current state", function() {
+        it("should return the member from current state", function () {
             expect(room.getMember(userA)).not.toEqual(null);
         });
     });
 
-    describe("addLiveEvents", function() {
+    describe("addLiveEvents", function () {
         const events: MatrixEvent[] = [
             utils.mkMessage({
-                room: roomId, user: userA, msg: "changing room name", event: true,
+                room: roomId,
+                user: userA,
+                msg: "changing room name",
+                event: true,
             }),
             utils.mkEvent({
-                type: EventType.RoomName, room: roomId, user: userA, event: true,
+                type: EventType.RoomName,
+                room: roomId,
+                user: userA,
+                event: true,
                 content: { name: "New Room Name" },
             }),
         ];
@@ -234,8 +266,8 @@ describe("Room", function() {
             expect(() => room.addLiveEvents(events, "shouldfailbecauseinvalidduplicatestrategy", false)).toThrow();
         });
 
-        it("should throw if duplicateStrategy isn't 'replace' or 'ignore'", function() {
-            expect(function() {
+        it("should throw if duplicateStrategy isn't 'replace' or 'ignore'", function () {
+            expect(function () {
                 // @ts-ignore
                 room.addLiveEvents(events, {
                     duplicateStrategy: "foo",
@@ -243,10 +275,13 @@ describe("Room", function() {
             }).toThrow();
         });
 
-        it("should replace a timeline event if dupe strategy is 'replace'", function() {
+        it("should replace a timeline event if dupe strategy is 'replace'", function () {
             // make a duplicate
             const dupe = utils.mkMessage({
-                room: roomId, user: userA, msg: "dupe", event: true,
+                room: roomId,
+                user: userA,
+                msg: "dupe",
+                event: true,
             });
             dupe.event.event_id = events[0].getId();
             room.addLiveEvents(events);
@@ -257,10 +292,13 @@ describe("Room", function() {
             expect(room.timeline[0]).toEqual(dupe);
         });
 
-        it("should ignore a given dupe event if dupe strategy is 'ignore'", function() {
+        it("should ignore a given dupe event if dupe strategy is 'ignore'", function () {
             // make a duplicate
             const dupe = utils.mkMessage({
-                room: roomId, user: userA, msg: "dupe", event: true,
+                room: roomId,
+                user: userA,
+                msg: "dupe",
+                event: true,
             });
             dupe.event.event_id = events[0].getId();
             room.addLiveEvents(events);
@@ -272,9 +310,9 @@ describe("Room", function() {
             expect(room.timeline[0]).toEqual(events[0]);
         });
 
-        it("should emit 'Room.timeline' events", function() {
+        it("should emit 'Room.timeline' events", function () {
             let callCount = 0;
-            room.on(RoomEvent.Timeline, function(event, emitRoom, toStart) {
+            room.on(RoomEvent.Timeline, function (event, emitRoom, toStart) {
                 callCount += 1;
                 expect(room.timeline.length).toEqual(callCount);
                 expect(event).toEqual(events[callCount - 1]);
@@ -285,40 +323,40 @@ describe("Room", function() {
             expect(callCount).toEqual(2);
         });
 
-        it("should call setStateEvents on the right RoomState with the right forwardLooking value for new events",
-            function() {
-                const events: MatrixEvent[] = [
-                    utils.mkMembership({
-                        room: roomId, mship: "invite", user: userB, skey: userA, event: true,
-                    }),
-                    utils.mkEvent({
-                        type: EventType.RoomName, room: roomId, user: userB, event: true,
-                        content: {
-                            name: "New room",
-                        },
-                    }),
-                ];
-                room.addLiveEvents(events);
-                expect(room.currentState.setStateEvents).toHaveBeenCalledWith(
-                    [events[0]],
-                    { timelineWasEmpty: false },
-                );
-                expect(room.currentState.setStateEvents).toHaveBeenCalledWith(
-                    [events[1]],
-                    { timelineWasEmpty: false },
-                );
-                expect(events[0].forwardLooking).toBe(true);
-                expect(events[1].forwardLooking).toBe(true);
-                expect(room.oldState.setStateEvents).not.toHaveBeenCalled();
-            });
+        it("should call setStateEvents on the right RoomState with the right forwardLooking value for new events", function () {
+            const events: MatrixEvent[] = [
+                utils.mkMembership({
+                    room: roomId,
+                    mship: "invite",
+                    user: userB,
+                    skey: userA,
+                    event: true,
+                }),
+                utils.mkEvent({
+                    type: EventType.RoomName,
+                    room: roomId,
+                    user: userB,
+                    event: true,
+                    content: {
+                        name: "New room",
+                    },
+                }),
+            ];
+            room.addLiveEvents(events);
+            expect(room.currentState.setStateEvents).toHaveBeenCalledWith([events[0]], { timelineWasEmpty: false });
+            expect(room.currentState.setStateEvents).toHaveBeenCalledWith([events[1]], { timelineWasEmpty: false });
+            expect(events[0].forwardLooking).toBe(true);
+            expect(events[1].forwardLooking).toBe(true);
+            expect(room.oldState.setStateEvents).not.toHaveBeenCalled();
+        });
 
-        it("should synthesize read receipts for the senders of events", function() {
+        it("should synthesize read receipts for the senders of events", function () {
             const sentinel = {
                 userId: userA,
                 membership: "join",
                 name: "Alice",
             } as unknown as RoomMember;
-            mocked(room.currentState.getSentinelMember).mockImplementation(function(uid) {
+            mocked(room.currentState.getSentinelMember).mockImplementation(function (uid) {
                 if (uid === userA) {
                     return sentinel;
                 }
@@ -328,15 +366,19 @@ describe("Room", function() {
             expect(room.getEventReadUpTo(userA)).toEqual(events[1].getId());
         });
 
-        it("should emit Room.localEchoUpdated when a local echo is updated", function() {
+        it("should emit Room.localEchoUpdated when a local echo is updated", function () {
             const localEvent = utils.mkMessage({
-                room: roomId, user: userA, event: true,
+                room: roomId,
+                user: userA,
+                event: true,
             });
             localEvent.status = EventStatus.SENDING;
             const localEventId = localEvent.getId();
 
             const remoteEvent = utils.mkMessage({
-                room: roomId, user: userA, event: true,
+                room: roomId,
+                user: userA,
+                event: true,
             });
             remoteEvent.event.unsigned = { transaction_id: "TXN_ID" };
             const remoteEventId = remoteEvent.getId();
@@ -373,9 +415,11 @@ describe("Room", function() {
             expect(callCount).toEqual(2);
         });
 
-        it("should be able to update local echo without a txn ID (/send then /sync)", function() {
+        it("should be able to update local echo without a txn ID (/send then /sync)", function () {
             const eventJson = utils.mkMessage({
-                room: roomId, user: userA, event: false,
+                room: roomId,
+                user: userA,
+                event: false,
             });
             delete eventJson["txn_id"];
             delete eventJson["event_id"];
@@ -404,9 +448,11 @@ describe("Room", function() {
             expect(room.getEventForTxnId(txnId)).toBeUndefined();
         });
 
-        it("should be able to update local echo without a txn ID (/sync then /send)", function() {
+        it("should be able to update local echo without a txn ID (/sync then /send)", function () {
             const eventJson = utils.mkMessage({
-                room: roomId, user: userA, event: false,
+                room: roomId,
+                user: userA,
+                event: false,
             });
             delete eventJson["txn_id"];
             delete eventJson["event_id"];
@@ -440,7 +486,9 @@ describe("Room", function() {
 
         it("should correctly handle remote echoes from other devices", () => {
             const remoteEvent = utils.mkMessage({
-                room: roomId, user: userA, event: true,
+                room: roomId,
+                user: userA,
+                event: true,
             });
             remoteEvent.event.unsigned = { transaction_id: "TXN_ID" };
 
@@ -450,8 +498,8 @@ describe("Room", function() {
         });
     });
 
-    describe('addEphemeralEvents', () => {
-        it("should call RoomState.setTypingEvent on m.typing events", function() {
+    describe("addEphemeralEvents", () => {
+        it("should call RoomState.setTypingEvent on m.typing events", function () {
             const typing = utils.mkEvent({
                 room: roomId,
                 type: EventType.Typing,
@@ -465,47 +513,52 @@ describe("Room", function() {
         });
     });
 
-    describe("addEventsToTimeline", function() {
+    describe("addEventsToTimeline", function () {
         const events = [
             utils.mkMessage({
-                room: roomId, user: userA, msg: "changing room name", event: true,
+                room: roomId,
+                user: userA,
+                msg: "changing room name",
+                event: true,
             }),
             utils.mkEvent({
-                type: EventType.RoomName, room: roomId, user: userA, event: true,
+                type: EventType.RoomName,
+                room: roomId,
+                user: userA,
+                event: true,
                 content: { name: "New Room Name" },
             }),
         ];
 
-        it("should not be able to add events to the end", function() {
-            expect(function() {
+        it("should not be able to add events to the end", function () {
+            expect(function () {
                 room.addEventsToTimeline(events, false, room.getLiveTimeline());
             }).toThrow();
         });
 
-        it("should be able to add events to the start", function() {
+        it("should be able to add events to the start", function () {
             room.addEventsToTimeline(events, true, room.getLiveTimeline());
             expect(room.timeline.length).toEqual(2);
             expect(room.timeline[0]).toEqual(events[1]);
             expect(room.timeline[1]).toEqual(events[0]);
         });
 
-        it("should emit 'Room.timeline' events when added to the start",
-            function() {
-                let callCount = 0;
-                room.on(RoomEvent.Timeline, function(event, emitRoom, toStart) {
-                    callCount += 1;
-                    expect(room.timeline.length).toEqual(callCount);
-                    expect(event).toEqual(events[callCount - 1]);
-                    expect(emitRoom).toEqual(room);
-                    expect(toStart).toBe(true);
-                });
-                room.addEventsToTimeline(events, true, room.getLiveTimeline());
-                expect(callCount).toEqual(2);
+        it("should emit 'Room.timeline' events when added to the start", function () {
+            let callCount = 0;
+            room.on(RoomEvent.Timeline, function (event, emitRoom, toStart) {
+                callCount += 1;
+                expect(room.timeline.length).toEqual(callCount);
+                expect(event).toEqual(events[callCount - 1]);
+                expect(emitRoom).toEqual(room);
+                expect(toStart).toBe(true);
             });
+            room.addEventsToTimeline(events, true, room.getLiveTimeline());
+            expect(callCount).toEqual(2);
+        });
     });
 
-    describe("event metadata handling", function() {
-        it("should set event.sender for new and old events", function() {
+    describe("event metadata handling", function () {
+        it("should set event.sender for new and old events", function () {
             const sentinel = {
                 userId: userA,
                 membership: "join",
@@ -516,13 +569,13 @@ describe("Room", function() {
                 membership: "join",
                 name: "Old Alice",
             } as unknown as RoomMember;
-            mocked(room.currentState.getSentinelMember).mockImplementation(function(uid) {
+            mocked(room.currentState.getSentinelMember).mockImplementation(function (uid) {
                 if (uid === userA) {
                     return sentinel;
                 }
                 return null;
             });
-            mocked(room.oldState.getSentinelMember).mockImplementation(function(uid) {
+            mocked(room.oldState.getSentinelMember).mockImplementation(function (uid) {
                 if (uid === userA) {
                     return oldSentinel;
                 }
@@ -530,11 +583,17 @@ describe("Room", function() {
             });
 
             const newEv = utils.mkEvent({
-                type: EventType.RoomName, room: roomId, user: userA, event: true,
+                type: EventType.RoomName,
+                room: roomId,
+                user: userA,
+                event: true,
                 content: { name: "New Room Name" },
             });
             const oldEv = utils.mkEvent({
-                type: EventType.RoomName, room: roomId, user: userA, event: true,
+                type: EventType.RoomName,
+                room: roomId,
+                user: userA,
+                event: true,
                 content: { name: "Old Room Name" },
             });
             room.addLiveEvents([newEv]);
@@ -543,7 +602,7 @@ describe("Room", function() {
             expect(oldEv.sender).toEqual(oldSentinel);
         });
 
-        it("should set event.target for new and old m.room.member events", function() {
+        it("should set event.target for new and old m.room.member events", function () {
             const sentinel = {
                 userId: userA,
                 membership: "join",
@@ -554,13 +613,13 @@ describe("Room", function() {
                 membership: "join",
                 name: "Old Alice",
             } as unknown as RoomMember;
-            mocked(room.currentState.getSentinelMember).mockImplementation(function(uid) {
+            mocked(room.currentState.getSentinelMember).mockImplementation(function (uid) {
                 if (uid === userA) {
                     return sentinel;
                 }
                 return null;
             });
-            mocked(room.oldState.getSentinelMember).mockImplementation(function(uid) {
+            mocked(room.oldState.getSentinelMember).mockImplementation(function (uid) {
                 if (uid === userA) {
                     return oldSentinel;
                 }
@@ -568,10 +627,18 @@ describe("Room", function() {
             });
 
             const newEv = utils.mkMembership({
-                room: roomId, mship: "invite", user: userB, skey: userA, event: true,
+                room: roomId,
+                mship: "invite",
+                user: userB,
+                skey: userA,
+                event: true,
             });
             const oldEv = utils.mkMembership({
-                room: roomId, mship: "ban", user: userB, skey: userA, event: true,
+                room: roomId,
+                mship: "ban",
+                user: userB,
+                skey: userA,
+                event: true,
             });
             room.addLiveEvents([newEv]);
             expect(newEv.target).toEqual(sentinel);
@@ -579,61 +646,73 @@ describe("Room", function() {
             expect(oldEv.target).toEqual(oldSentinel);
         });
 
-        it("should call setStateEvents on the right RoomState with the right " +
-        "forwardLooking value for old events", function() {
-            const events: MatrixEvent[] = [
-                utils.mkMembership({
-                    room: roomId, mship: "invite", user: userB, skey: userA, event: true,
-                }),
-                utils.mkEvent({
-                    type: EventType.RoomName, room: roomId, user: userB, event: true,
-                    content: {
-                        name: "New room",
-                    },
-                }),
-            ];
+        it(
+            "should call setStateEvents on the right RoomState with the right " + "forwardLooking value for old events",
+            function () {
+                const events: MatrixEvent[] = [
+                    utils.mkMembership({
+                        room: roomId,
+                        mship: "invite",
+                        user: userB,
+                        skey: userA,
+                        event: true,
+                    }),
+                    utils.mkEvent({
+                        type: EventType.RoomName,
+                        room: roomId,
+                        user: userB,
+                        event: true,
+                        content: {
+                            name: "New room",
+                        },
+                    }),
+                ];
 
-            room.addEventsToTimeline(events, true, room.getLiveTimeline());
-            expect(room.oldState.setStateEvents).toHaveBeenCalledWith(
-                [events[0]],
-                { timelineWasEmpty: undefined },
-            );
-            expect(room.oldState.setStateEvents).toHaveBeenCalledWith(
-                [events[1]],
-                { timelineWasEmpty: undefined },
-            );
-            expect(events[0].forwardLooking).toBe(false);
-            expect(events[1].forwardLooking).toBe(false);
-            expect(room.currentState.setStateEvents).not.toHaveBeenCalled();
-        });
+                room.addEventsToTimeline(events, true, room.getLiveTimeline());
+                expect(room.oldState.setStateEvents).toHaveBeenCalledWith([events[0]], { timelineWasEmpty: undefined });
+                expect(room.oldState.setStateEvents).toHaveBeenCalledWith([events[1]], { timelineWasEmpty: undefined });
+                expect(events[0].forwardLooking).toBe(false);
+                expect(events[1].forwardLooking).toBe(false);
+                expect(room.currentState.setStateEvents).not.toHaveBeenCalled();
+            },
+        );
     });
 
-    const resetTimelineTests = function(timelineSupport: boolean) {
+    const resetTimelineTests = function (timelineSupport: boolean) {
         let events: MatrixEvent[];
 
-        beforeEach(function() {
+        beforeEach(function () {
             room = new Room(roomId, new TestClient(userA).client, userA, { timelineSupport: timelineSupport });
             // set events each time to avoid resusing Event objects (which
             // doesn't work because they get frozen)
             events = [
                 utils.mkMessage({
-                    room: roomId, user: userA, msg: "A message", event: true,
+                    room: roomId,
+                    user: userA,
+                    msg: "A message",
+                    event: true,
                 }),
                 utils.mkEvent({
-                    type: EventType.RoomName, room: roomId, user: userA, event: true,
+                    type: EventType.RoomName,
+                    room: roomId,
+                    user: userA,
+                    event: true,
                     content: { name: "New Room Name" },
                 }),
                 utils.mkEvent({
-                    type: EventType.RoomName, room: roomId, user: userA, event: true,
+                    type: EventType.RoomName,
+                    room: roomId,
+                    user: userA,
+                    event: true,
                     content: { name: "Another New Name" },
                 }),
             ];
         });
 
-        it("should copy state from previous timeline", function() {
+        it("should copy state from previous timeline", function () {
             room.addLiveEvents([events[0], events[1]]);
             expect(room.getLiveTimeline().getEvents().length).toEqual(2);
-            room.resetLiveTimeline('sometoken', 'someothertoken');
+            room.resetLiveTimeline("sometoken", "someothertoken");
 
             room.addLiveEvents([events[2]]);
             const oldState = room.getLiveTimeline().getState(EventTimeline.BACKWARDS);
@@ -643,13 +722,13 @@ describe("Room", function() {
             expect(newState?.getStateEvents(EventType.RoomName, "")).toEqual(events[2]);
         });
 
-        it("should reset the legacy timeline fields", function() {
+        it("should reset the legacy timeline fields", function () {
             room.addLiveEvents([events[0], events[1]]);
             expect(room.timeline.length).toEqual(2);
 
             const oldStateBeforeRunningReset = room.oldState;
             let oldStateUpdateEmitCount = 0;
-            room.on(RoomEvent.OldStateUpdated, function(room, previousOldState, oldState) {
+            room.on(RoomEvent.OldStateUpdated, function (room, previousOldState, oldState) {
                 expect(previousOldState).toBe(oldStateBeforeRunningReset);
                 expect(oldState).toBe(room.oldState);
                 oldStateUpdateEmitCount += 1;
@@ -657,30 +736,28 @@ describe("Room", function() {
 
             const currentStateBeforeRunningReset = room.currentState;
             let currentStateUpdateEmitCount = 0;
-            room.on(RoomEvent.CurrentStateUpdated, function(room, previousCurrentState, currentState) {
+            room.on(RoomEvent.CurrentStateUpdated, function (room, previousCurrentState, currentState) {
                 expect(previousCurrentState).toBe(currentStateBeforeRunningReset);
                 expect(currentState).toBe(room.currentState);
                 currentStateUpdateEmitCount += 1;
             });
 
-            room.resetLiveTimeline('sometoken', 'someothertoken');
+            room.resetLiveTimeline("sometoken", "someothertoken");
 
             room.addLiveEvents([events[2]]);
             const newLiveTimeline = room.getLiveTimeline();
             expect(room.timeline).toEqual(newLiveTimeline.getEvents());
-            expect(room.oldState).toEqual(
-                newLiveTimeline.getState(EventTimeline.BACKWARDS));
-            expect(room.currentState).toEqual(
-                newLiveTimeline.getState(EventTimeline.FORWARDS));
+            expect(room.oldState).toEqual(newLiveTimeline.getState(EventTimeline.BACKWARDS));
+            expect(room.currentState).toEqual(newLiveTimeline.getState(EventTimeline.FORWARDS));
             // Make sure `RoomEvent.OldStateUpdated` was emitted
             expect(oldStateUpdateEmitCount).toEqual(1);
             // Make sure `RoomEvent.OldStateUpdated` was emitted if necessary
             expect(currentStateUpdateEmitCount).toEqual(timelineSupport ? 1 : 0);
         });
 
-        it("should emit Room.timelineReset event and set the correct pagination token", function() {
+        it("should emit Room.timelineReset event and set the correct pagination token", function () {
             let callCount = 0;
-            room.on(RoomEvent.TimelineReset, function(emitRoom) {
+            room.on(RoomEvent.TimelineReset, function (emitRoom) {
                 callCount += 1;
                 expect(emitRoom).toEqual(room);
 
@@ -693,11 +770,11 @@ describe("Room", function() {
             expect(callCount).toEqual(1);
         });
 
-        it("should " + (timelineSupport ? "remember" : "forget") + " old timelines", function() {
+        it("should " + (timelineSupport ? "remember" : "forget") + " old timelines", function () {
             room.addLiveEvents([events[0]]);
             expect(room.timeline.length).toEqual(1);
             const firstLiveTimeline = room.getLiveTimeline();
-            room.resetLiveTimeline('sometoken', 'someothertoken');
+            room.resetLiveTimeline("sometoken", "someothertoken");
 
             const tl = room.getTimelineForEvent(events[0].getId()!);
             expect(tl).toBe(timelineSupport ? firstLiveTimeline : null);
@@ -707,35 +784,47 @@ describe("Room", function() {
     describe("resetLiveTimeline with timeline support enabled", resetTimelineTests.bind(null, true));
     describe("resetLiveTimeline with timeline support disabled", resetTimelineTests.bind(null, false));
 
-    describe("compareEventOrdering", function() {
-        beforeEach(function() {
+    describe("compareEventOrdering", function () {
+        beforeEach(function () {
             room = new Room(roomId, new TestClient(userA).client, userA, { timelineSupport: true });
         });
 
         const events: MatrixEvent[] = [
             utils.mkMessage({
-                room: roomId, user: userA, msg: "1111", event: true,
+                room: roomId,
+                user: userA,
+                msg: "1111",
+                event: true,
             }),
             utils.mkMessage({
-                room: roomId, user: userA, msg: "2222", event: true,
+                room: roomId,
+                user: userA,
+                msg: "2222",
+                event: true,
             }),
             utils.mkMessage({
-                room: roomId, user: userA, msg: "3333", event: true,
+                room: roomId,
+                user: userA,
+                msg: "3333",
+                event: true,
             }),
         ];
 
-        it("should handle events in the same timeline", function() {
+        it("should handle events in the same timeline", function () {
             room.addLiveEvents(events);
 
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!))
-                .toBeLessThan(0);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[2].getId()!, events[1].getId()!))
-                .toBeGreaterThan(0);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[1].getId()!))
-                .toEqual(0);
+            expect(
+                room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!),
+            ).toBeLessThan(0);
+            expect(
+                room.getUnfilteredTimelineSet().compareEventOrdering(events[2].getId()!, events[1].getId()!),
+            ).toBeGreaterThan(0);
+            expect(
+                room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[1].getId()!),
+            ).toEqual(0);
         });
 
-        it("should handle events in adjacent timelines", function() {
+        it("should handle events in adjacent timelines", function () {
             const oldTimeline = room.addTimeline();
             oldTimeline.setNeighbouringTimeline(room.getLiveTimeline(), Direction.Forward);
             room.getLiveTimeline().setNeighbouringTimeline(oldTimeline, Direction.Backward);
@@ -743,42 +832,42 @@ describe("Room", function() {
             room.addEventsToTimeline([events[0]], false, oldTimeline);
             room.addLiveEvents([events[1]]);
 
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!))
-                .toBeLessThan(0);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[0].getId()!))
-                .toBeGreaterThan(0);
+            expect(
+                room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!),
+            ).toBeLessThan(0);
+            expect(
+                room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[0].getId()!),
+            ).toBeGreaterThan(0);
         });
 
-        it("should return null for events in non-adjacent timelines", function() {
+        it("should return null for events in non-adjacent timelines", function () {
             const oldTimeline = room.addTimeline();
 
             room.addEventsToTimeline([events[0]], false, oldTimeline);
             room.addLiveEvents([events[1]]);
 
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!))
-                .toBe(null);
-            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[0].getId()!))
-                .toBe(null);
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[1].getId()!)).toBe(
+                null,
+            );
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[1].getId()!, events[0].getId()!)).toBe(
+                null,
+            );
         });
 
-        it("should return null for unknown events", function() {
+        it("should return null for unknown events", function () {
             room.addLiveEvents(events);
 
-            expect(room.getUnfilteredTimelineSet()
-                .compareEventOrdering(events[0].getId()!, "xxx"))
-                .toBe(null);
-            expect(room.getUnfilteredTimelineSet()
-                .compareEventOrdering("xxx", events[0].getId()!))
-                .toBe(null);
-            expect(room.getUnfilteredTimelineSet()
-                .compareEventOrdering(events[0].getId()!, events[0].getId()!))
-                .toBe(0);
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, "xxx")).toBe(null);
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering("xxx", events[0].getId()!)).toBe(null);
+            expect(room.getUnfilteredTimelineSet().compareEventOrdering(events[0].getId()!, events[0].getId()!)).toBe(
+                0,
+            );
         });
     });
 
-    describe("getJoinedMembers", function() {
-        it("should return members whose membership is 'join'", function() {
-            mocked(room.currentState.getMembers).mockImplementation(function() {
+    describe("getJoinedMembers", function () {
+        it("should return members whose membership is 'join'", function () {
+            mocked(room.currentState.getMembers).mockImplementation(function () {
                 return [
                     { userId: "@alice:bar", membership: "join" } as unknown as RoomMember,
                     { userId: "@bob:bar", membership: "invite" } as unknown as RoomMember,
@@ -790,93 +879,110 @@ describe("Room", function() {
             expect(res[0].userId).toEqual("@alice:bar");
         });
 
-        it("should return an empty list if no membership is 'join'", function() {
-            mocked(room.currentState.getMembers).mockImplementation(function() {
-                return [
-                    { userId: "@bob:bar", membership: "invite" } as unknown as RoomMember,
-                ];
+        it("should return an empty list if no membership is 'join'", function () {
+            mocked(room.currentState.getMembers).mockImplementation(function () {
+                return [{ userId: "@bob:bar", membership: "invite" } as unknown as RoomMember];
             });
             const res = room.getJoinedMembers();
             expect(res.length).toEqual(0);
         });
     });
 
-    describe("hasMembershipState", function() {
-        it("should return true for a matching userId and membership",
-            function() {
-                mocked(room.currentState.getMember).mockImplementation(function(userId) {
-                    return {
-                        "@alice:bar": { userId: "@alice:bar", membership: "join" },
-                        "@bob:bar": { userId: "@bob:bar", membership: "invite" },
-                    }[userId] as unknown as RoomMember;
-                });
-                expect(room.hasMembershipState("@bob:bar", "invite")).toBe(true);
+    describe("hasMembershipState", function () {
+        it("should return true for a matching userId and membership", function () {
+            mocked(room.currentState.getMember).mockImplementation(function (userId) {
+                return {
+                    "@alice:bar": { userId: "@alice:bar", membership: "join" },
+                    "@bob:bar": { userId: "@bob:bar", membership: "invite" },
+                }[userId] as unknown as RoomMember;
             });
+            expect(room.hasMembershipState("@bob:bar", "invite")).toBe(true);
+        });
 
-        it("should return false if match membership but no match userId",
-            function() {
-                mocked(room.currentState.getMember).mockImplementation(function(userId) {
-                    return {
-                        "@alice:bar": { userId: "@alice:bar", membership: "join" },
-                    }[userId] as unknown as RoomMember;
-                });
-                expect(room.hasMembershipState("@bob:bar", "join")).toBe(false);
+        it("should return false if match membership but no match userId", function () {
+            mocked(room.currentState.getMember).mockImplementation(function (userId) {
+                return {
+                    "@alice:bar": { userId: "@alice:bar", membership: "join" },
+                }[userId] as unknown as RoomMember;
             });
+            expect(room.hasMembershipState("@bob:bar", "join")).toBe(false);
+        });
 
-        it("should return false if match userId but no match membership",
-            function() {
-                mocked(room.currentState.getMember).mockImplementation(function(userId) {
-                    return {
-                        "@alice:bar": { userId: "@alice:bar", membership: "join" },
-                    }[userId] as unknown as RoomMember;
-                });
-                expect(room.hasMembershipState("@alice:bar", "ban")).toBe(false);
+        it("should return false if match userId but no match membership", function () {
+            mocked(room.currentState.getMember).mockImplementation(function (userId) {
+                return {
+                    "@alice:bar": { userId: "@alice:bar", membership: "join" },
+                }[userId] as unknown as RoomMember;
             });
+            expect(room.hasMembershipState("@alice:bar", "ban")).toBe(false);
+        });
 
-        it("should return false if no match membership or userId",
-            function() {
-                mocked(room.currentState.getMember).mockImplementation(function(userId) {
-                    return {
-                        "@alice:bar": { userId: "@alice:bar", membership: "join" },
-                    }[userId] as unknown as RoomMember;
-                });
-                expect(room.hasMembershipState("@bob:bar", "invite")).toBe(false);
+        it("should return false if no match membership or userId", function () {
+            mocked(room.currentState.getMember).mockImplementation(function (userId) {
+                return {
+                    "@alice:bar": { userId: "@alice:bar", membership: "join" },
+                }[userId] as unknown as RoomMember;
             });
+            expect(room.hasMembershipState("@bob:bar", "invite")).toBe(false);
+        });
 
-        it("should return false if no members exist",
-            function() {
-                expect(room.hasMembershipState("@foo:bar", "join")).toBe(false);
-            });
+        it("should return false if no members exist", function () {
+            expect(room.hasMembershipState("@foo:bar", "join")).toBe(false);
+        });
     });
 
-    describe("recalculate", function() {
-        const setJoinRule = function(rule: JoinRule) {
-            room.addLiveEvents([utils.mkEvent({
-                type: EventType.RoomJoinRules, room: roomId, user: userA, content: {
-                    join_rule: rule,
-                }, event: true,
-            })]);
+    describe("recalculate", function () {
+        const setJoinRule = function (rule: JoinRule) {
+            room.addLiveEvents([
+                utils.mkEvent({
+                    type: EventType.RoomJoinRules,
+                    room: roomId,
+                    user: userA,
+                    content: {
+                        join_rule: rule,
+                    },
+                    event: true,
+                }),
+            ]);
         };
-        const setAltAliases = function(aliases: string[]) {
-            room.addLiveEvents([utils.mkEvent({
-                type: EventType.RoomCanonicalAlias, room: roomId, skey: "", content: {
-                    alt_aliases: aliases,
-                }, event: true,
-            })]);
+        const setAltAliases = function (aliases: string[]) {
+            room.addLiveEvents([
+                utils.mkEvent({
+                    type: EventType.RoomCanonicalAlias,
+                    room: roomId,
+                    skey: "",
+                    content: {
+                        alt_aliases: aliases,
+                    },
+                    event: true,
+                }),
+            ]);
         };
-        const setAlias = function(alias: string) {
-            room.addLiveEvents([utils.mkEvent({
-                type: EventType.RoomCanonicalAlias, room: roomId, skey: "", content: { alias }, event: true,
-            })]);
+        const setAlias = function (alias: string) {
+            room.addLiveEvents([
+                utils.mkEvent({
+                    type: EventType.RoomCanonicalAlias,
+                    room: roomId,
+                    skey: "",
+                    content: { alias },
+                    event: true,
+                }),
+            ]);
         };
-        const setRoomName = function(name: string) {
-            room.addLiveEvents([utils.mkEvent({
-                type: EventType.RoomName, room: roomId, user: userA, content: {
-                    name: name,
-                }, event: true,
-            })]);
+        const setRoomName = function (name: string) {
+            room.addLiveEvents([
+                utils.mkEvent({
+                    type: EventType.RoomName,
+                    room: roomId,
+                    user: userA,
+                    content: {
+                        name: name,
+                    },
+                    event: true,
+                }),
+            ]);
         };
-        const addMember = function(userId: string, state = "join", opts: any = {}) {
+        const addMember = function (userId: string, state = "join", opts: any = {}) {
             opts.room = roomId;
             opts.mship = state;
             opts.user = opts.user || userId;
@@ -887,53 +993,59 @@ describe("Room", function() {
             return event;
         };
 
-        beforeEach(function() {
+        beforeEach(function () {
             // no mocking
             room = new Room(roomId, new TestClient(userA).client, userA);
         });
 
-        describe("Room.recalculate => Stripped State Events", function() {
-            it("should set stripped state events as actual state events if the " +
-            "room is an invite room", function() {
-                const roomName = "flibble";
-
-                const event = addMember(userA, "invite");
-                event.event.unsigned = {};
-                event.event.unsigned.invite_room_state = [{
-                    type: EventType.RoomName,
-                    state_key: "",
-                    content: {
-                        name: roomName,
-                    },
-                    sender: "@bob:foobar",
-                }];
+        describe("Room.recalculate => Stripped State Events", function () {
+            it(
+                "should set stripped state events as actual state events if the " + "room is an invite room",
+                function () {
+                    const roomName = "flibble";
+
+                    const event = addMember(userA, "invite");
+                    event.event.unsigned = {};
+                    event.event.unsigned.invite_room_state = [
+                        {
+                            type: EventType.RoomName,
+                            state_key: "",
+                            content: {
+                                name: roomName,
+                            },
+                            sender: "@bob:foobar",
+                        },
+                    ];
 
-                room.recalculate();
-                expect(room.name).toEqual(roomName);
-            });
+                    room.recalculate();
+                    expect(room.name).toEqual(roomName);
+                },
+            );
 
-            it("should not clobber state events if it isn't an invite room", function() {
+            it("should not clobber state events if it isn't an invite room", function () {
                 const event = addMember(userA, "join");
                 const roomName = "flibble";
                 setRoomName(roomName);
                 const roomNameToIgnore = "ignoreme";
                 event.event.unsigned = {};
-                event.event.unsigned.invite_room_state = [{
-                    type: EventType.RoomName,
-                    state_key: "",
-                    content: {
-                        name: roomNameToIgnore,
+                event.event.unsigned.invite_room_state = [
+                    {
+                        type: EventType.RoomName,
+                        state_key: "",
+                        content: {
+                            name: roomNameToIgnore,
+                        },
+                        sender: "@bob:foobar",
                     },
-                    sender: "@bob:foobar",
-                }];
+                ];
 
                 room.recalculate();
                 expect(room.name).toEqual(roomName);
             });
         });
 
-        describe("Room.recalculate => Room Name using room summary", function() {
-            it("should use room heroes if available", function() {
+        describe("Room.recalculate => Room Name using room summary", function () {
+            it("should use room heroes if available", function () {
                 addMember(userA, "invite");
                 addMember(userB);
                 addMember(userC);
@@ -946,7 +1058,7 @@ describe("Room", function() {
                 expect(room.name).toEqual(`${userB} and 2 others`);
             });
 
-            it("missing hero member state reverts to mxid", function() {
+            it("missing hero member state reverts to mxid", function () {
                 room.setSummary({
                     "m.heroes": [userB],
                     "m.joined_member_count": 2,
@@ -956,7 +1068,7 @@ describe("Room", function() {
                 expect(room.name).toEqual(userB);
             });
 
-            it("uses hero name from state", function() {
+            it("uses hero name from state", function () {
                 const name = "Mr B";
                 addMember(userA, "invite");
                 addMember(userB, "join", { name });
@@ -968,7 +1080,7 @@ describe("Room", function() {
                 expect(room.name).toEqual(name);
             });
 
-            it("uses counts from summary", function() {
+            it("uses counts from summary", function () {
                 const name = "Mr B";
                 addMember(userB, "join", { name });
                 room.setSummary({
@@ -980,7 +1092,7 @@ describe("Room", function() {
                 expect(room.name).toEqual(`${name} and 98 others`);
             });
 
-            it("relies on heroes in case of absent counts", function() {
+            it("relies on heroes in case of absent counts", function () {
                 const nameB = "Mr Bean";
                 const nameC = "Mel C";
                 addMember(userB, "join", { name: nameB });
@@ -992,7 +1104,7 @@ describe("Room", function() {
                 expect(room.name).toEqual(`${nameB} and ${nameC}`);
             });
 
-            it("uses only heroes", function() {
+            it("uses only heroes", function () {
                 const nameB = "Mr Bean";
                 addMember(userB, "join", { name: nameB });
                 addMember(userC, "join");
@@ -1003,7 +1115,7 @@ describe("Room", function() {
                 expect(room.name).toEqual(nameB);
             });
 
-            it("reverts to empty room in case of self chat", function() {
+            it("reverts to empty room in case of self chat", function () {
                 room.setSummary({
                     "m.heroes": [],
                     "m.invited_member_count": 1,
@@ -1013,103 +1125,126 @@ describe("Room", function() {
             });
         });
 
-        describe("Room.recalculate => Room Name", function() {
-            it("should return the names of members in a private (invite join_rules)" +
-            " room if a room name and alias don't exist and there are >3 members.",
-            function() {
-                setJoinRule(JoinRule.Invite);
-                addMember(userA);
-                addMember(userB);
-                addMember(userC);
-                addMember(userD);
-                room.recalculate();
-                const name = room.name;
-                // we expect at least 1 member to be mentioned
-                const others = [userB, userC, userD];
-                let found = false;
-                for (let i = 0; i < others.length; i++) {
-                    if (name.indexOf(others[i]) !== -1) {
-                        found = true;
-                        break;
+        describe("Room.recalculate => Room Name", function () {
+            it(
+                "should return the names of members in a private (invite join_rules)" +
+                    " room if a room name and alias don't exist and there are >3 members.",
+                function () {
+                    setJoinRule(JoinRule.Invite);
+                    addMember(userA);
+                    addMember(userB);
+                    addMember(userC);
+                    addMember(userD);
+                    room.recalculate();
+                    const name = room.name;
+                    // we expect at least 1 member to be mentioned
+                    const others = [userB, userC, userD];
+                    let found = false;
+                    for (let i = 0; i < others.length; i++) {
+                        if (name.indexOf(others[i]) !== -1) {
+                            found = true;
+                            break;
+                        }
                     }
-                }
-                expect(found).toEqual(true);
-            });
+                    expect(found).toEqual(true);
+                },
+            );
 
-            it("should return the names of members in a private (invite join_rules)" +
-            " room if a room name and alias don't exist and there are >2 members.", function() {
-                setJoinRule(JoinRule.Invite);
-                addMember(userA);
-                addMember(userB);
-                addMember(userC);
-                room.recalculate();
-                const name = room.name;
-                expect(name.indexOf(userB)).not.toEqual(-1);
-                expect(name.indexOf(userC)).not.toEqual(-1);
-            });
+            it(
+                "should return the names of members in a private (invite join_rules)" +
+                    " room if a room name and alias don't exist and there are >2 members.",
+                function () {
+                    setJoinRule(JoinRule.Invite);
+                    addMember(userA);
+                    addMember(userB);
+                    addMember(userC);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name.indexOf(userB)).not.toEqual(-1);
+                    expect(name.indexOf(userC)).not.toEqual(-1);
+                },
+            );
 
-            it("should return the names of members in a public (public join_rules)" +
-            " room if a room name and alias don't exist and there are >2 members.", function() {
-                setJoinRule(JoinRule.Public);
-                addMember(userA);
-                addMember(userB);
-                addMember(userC);
-                room.recalculate();
-                const name = room.name;
-                expect(name.indexOf(userB)).not.toEqual(-1);
-                expect(name.indexOf(userC)).not.toEqual(-1);
-            });
+            it(
+                "should return the names of members in a public (public join_rules)" +
+                    " room if a room name and alias don't exist and there are >2 members.",
+                function () {
+                    setJoinRule(JoinRule.Public);
+                    addMember(userA);
+                    addMember(userB);
+                    addMember(userC);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name.indexOf(userB)).not.toEqual(-1);
+                    expect(name.indexOf(userC)).not.toEqual(-1);
+                },
+            );
 
-            it("should show the other user's name for public (public join_rules)" +
-            " rooms if a room name and alias don't exist and it is a 1:1-chat.", function() {
-                setJoinRule(JoinRule.Public);
-                addMember(userA);
-                addMember(userB);
-                room.recalculate();
-                const name = room.name;
-                expect(name.indexOf(userB)).not.toEqual(-1);
-            });
+            it(
+                "should show the other user's name for public (public join_rules)" +
+                    " rooms if a room name and alias don't exist and it is a 1:1-chat.",
+                function () {
+                    setJoinRule(JoinRule.Public);
+                    addMember(userA);
+                    addMember(userB);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name.indexOf(userB)).not.toEqual(-1);
+                },
+            );
 
-            it("should show the other user's name for private " +
-            "(invite join_rules) rooms if a room name and alias don't exist and it" +
-            " is a 1:1-chat.", function() {
-                setJoinRule(JoinRule.Invite);
-                addMember(userA);
-                addMember(userB);
-                room.recalculate();
-                const name = room.name;
-                expect(name.indexOf(userB)).not.toEqual(-1);
-            });
+            it(
+                "should show the other user's name for private " +
+                    "(invite join_rules) rooms if a room name and alias don't exist and it" +
+                    " is a 1:1-chat.",
+                function () {
+                    setJoinRule(JoinRule.Invite);
+                    addMember(userA);
+                    addMember(userB);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name.indexOf(userB)).not.toEqual(-1);
+                },
+            );
 
-            it("should show the other user's name for private" +
-            " (invite join_rules) rooms if you are invited to it.", function() {
-                setJoinRule(JoinRule.Invite);
-                addMember(userA, "invite", { user: userB });
-                addMember(userB);
-                room.recalculate();
-                const name = room.name;
-                expect(name.indexOf(userB)).not.toEqual(-1);
-            });
+            it(
+                "should show the other user's name for private" +
+                    " (invite join_rules) rooms if you are invited to it.",
+                function () {
+                    setJoinRule(JoinRule.Invite);
+                    addMember(userA, "invite", { user: userB });
+                    addMember(userB);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name.indexOf(userB)).not.toEqual(-1);
+                },
+            );
 
-            it("should show the room alias if one exists for private " +
-            "(invite join_rules) rooms if a room name doesn't exist.", function() {
-                const alias = "#room_alias:here";
-                setJoinRule(JoinRule.Invite);
-                setAlias(alias);
-                room.recalculate();
-                const name = room.name;
-                expect(name).toEqual(alias);
-            });
+            it(
+                "should show the room alias if one exists for private " +
+                    "(invite join_rules) rooms if a room name doesn't exist.",
+                function () {
+                    const alias = "#room_alias:here";
+                    setJoinRule(JoinRule.Invite);
+                    setAlias(alias);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name).toEqual(alias);
+                },
+            );
 
-            it("should show the room alias if one exists for public " +
-            "(public join_rules) rooms if a room name doesn't exist.", function() {
-                const alias = "#room_alias:here";
-                setJoinRule(JoinRule.Public);
-                setAlias(alias);
-                room.recalculate();
-                const name = room.name;
-                expect(name).toEqual(alias);
-            });
+            it(
+                "should show the room alias if one exists for public " +
+                    "(public join_rules) rooms if a room name doesn't exist.",
+                function () {
+                    const alias = "#room_alias:here";
+                    setJoinRule(JoinRule.Public);
+                    setAlias(alias);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name).toEqual(alias);
+                },
+            );
 
             it("should not show alt aliases if a room name does not exist", () => {
                 const alias = "#room_alias:here";
@@ -1119,8 +1254,7 @@ describe("Room", function() {
                 expect(name).not.toEqual(alias);
             });
 
-            it("should show the room name if one exists for private " +
-            "(invite join_rules) rooms.", function() {
+            it("should show the room name if one exists for private " + "(invite join_rules) rooms.", function () {
                 const roomName = "A mighty name indeed";
                 setJoinRule(JoinRule.Invite);
                 setRoomName(roomName);
@@ -1129,8 +1263,7 @@ describe("Room", function() {
                 expect(name).toEqual(roomName);
             });
 
-            it("should show the room name if one exists for public " +
-            "(public join_rules) rooms.", function() {
+            it("should show the room name if one exists for public " + "(public join_rules) rooms.", function () {
                 const roomName = "A mighty name indeed";
                 setJoinRule(JoinRule.Public);
                 setRoomName(roomName);
@@ -1138,63 +1271,66 @@ describe("Room", function() {
                 expect(room.name).toEqual(roomName);
             });
 
-            it("should return 'Empty room' for private (invite join_rules) rooms if" +
-            " a room name and alias don't exist and it is a self-chat.", function() {
-                setJoinRule(JoinRule.Invite);
-                addMember(userA);
-                room.recalculate();
-                expect(room.name).toEqual("Empty room");
-            });
+            it(
+                "should return 'Empty room' for private (invite join_rules) rooms if" +
+                    " a room name and alias don't exist and it is a self-chat.",
+                function () {
+                    setJoinRule(JoinRule.Invite);
+                    addMember(userA);
+                    room.recalculate();
+                    expect(room.name).toEqual("Empty room");
+                },
+            );
 
-            it("should return 'Empty room' for public (public join_rules) rooms if a" +
-            " room name and alias don't exist and it is a self-chat.", function() {
-                setJoinRule(JoinRule.Public);
-                addMember(userA);
+            it(
+                "should return 'Empty room' for public (public join_rules) rooms if a" +
+                    " room name and alias don't exist and it is a self-chat.",
+                function () {
+                    setJoinRule(JoinRule.Public);
+                    addMember(userA);
+                    room.recalculate();
+                    const name = room.name;
+                    expect(name).toEqual("Empty room");
+                },
+            );
+
+            it("should return 'Empty room' if there is no name, " + "alias or members in the room.", function () {
                 room.recalculate();
                 const name = room.name;
                 expect(name).toEqual("Empty room");
             });
 
-            it("should return 'Empty room' if there is no name, " +
-               "alias or members in the room.",
-            function() {
+            it("should return '[inviter display name] if state event " + "available", function () {
+                setJoinRule(JoinRule.Invite);
+                addMember(userB, "join", { name: "Alice" });
+                addMember(userA, "invite", { user: userA });
                 room.recalculate();
                 const name = room.name;
-                expect(name).toEqual("Empty room");
+                expect(name).toEqual("Alice");
             });
 
-            it("should return '[inviter display name] if state event " +
-               "available",
-            function() {
+            it("should return inviter mxid if display name not available", function () {
                 setJoinRule(JoinRule.Invite);
-                addMember(userB, 'join', { name: "Alice" });
+                addMember(userB);
                 addMember(userA, "invite", { user: userA });
                 room.recalculate();
                 const name = room.name;
-                expect(name).toEqual("Alice");
+                expect(name).toEqual(userB);
             });
-
-            it("should return inviter mxid if display name not available",
-                function() {
-                    setJoinRule(JoinRule.Invite);
-                    addMember(userB);
-                    addMember(userA, "invite", { user: userA });
-                    room.recalculate();
-                    const name = room.name;
-                    expect(name).toEqual(userB);
-                });
         });
     });
 
-    describe("receipts", function() {
+    describe("receipts", function () {
         const eventToAck = utils.mkMessage({
-            room: roomId, user: userA, msg: "PLEASE ACKNOWLEDGE MY EXISTENCE",
+            room: roomId,
+            user: userA,
+            msg: "PLEASE ACKNOWLEDGE MY EXISTENCE",
             event: true,
         });
 
         function mkReceipt(roomId: string, records: Array<ReturnType<typeof mkRecord>>) {
             const content: IContent = {};
-            records.forEach(function(r) {
+            records.forEach(function (r) {
                 if (!content[r.eventId]) {
                     content[r.eventId] = {};
                 }
@@ -1222,97 +1358,102 @@ describe("Room", function() {
             };
         }
 
-        describe("addReceipt", function() {
-            it("should store the receipt so it can be obtained via getReceiptsForEvent", function() {
+        describe("addReceipt", function () {
+            it("should store the receipt so it can be obtained via getReceiptsForEvent", function () {
                 const ts = 13787898424;
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(eventToAck.getId()!, "m.read", userB, ts),
-                ]));
-                expect(room.getReceiptsForEvent(eventToAck)).toEqual([{
-                    type: "m.read",
-                    userId: userB,
-                    data: {
-                        ts: ts,
+                room.addReceipt(mkReceipt(roomId, [mkRecord(eventToAck.getId()!, "m.read", userB, ts)]));
+                expect(room.getReceiptsForEvent(eventToAck)).toEqual([
+                    {
+                        type: "m.read",
+                        userId: userB,
+                        data: {
+                            ts: ts,
+                        },
                     },
-                }]);
+                ]);
             });
 
-            it("should emit an event when a receipt is added",
-                function() {
-                    const listener = jest.fn();
-                    room.on(RoomEvent.Receipt, listener);
+            it("should emit an event when a receipt is added", function () {
+                const listener = jest.fn();
+                room.on(RoomEvent.Receipt, listener);
 
-                    const ts = 13787898424;
+                const ts = 13787898424;
 
-                    const receiptEvent = mkReceipt(roomId, [
-                        mkRecord(eventToAck.getId()!, "m.read", userB, ts),
-                    ]);
+                const receiptEvent = mkReceipt(roomId, [mkRecord(eventToAck.getId()!, "m.read", userB, ts)]);
 
-                    room.addReceipt(receiptEvent);
-                    expect(listener).toHaveBeenCalledWith(receiptEvent, room);
-                });
+                room.addReceipt(receiptEvent);
+                expect(listener).toHaveBeenCalledWith(receiptEvent, room);
+            });
 
-            it("should clobber receipts based on type and user ID", function() {
+            it("should clobber receipts based on type and user ID", function () {
                 const nextEventToAck = utils.mkMessage({
-                    room: roomId, user: userA, msg: "I AM HERE YOU KNOW",
+                    room: roomId,
+                    user: userA,
+                    msg: "I AM HERE YOU KNOW",
                     event: true,
                 });
                 const ts = 13787898424;
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(eventToAck.getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(eventToAck.getId()!, "m.read", userB, ts)]));
                 const ts2 = 13787899999;
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(nextEventToAck.getId()!, "m.read", userB, ts2),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(nextEventToAck.getId()!, "m.read", userB, ts2)]));
                 expect(room.getReceiptsForEvent(eventToAck)).toEqual([]);
-                expect(room.getReceiptsForEvent(nextEventToAck)).toEqual([{
-                    type: "m.read",
-                    userId: userB,
-                    data: {
-                        ts: ts2,
+                expect(room.getReceiptsForEvent(nextEventToAck)).toEqual([
+                    {
+                        type: "m.read",
+                        userId: userB,
+                        data: {
+                            ts: ts2,
+                        },
                     },
-                }]);
+                ]);
             });
 
-            it("should persist multiple receipts for a single event ID", function() {
+            it("should persist multiple receipts for a single event ID", function () {
                 const ts = 13787898424;
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(eventToAck.getId()!, "m.read", userB, ts),
-                    mkRecord(eventToAck.getId()!, "m.read", userC, ts),
-                    mkRecord(eventToAck.getId()!, "m.read", userD, ts),
-                ]));
-                expect(room.getUsersReadUpTo(eventToAck)).toEqual(
-                    [userB, userC, userD],
+                room.addReceipt(
+                    mkReceipt(roomId, [
+                        mkRecord(eventToAck.getId()!, "m.read", userB, ts),
+                        mkRecord(eventToAck.getId()!, "m.read", userC, ts),
+                        mkRecord(eventToAck.getId()!, "m.read", userD, ts),
+                    ]),
                 );
+                expect(room.getUsersReadUpTo(eventToAck)).toEqual([userB, userC, userD]);
             });
 
-            it("should persist multiple receipts for a single receipt type", function() {
+            it("should persist multiple receipts for a single receipt type", function () {
                 const eventTwo = utils.mkMessage({
-                    room: roomId, user: userA, msg: "2222",
+                    room: roomId,
+                    user: userA,
+                    msg: "2222",
                     event: true,
                 });
                 const eventThree = utils.mkMessage({
-                    room: roomId, user: userA, msg: "3333",
+                    room: roomId,
+                    user: userA,
+                    msg: "3333",
                     event: true,
                 });
                 const ts = 13787898424;
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(eventToAck.getId()!, "m.read", userB, ts),
-                    mkRecord(eventTwo.getId()!, "m.read", userC, ts),
-                    mkRecord(eventThree.getId()!, "m.read", userD, ts),
-                ]));
+                room.addReceipt(
+                    mkReceipt(roomId, [
+                        mkRecord(eventToAck.getId()!, "m.read", userB, ts),
+                        mkRecord(eventTwo.getId()!, "m.read", userC, ts),
+                        mkRecord(eventThree.getId()!, "m.read", userD, ts),
+                    ]),
+                );
                 expect(room.getUsersReadUpTo(eventToAck)).toEqual([userB]);
                 expect(room.getUsersReadUpTo(eventTwo)).toEqual([userC]);
                 expect(room.getUsersReadUpTo(eventThree)).toEqual([userD]);
             });
 
-            it("should persist multiple receipts for a single user ID", function() {
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(eventToAck.getId()!, "m.delivered", userB, 13787898424),
-                    mkRecord(eventToAck.getId()!, "m.read", userB, 22222222),
-                    mkRecord(eventToAck.getId()!, "m.seen", userB, 33333333),
-                ]));
+            it("should persist multiple receipts for a single user ID", function () {
+                room.addReceipt(
+                    mkReceipt(roomId, [
+                        mkRecord(eventToAck.getId()!, "m.delivered", userB, 13787898424),
+                        mkRecord(eventToAck.getId()!, "m.read", userB, 22222222),
+                        mkRecord(eventToAck.getId()!, "m.seen", userB, 33333333),
+                    ]),
+                );
                 expect(room.getReceiptsForEvent(eventToAck)).toEqual([
                     {
                         type: "m.delivered",
@@ -1338,18 +1479,24 @@ describe("Room", function() {
                 ]);
             });
 
-            it("should prioritise the most recent event", function() {
+            it("should prioritise the most recent event", function () {
                 const events: MatrixEvent[] = [
                     utils.mkMessage({
-                        room: roomId, user: userA, msg: "1111",
+                        room: roomId,
+                        user: userA,
+                        msg: "1111",
                         event: true,
                     }),
                     utils.mkMessage({
-                        room: roomId, user: userA, msg: "2222",
+                        room: roomId,
+                        user: userA,
+                        msg: "2222",
                         event: true,
                     }),
                     utils.mkMessage({
-                        room: roomId, user: userA, msg: "3333",
+                        room: roomId,
+                        user: userA,
+                        msg: "3333",
                         event: true,
                     }),
                 ];
@@ -1358,36 +1505,36 @@ describe("Room", function() {
                 const ts = 13787898424;
 
                 // check it initialises correctly
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(events[0].getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(events[0].getId()!, "m.read", userB, ts)]));
                 expect(room.getEventReadUpTo(userB)).toEqual(events[0].getId());
 
                 // 2>0, so it should move forward
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(events[2].getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(events[2].getId()!, "m.read", userB, ts)]));
                 expect(room.getEventReadUpTo(userB)).toEqual(events[2].getId());
 
                 // 1<2, so it should stay put
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(events[1].getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(events[1].getId()!, "m.read", userB, ts)]));
                 expect(room.getEventReadUpTo(userB)).toEqual(events[2].getId());
             });
 
             it("should prioritise the most recent event even if it is synthetic", () => {
                 const events: MatrixEvent[] = [
                     utils.mkMessage({
-                        room: roomId, user: userA, msg: "1111",
+                        room: roomId,
+                        user: userA,
+                        msg: "1111",
                         event: true,
                     }),
                     utils.mkMessage({
-                        room: roomId, user: userA, msg: "2222",
+                        room: roomId,
+                        user: userA,
+                        msg: "2222",
                         event: true,
                     }),
                     utils.mkMessage({
-                        room: roomId, user: userA, msg: "3333",
+                        room: roomId,
+                        user: userA,
+                        msg: "3333",
                         event: true,
                     }),
                 ];
@@ -1396,59 +1543,45 @@ describe("Room", function() {
                 const ts = 13787898424;
 
                 // check it initialises correctly
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(events[0].getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(events[0].getId()!, "m.read", userB, ts)]));
                 expect(room.getEventReadUpTo(userB)).toEqual(events[0].getId());
 
                 // 2>0, so it should move forward
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(events[2].getId()!, "m.read", userB, ts),
-                ]), true);
+                room.addReceipt(mkReceipt(roomId, [mkRecord(events[2].getId()!, "m.read", userB, ts)]), true);
                 expect(room.getEventReadUpTo(userB)).toEqual(events[2].getId());
-                expect(room.getReceiptsForEvent(events[2])).toEqual([
-                    { data: { ts }, type: "m.read", userId: userB },
-                ]);
+                expect(room.getReceiptsForEvent(events[2])).toEqual([{ data: { ts }, type: "m.read", userId: userB }]);
 
                 // 1<2, so it should stay put
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(events[1].getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(events[1].getId()!, "m.read", userB, ts)]));
                 expect(room.getEventReadUpTo(userB)).toEqual(events[2].getId());
                 expect(room.getEventReadUpTo(userB, true)).toEqual(events[1].getId());
-                expect(room.getReceiptsForEvent(events[2])).toEqual([
-                    { data: { ts }, type: "m.read", userId: userB },
-                ]);
+                expect(room.getReceiptsForEvent(events[2])).toEqual([{ data: { ts }, type: "m.read", userId: userB }]);
             });
         });
 
-        describe("getUsersReadUpTo", function() {
-            it("should return user IDs read up to the given event", function() {
+        describe("getUsersReadUpTo", function () {
+            it("should return user IDs read up to the given event", function () {
                 const ts = 13787898424;
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(eventToAck.getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(eventToAck.getId()!, "m.read", userB, ts)]));
                 expect(room.getUsersReadUpTo(eventToAck)).toEqual([userB]);
             });
         });
 
-        describe("hasUserReadUpTo", function() {
-            it("should acknowledge if an event has been read", function() {
+        describe("hasUserReadUpTo", function () {
+            it("should acknowledge if an event has been read", function () {
                 const ts = 13787898424;
-                room.addReceipt(mkReceipt(roomId, [
-                    mkRecord(eventToAck.getId()!, "m.read", userB, ts),
-                ]));
+                room.addReceipt(mkReceipt(roomId, [mkRecord(eventToAck.getId()!, "m.read", userB, ts)]));
                 expect(room.hasUserReadEvent(userB, eventToAck.getId()!)).toEqual(true);
             });
-            it("return false for an unknown event", function() {
+            it("return false for an unknown event", function () {
                 expect(room.hasUserReadEvent(userB, "unknown_event")).toEqual(false);
             });
         });
     });
 
-    describe("tags", function() {
+    describe("tags", function () {
         function mkTags(roomId: string, tags: object) {
-            const content = { "tags": tags };
+            const content = { tags: tags };
             return new MatrixEvent({
                 content: content,
                 room_id: roomId,
@@ -1456,22 +1589,21 @@ describe("Room", function() {
             });
         }
 
-        describe("addTag", function() {
-            it("should set tags on rooms from event stream so " +
-               "they can be obtained by the tags property",
-            function() {
-                const tags = { "m.foo": { "order": 0.5 } };
-                room.addTags(mkTags(roomId, tags));
-                expect(room.tags).toEqual(tags);
-            });
+        describe("addTag", function () {
+            it(
+                "should set tags on rooms from event stream so " + "they can be obtained by the tags property",
+                function () {
+                    const tags = { "m.foo": { order: 0.5 } };
+                    room.addTags(mkTags(roomId, tags));
+                    expect(room.tags).toEqual(tags);
+                },
+            );
 
-            it("should emit Room.tags event when new tags are " +
-               "received on the event stream",
-            function() {
+            it("should emit Room.tags event when new tags are " + "received on the event stream", function () {
                 const listener = jest.fn();
                 room.on(RoomEvent.Tags, listener);
 
-                const tags = { "m.foo": { "order": 0.5 } };
+                const tags = { "m.foo": { order: 0.5 } };
                 const event = mkTags(roomId, tags);
                 room.addTags(event);
                 expect(listener).toHaveBeenCalledWith(event, room);
@@ -1482,62 +1614,70 @@ describe("Room", function() {
         });
     });
 
-    describe("addPendingEvent", function() {
-        it("should add pending events to the pendingEventList if " +
-                      "pendingEventOrdering == 'detached'", function() {
-            const client = (new TestClient(
-                "@alice:example.com", "alicedevice",
-            )).client;
+    describe("addPendingEvent", function () {
+        it("should add pending events to the pendingEventList if " + "pendingEventOrdering == 'detached'", function () {
+            const client = new TestClient("@alice:example.com", "alicedevice").client;
             client.supportsExperimentalThreads = () => true;
             const room = new Room(roomId, client, userA, {
                 pendingEventOrdering: PendingEventOrdering.Detached,
             });
             const eventA = utils.mkMessage({
-                room: roomId, user: userA, msg: "remote 1", event: true,
+                room: roomId,
+                user: userA,
+                msg: "remote 1",
+                event: true,
             });
             const eventB = utils.mkMessage({
-                room: roomId, user: userA, msg: "local 1", event: true,
+                room: roomId,
+                user: userA,
+                msg: "local 1",
+                event: true,
             });
             eventB.status = EventStatus.SENDING;
             const eventC = utils.mkMessage({
-                room: roomId, user: userA, msg: "remote 2", event: true,
+                room: roomId,
+                user: userA,
+                msg: "remote 2",
+                event: true,
             });
             room.addLiveEvents([eventA]);
             room.addPendingEvent(eventB, "TXN1");
             room.addLiveEvents([eventC]);
-            expect(room.timeline).toEqual(
-                [eventA, eventC],
-            );
-            expect(room.getPendingEvents()).toEqual(
-                [eventB],
-            );
+            expect(room.timeline).toEqual([eventA, eventC]);
+            expect(room.getPendingEvents()).toEqual([eventB]);
         });
 
-        it("should add pending events to the timeline if " +
-                      "pendingEventOrdering == 'chronological'", function() {
+        it("should add pending events to the timeline if " + "pendingEventOrdering == 'chronological'", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA, {
                 pendingEventOrdering: PendingEventOrdering.Chronological,
             });
             const eventA = utils.mkMessage({
-                room: roomId, user: userA, msg: "remote 1", event: true,
+                room: roomId,
+                user: userA,
+                msg: "remote 1",
+                event: true,
             });
             const eventB = utils.mkMessage({
-                room: roomId, user: userA, msg: "local 1", event: true,
+                room: roomId,
+                user: userA,
+                msg: "local 1",
+                event: true,
             });
             eventB.status = EventStatus.SENDING;
             const eventC = utils.mkMessage({
-                room: roomId, user: userA, msg: "remote 2", event: true,
+                room: roomId,
+                user: userA,
+                msg: "remote 2",
+                event: true,
             });
             room.addLiveEvents([eventA]);
             room.addPendingEvent(eventB, "TXN1");
             room.addLiveEvents([eventC]);
-            expect(room.timeline).toEqual(
-                [eventA, eventB, eventC],
-            );
+            expect(room.timeline).toEqual([eventA, eventB, eventC]);
         });
 
         it("should apply redactions eagerly in the pending event list", () => {
-            const client = (new TestClient("@alice:example.com", "alicedevice")).client;
+            const client = new TestClient("@alice:example.com", "alicedevice").client;
             const room = new Room(roomId, client, userA, {
                 pendingEventOrdering: PendingEventOrdering.Detached,
             });
@@ -1567,72 +1707,68 @@ describe("Room", function() {
         });
     });
 
-    describe("updatePendingEvent", function() {
-        it("should remove cancelled events from the pending list", function() {
-            const client = (new TestClient(
-                "@alice:example.com", "alicedevice",
-            )).client;
+    describe("updatePendingEvent", function () {
+        it("should remove cancelled events from the pending list", function () {
+            const client = new TestClient("@alice:example.com", "alicedevice").client;
             const room = new Room(roomId, client, userA, {
                 pendingEventOrdering: PendingEventOrdering.Detached,
             });
             const eventA = utils.mkMessage({
-                room: roomId, user: userA, event: true,
+                room: roomId,
+                user: userA,
+                event: true,
             });
             eventA.status = EventStatus.SENDING;
             const eventId = eventA.getId();
 
             room.addPendingEvent(eventA, "TXN1");
-            expect(room.getPendingEvents()).toEqual(
-                [eventA],
-            );
+            expect(room.getPendingEvents()).toEqual([eventA]);
 
             // the event has to have been failed or queued before it can be
             // cancelled
             room.updatePendingEvent(eventA, EventStatus.NOT_SENT);
 
             let callCount = 0;
-            room.on(RoomEvent.LocalEchoUpdated,
-                function(event, emitRoom, oldEventId, oldStatus) {
-                    expect(event).toEqual(eventA);
-                    expect(event.status).toEqual(EventStatus.CANCELLED);
-                    expect(emitRoom).toEqual(room);
-                    expect(oldEventId).toEqual(eventId);
-                    expect(oldStatus).toEqual(EventStatus.NOT_SENT);
-                    callCount++;
-                });
+            room.on(RoomEvent.LocalEchoUpdated, function (event, emitRoom, oldEventId, oldStatus) {
+                expect(event).toEqual(eventA);
+                expect(event.status).toEqual(EventStatus.CANCELLED);
+                expect(emitRoom).toEqual(room);
+                expect(oldEventId).toEqual(eventId);
+                expect(oldStatus).toEqual(EventStatus.NOT_SENT);
+                callCount++;
+            });
 
             room.updatePendingEvent(eventA, EventStatus.CANCELLED);
             expect(room.getPendingEvents()).toEqual([]);
             expect(callCount).toEqual(1);
         });
 
-        it("should remove cancelled events from the timeline", function() {
+        it("should remove cancelled events from the timeline", function () {
             const room = new Room(roomId, null!, userA);
             const eventA = utils.mkMessage({
-                room: roomId, user: userA, event: true,
+                room: roomId,
+                user: userA,
+                event: true,
             });
             eventA.status = EventStatus.SENDING;
             const eventId = eventA.getId();
 
             room.addPendingEvent(eventA, "TXN1");
-            expect(room.getLiveTimeline().getEvents()).toEqual(
-                [eventA],
-            );
+            expect(room.getLiveTimeline().getEvents()).toEqual([eventA]);
 
             // the event has to have been failed or queued before it can be
             // cancelled
             room.updatePendingEvent(eventA, EventStatus.NOT_SENT);
 
             let callCount = 0;
-            room.on(RoomEvent.LocalEchoUpdated,
-                function(event, emitRoom, oldEventId, oldStatus) {
-                    expect(event).toEqual(eventA);
-                    expect(event.status).toEqual(EventStatus.CANCELLED);
-                    expect(emitRoom).toEqual(room);
-                    expect(oldEventId).toEqual(eventId);
-                    expect(oldStatus).toEqual(EventStatus.NOT_SENT);
-                    callCount++;
-                });
+            room.on(RoomEvent.LocalEchoUpdated, function (event, emitRoom, oldEventId, oldStatus) {
+                expect(event).toEqual(eventA);
+                expect(event.status).toEqual(EventStatus.CANCELLED);
+                expect(emitRoom).toEqual(room);
+                expect(oldEventId).toEqual(eventId);
+                expect(oldStatus).toEqual(EventStatus.NOT_SENT);
+                callCount++;
+            });
 
             room.updatePendingEvent(eventA, EventStatus.CANCELLED);
             expect(room.getLiveTimeline().getEvents()).toEqual([]);
@@ -1640,20 +1776,22 @@ describe("Room", function() {
         });
     });
 
-    describe("loadMembersIfNeeded", function() {
+    describe("loadMembersIfNeeded", function () {
         function createClientMock(
             serverResponse: Error | MatrixEvent[],
             storageResponse: MatrixEvent[] | Error | null = null,
         ) {
             return {
-                getEventMapper: function() {
+                getEventMapper: function () {
                     // events should already be MatrixEvents
-                    return function(event: MatrixEvent) {return event;};
+                    return function (event: MatrixEvent) {
+                        return event;
+                    };
                 },
                 isCryptoEnabled() {
                     return true;
                 },
-                isRoomEncrypted: function() {
+                isRoomEncrypted: function () {
                     return false;
                 },
                 members: jest.fn().mockImplementation(() => {
@@ -1666,14 +1804,14 @@ describe("Room", function() {
                 store: {
                     storageResponse,
                     storedMembers: [] as IStateEventWithRoomId[] | null,
-                    getOutOfBandMembers: function() {
+                    getOutOfBandMembers: function () {
                         if (this.storageResponse instanceof Error) {
                             return Promise.reject(this.storageResponse);
                         } else {
                             return Promise.resolve(this.storageResponse);
                         }
                     },
-                    setOutOfBandMembers: function(roomId: string, memberEvents: IStateEventWithRoomId[]) {
+                    setOutOfBandMembers: function (roomId: string, memberEvents: IStateEventWithRoomId[]) {
                         this.storedMembers = memberEvents;
                         return Promise.resolve();
                     },
@@ -1692,7 +1830,7 @@ describe("Room", function() {
             name: "User A",
         });
 
-        it("should load members from server on first call", async function() {
+        it("should load members from server on first call", async function () {
             const client = createClientMock([memberEvent]);
             const room = new Room(roomId, client as any, null!, { lazyLoadMembers: true });
             await room.loadMembersIfNeeded();
@@ -1703,7 +1841,7 @@ describe("Room", function() {
             expect(storedMembers[0].event_id).toEqual(memberEvent.getId());
         });
 
-        it("should take members from storage if available", async function() {
+        it("should take members from storage if available", async function () {
             const memberEvent2 = utils.mkMembership({
                 user: "@user_a:bar",
                 mship: "join",
@@ -1720,7 +1858,7 @@ describe("Room", function() {
             expect(memberA.name).toEqual("User A");
         });
 
-        it("should allow retry on error", async function() {
+        it("should allow retry on error", async function () {
             const client = createClientMock(new Error("server says no"));
             const room = new Room(roomId, client as any, null!, { lazyLoadMembers: true });
             let hasThrown = false;
@@ -1738,14 +1876,13 @@ describe("Room", function() {
         });
     });
 
-    describe("getMyMembership", function() {
-        it("should return synced membership if membership isn't available yet",
-            function() {
-                const room = new Room(roomId, null!, userA);
-                room.updateMyMembership(JoinRule.Invite);
-                expect(room.getMyMembership()).toEqual(JoinRule.Invite);
-            });
-        it("should emit a Room.myMembership event on a change", function() {
+    describe("getMyMembership", function () {
+        it("should return synced membership if membership isn't available yet", function () {
+            const room = new Room(roomId, null!, userA);
+            room.updateMyMembership(JoinRule.Invite);
+            expect(room.getMyMembership()).toEqual(JoinRule.Invite);
+        });
+        it("should emit a Room.myMembership event on a change", function () {
             const room = new Room(roomId, null!, userA);
             const events: {
                 membership: string;
@@ -1757,7 +1894,7 @@ describe("Room", function() {
             room.updateMyMembership(JoinRule.Invite);
             expect(room.getMyMembership()).toEqual(JoinRule.Invite);
             expect(events[0]).toEqual({ membership: "invite", oldMembership: undefined });
-            events.splice(0);   //clear
+            events.splice(0); //clear
             room.updateMyMembership(JoinRule.Invite);
             expect(events.length).toEqual(0);
             room.updateMyMembership("join");
@@ -1805,27 +1942,29 @@ describe("Room", function() {
         });
     });
 
-    describe("guessDMUserId", function() {
-        it("should return first hero id", function() {
+    describe("guessDMUserId", function () {
+        it("should return first hero id", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.setSummary({
-                'm.heroes': [userB],
-                'm.joined_member_count': 1,
-                'm.invited_member_count': 1,
+                "m.heroes": [userB],
+                "m.joined_member_count": 1,
+                "m.invited_member_count": 1,
             });
             expect(room.guessDMUserId()).toEqual(userB);
         });
-        it("should return first member that isn't self", function() {
+        it("should return first member that isn't self", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
-            room.addLiveEvents([utils.mkMembership({
-                user: userB,
-                mship: "join",
-                room: roomId,
-                event: true,
-            })]);
+            room.addLiveEvents([
+                utils.mkMembership({
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                }),
+            ]);
             expect(room.guessDMUserId()).toEqual(userB);
         });
-        it("should return self if only member present", function() {
+        it("should return self if only member present", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             expect(room.guessDMUserId()).toEqual(userA);
         });
@@ -1861,8 +2000,8 @@ describe("Room", function() {
         });
     });
 
-    describe("maySendMessage", function() {
-        it("should return false if synced membership not join", function() {
+    describe("maySendMessage", function () {
+        it("should return false if synced membership not join", function () {
             const room = new Room(roomId, { isRoomEncrypted: () => false } as any, userA);
             room.updateMyMembership(JoinRule.Invite);
             expect(room.maySendMessage()).toEqual(false);
@@ -1873,130 +2012,183 @@ describe("Room", function() {
         });
     });
 
-    describe("getDefaultRoomName", function() {
-        it("should return 'Empty room' if a user is the only member", function() {
+    describe("getDefaultRoomName", function () {
+        it("should return 'Empty room' if a user is the only member", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
         });
 
-        it("should return a display name if one other member is in the room", function() {
+        it("should return a display name if one other member is in the room", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
             ]);
             expect(room.getDefaultRoomName(userA)).toEqual("User B");
         });
 
-        it("should return a display name if one other member is banned", function() {
+        it("should return a display name if one other member is banned", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "ban",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "ban",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
             ]);
             expect(room.getDefaultRoomName(userA)).toEqual("Empty room (was User B)");
         });
 
-        it("should return a display name if one other member is invited", function() {
+        it("should return a display name if one other member is invited", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "invite",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "invite",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
             ]);
             expect(room.getDefaultRoomName(userA)).toEqual("User B");
         });
 
-        it("should return 'Empty room (was User B)' if User B left the room", function() {
+        it("should return 'Empty room (was User B)' if User B left the room", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "leave",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "leave",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
             ]);
             expect(room.getDefaultRoomName(userA)).toEqual("Empty room (was User B)");
         });
 
-        it("should return 'User B and User C' if in a room with two other users", function() {
+        it("should return 'User B and User C' if in a room with two other users", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkMembership({
-                    user: userC, mship: "join",
-                    room: roomId, event: true, name: "User C",
+                    user: userC,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User C",
                 }),
             ]);
             expect(room.getDefaultRoomName(userA)).toEqual("User B and User C");
         });
 
-        it("should return 'User B and 2 others' if in a room with three other users", function() {
+        it("should return 'User B and 2 others' if in a room with three other users", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkMembership({
-                    user: userC, mship: "join",
-                    room: roomId, event: true, name: "User C",
+                    user: userC,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User C",
                 }),
                 utils.mkMembership({
-                    user: userD, mship: "join",
-                    room: roomId, event: true, name: "User D",
+                    user: userD,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User D",
                 }),
             ]);
             expect(room.getDefaultRoomName(userA)).toEqual("User B and 2 others");
         });
     });
 
-    describe("io.element.functional_users", function() {
-        it("should return a display name (default behaviour) if no one is marked as a functional member", function() {
+    describe("io.element.functional_users", function () {
+        it("should return a display name (default behaviour) if no one is marked as a functional member", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkEvent({
-                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
-                    room: roomId, event: true,
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
                     content: {
                         service_members: [],
                     },
@@ -2005,16 +2197,22 @@ describe("Room", function() {
             expect(room.getDefaultRoomName(userA)).toEqual("User B");
         });
 
-        it("should return a display name (default behaviour) if service members is a number (invalid)", function() {
+        it("should return a display name (default behaviour) if service members is a number (invalid)", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkEvent({
                     type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
@@ -2029,20 +2227,28 @@ describe("Room", function() {
             expect(room.getDefaultRoomName(userA)).toEqual("User B");
         });
 
-        it("should return a display name (default behaviour) if service members is a string (invalid)", function() {
+        it("should return a display name (default behaviour) if service members is a string (invalid)", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkEvent({
-                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
-                    room: roomId, event: true,
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
                     content: {
                         service_members: userB,
                     },
@@ -2051,20 +2257,28 @@ describe("Room", function() {
             expect(room.getDefaultRoomName(userA)).toEqual("User B");
         });
 
-        it("should return 'Empty room' if the only other member is a functional member", function() {
+        it("should return 'Empty room' if the only other member is a functional member", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkEvent({
-                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
-                    room: roomId, event: true,
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
                     content: {
                         service_members: [userB],
                     },
@@ -2073,24 +2287,36 @@ describe("Room", function() {
             expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
         });
 
-        it("should return 'User B' if User B is the only other member who isn't a functional member", function() {
+        it("should return 'User B' if User B is the only other member who isn't a functional member", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkMembership({
-                    user: userC, mship: "join",
-                    room: roomId, event: true, name: "User C",
+                    user: userC,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User C",
                 }),
                 utils.mkEvent({
-                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
-                    room: roomId, event: true, user: userA,
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
+                    user: userA,
                     content: {
                         service_members: [userC],
                     },
@@ -2099,24 +2325,36 @@ describe("Room", function() {
             expect(room.getDefaultRoomName(userA)).toEqual("User B");
         });
 
-        it("should return 'Empty room' if all other members are functional members", function() {
+        it("should return 'Empty room' if all other members are functional members", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkMembership({
-                    user: userC, mship: "join",
-                    room: roomId, event: true, name: "User C",
+                    user: userC,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User C",
                 }),
                 utils.mkEvent({
-                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
-                    room: roomId, event: true, user: userA,
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
+                    user: userA,
                     content: {
                         service_members: [userB, userC],
                     },
@@ -2125,20 +2363,29 @@ describe("Room", function() {
             expect(room.getDefaultRoomName(userA)).toEqual("Empty room");
         });
 
-        it("should not break if an unjoined user is marked as a service user", function() {
+        it("should not break if an unjoined user is marked as a service user", function () {
             const room = new Room(roomId, new TestClient(userA).client, userA);
             room.addLiveEvents([
                 utils.mkMembership({
-                    user: userA, mship: "join",
-                    room: roomId, event: true, name: "User A",
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
                 }),
                 utils.mkMembership({
-                    user: userB, mship: "join",
-                    room: roomId, event: true, name: "User B",
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
                 }),
                 utils.mkEvent({
-                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, skey: "",
-                    room: roomId, event: true, user: userA,
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
+                    user: userA,
                     content: {
                         service_members: [userC],
                     },
@@ -2148,27 +2395,25 @@ describe("Room", function() {
         });
     });
 
-    describe("threads", function() {
+    describe("threads", function () {
         beforeEach(() => {
-            const client = (new TestClient(
-                "@alice:example.com", "alicedevice",
-            )).client;
+            const client = new TestClient("@alice:example.com", "alicedevice").client;
             room = new Room(roomId, client, userA);
             client.getRoom = () => room;
         });
 
-        it("allow create threads without a root event", function() {
+        it("allow create threads without a root event", function () {
             const eventWithoutARootEvent = new MatrixEvent({
                 event_id: "$123",
                 room_id: roomId,
                 content: {
                     "m.relates_to": {
-                        "rel_type": "m.thread",
-                        "event_id": "$000",
+                        rel_type: "m.thread",
+                        event_id: "$000",
                     },
                 },
                 unsigned: {
-                    "age": 1,
+                    age: 1,
                 },
             });
 
@@ -2213,19 +2458,20 @@ describe("Room", function() {
             const threadResponseEdit = mkEdit(threadResponse);
             threadResponseEdit.localTimestamp += 2000;
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        [THREAD_RELATION_TYPE.name]: {
-                            latest_event: threadResponse.event,
-                            count: 2,
-                            current_user_participated: true,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            [THREAD_RELATION_TYPE.name]: {
+                                latest_event: threadResponse.event,
+                                count: 2,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             let prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents([randomMessage, threadRoot, threadResponse]);
@@ -2235,22 +2481,23 @@ describe("Room", function() {
             expect(thread.replyToEvent.event).toEqual(threadResponse.event);
             expect(thread.replyToEvent.getContent().body).toBe(threadResponse.getContent().body);
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        [THREAD_RELATION_TYPE.name]: {
-                            latest_event: {
-                                ...threadResponse.event,
-                                content: threadResponseEdit.event.content,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            [THREAD_RELATION_TYPE.name]: {
+                                latest_event: {
+                                    ...threadResponse.event,
+                                    content: threadResponseEdit.event.content,
+                                },
+                                count: 2,
+                                current_user_participated: true,
                             },
-                            count: 2,
-                            current_user_participated: true,
                         },
                     },
-                },
-            });
+                });
 
             prom = emitPromise(room, ThreadEvent.Update);
             room.addLiveEvents([threadResponseEdit]);
@@ -2268,19 +2515,20 @@ describe("Room", function() {
             const threadResponse2 = mkThreadResponse(threadRoot);
             threadResponse2.localTimestamp += 2000;
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        [THREAD_RELATION_TYPE.name]: {
-                            latest_event: threadResponse2.event,
-                            count: 2,
-                            current_user_participated: true,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            [THREAD_RELATION_TYPE.name]: {
+                                latest_event: threadResponse2.event,
+                                count: 2,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             let prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents([threadRoot, threadResponse1, threadResponse2]);
@@ -2290,30 +2538,31 @@ describe("Room", function() {
             expect(thread).toHaveLength(2);
             expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
 
-            thread.timelineSet.addEventToTimeline(
-                threadResponse1,
-                thread.liveTimeline,
-                { toStartOfTimeline: true, fromCache: false, roomState: thread.roomState },
-            );
-            thread.timelineSet.addEventToTimeline(
-                threadResponse2,
-                thread.liveTimeline,
-                { toStartOfTimeline: true, fromCache: false, roomState: thread.roomState },
-            );
-
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        [THREAD_RELATION_TYPE.name]: {
-                            latest_event: threadResponse2.event,
-                            count: 1,
-                            current_user_participated: true,
+            thread.timelineSet.addEventToTimeline(threadResponse1, thread.liveTimeline, {
+                toStartOfTimeline: true,
+                fromCache: false,
+                roomState: thread.roomState,
+            });
+            thread.timelineSet.addEventToTimeline(threadResponse2, thread.liveTimeline, {
+                toStartOfTimeline: true,
+                fromCache: false,
+                roomState: thread.roomState,
+            });
+
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            [THREAD_RELATION_TYPE.name]: {
+                                latest_event: threadResponse2.event,
+                                count: 1,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             prom = emitPromise(thread, ThreadEvent.Update);
             const threadResponse1Redaction = mkRedaction(threadResponse1);
@@ -2334,19 +2583,20 @@ describe("Room", function() {
             threadResponse2.localTimestamp += 2000;
             const threadResponse2Reaction = mkReaction(threadResponse2);
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        [THREAD_RELATION_TYPE.name]: {
-                            latest_event: threadResponse2.event,
-                            count: 2,
-                            current_user_participated: true,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            [THREAD_RELATION_TYPE.name]: {
+                                latest_event: threadResponse2.event,
+                                count: 2,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             const prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents([threadRoot, threadResponse1, threadResponse2, threadResponse2Reaction]);
@@ -2373,19 +2623,20 @@ describe("Room", function() {
             threadResponse2.localTimestamp += 2000;
             const threadResponse2Reaction = mkReaction(threadResponse2);
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        [THREAD_RELATION_TYPE.name]: {
-                            latest_event: threadResponse2.event,
-                            count: 2,
-                            current_user_participated: true,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            [THREAD_RELATION_TYPE.name]: {
+                                latest_event: threadResponse2.event,
+                                count: 2,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             let prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents([threadRoot, threadResponse1, threadResponse2, threadResponse2Reaction]);
@@ -2407,10 +2658,11 @@ describe("Room", function() {
             Thread.setServerSideSupport(FeatureSupport.Stable);
             Thread.setServerSideListSupport(FeatureSupport.Stable);
 
-            room.client.createThreadListMessagesRequest = () => Promise.resolve({
-                chunk: [],
-                state: [],
-            });
+            room.client.createThreadListMessagesRequest = () =>
+                Promise.resolve({
+                    chunk: [],
+                    state: [],
+                });
 
             await room.createThreadsTimelineSets();
             await room.fetchRoomThreads();
@@ -2421,19 +2673,20 @@ describe("Room", function() {
             const threadResponse2 = mkThreadResponse(threadRoot);
             threadResponse2.localTimestamp += 2000;
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        "m.thread": {
-                            latest_event: threadResponse2.event,
-                            count: 2,
-                            current_user_participated: true,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            "m.thread": {
+                                latest_event: threadResponse2.event,
+                                count: 2,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             let prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents([threadRoot, threadResponse1, threadResponse2]);
@@ -2443,19 +2696,20 @@ describe("Room", function() {
             expect(thread).toHaveLength(2);
             expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        "m.thread": {
-                            latest_event: threadResponse1.event,
-                            count: 1,
-                            current_user_participated: true,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            "m.thread": {
+                                latest_event: threadResponse1.event,
+                                count: 1,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             prom = emitPromise(room, ThreadEvent.Update);
             const threadResponse2Redaction = mkRedaction(threadResponse2);
@@ -2465,19 +2719,20 @@ describe("Room", function() {
             expect(thread).toHaveLength(1);
             expect(thread.replyToEvent.getId()).toBe(threadResponse1.getId());
 
-            room.client.fetchRoomEvent = (eventId: string) => Promise.resolve({
-                ...threadRoot.event,
-                unsigned: {
-                    "age": 123,
-                    "m.relations": {
-                        "m.thread": {
-                            latest_event: threadRoot.event,
-                            count: 0,
-                            current_user_participated: true,
+            room.client.fetchRoomEvent = (eventId: string) =>
+                Promise.resolve({
+                    ...threadRoot.event,
+                    unsigned: {
+                        "age": 123,
+                        "m.relations": {
+                            "m.thread": {
+                                latest_event: threadRoot.event,
+                                count: 0,
+                                current_user_participated: true,
+                            },
                         },
                     },
-                },
-            });
+                });
 
             prom = emitPromise(room, ThreadEvent.Delete);
             const prom2 = emitPromise(room, RoomEvent.Timeline);
@@ -2565,14 +2820,7 @@ describe("Room", function() {
             const reaction2Redaction = mkRedaction(reply1);
 
             const roots = new Set([threadRoot.getId()!]);
-            const events = [
-                threadRoot,
-                threadResponse1,
-                reply1,
-                reaction1,
-                reaction2,
-                reaction2Redaction,
-            ];
+            const events = [threadRoot, threadResponse1, reply1, reaction1, reaction2, reaction2Redaction];
 
             expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInRoom).toBeTruthy();
             expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInThread).toBeFalsy();
@@ -2591,12 +2839,7 @@ describe("Room", function() {
             const reply2 = mkReply(reply1);
 
             const roots = new Set([threadRoot.getId()!]);
-            const events = [
-                threadRoot,
-                threadResponse1,
-                reply1,
-                reply2,
-            ];
+            const events = [threadRoot, threadResponse1, reply1, reply2];
 
             expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInRoom).toBeTruthy();
             expect(room.eventShouldLiveIn(reply1, events, roots).shouldLiveInThread).toBeFalsy();
@@ -2611,33 +2854,24 @@ describe("Room", function() {
             const threadResponse = mkThreadResponse(threadRoot);
             const threadReaction = mkReaction(threadResponse);
 
-            const events = [
-                threadRoot,
-                rootReaction,
-                threadResponse,
-                threadReaction,
-            ];
+            const events = [threadRoot, rootReaction, threadResponse, threadReaction];
 
             room.addLiveEvents(events);
 
             const thread = threadRoot.getThread()!;
             expect(thread.rootEvent).toBe(threadRoot);
 
-            const rootRelations = thread.timelineSet.relations.getChildEventsForEvent(
-                threadRoot.getId()!,
-                RelationType.Annotation,
-                EventType.Reaction,
-            )!.getSortedAnnotationsByKey();
+            const rootRelations = thread.timelineSet.relations
+                .getChildEventsForEvent(threadRoot.getId()!, RelationType.Annotation, EventType.Reaction)!
+                .getSortedAnnotationsByKey();
             expect(rootRelations).toHaveLength(1);
             expect(rootRelations![0][0]).toEqual(rootReaction.getRelation()!.key);
             expect(rootRelations![0][1].size).toEqual(1);
             expect(rootRelations![0][1].has(rootReaction)).toBeTruthy();
 
-            const responseRelations = thread.timelineSet.relations.getChildEventsForEvent(
-                threadResponse.getId()!,
-                RelationType.Annotation,
-                EventType.Reaction,
-            )!.getSortedAnnotationsByKey();
+            const responseRelations = thread.timelineSet.relations
+                .getChildEventsForEvent(threadResponse.getId()!, RelationType.Annotation, EventType.Reaction)!
+                .getSortedAnnotationsByKey();
             expect(responseRelations).toHaveLength(1);
             expect(responseRelations![0][0]).toEqual(threadReaction.getRelation()!.key);
             expect(responseRelations![0][1].size).toEqual(1);
@@ -2651,7 +2885,7 @@ describe("Room", function() {
 
         it("handles missing receipt type", () => {
             room.getReadReceiptForUserId = (userId, ignore, receiptType): WrappedReceipt | null => {
-                return receiptType === ReceiptType.ReadPrivate ? { eventId: "eventId" } as WrappedReceipt : null;
+                return receiptType === ReceiptType.ReadPrivate ? ({ eventId: "eventId" } as WrappedReceipt) : null;
             };
 
             expect(room.getEventReadUpTo(userA)).toEqual("eventId");
@@ -2670,9 +2904,12 @@ describe("Room", function() {
                 };
 
                 for (let i = 1; i <= 2; i++) {
-                    room.getUnfilteredTimelineSet = () => ({ compareEventOrdering: (event1, event2) => {
-                        return (event1 === `eventId${i}`) ? 1 : -1;
-                    } } as EventTimelineSet);
+                    room.getUnfilteredTimelineSet = () =>
+                        ({
+                            compareEventOrdering: (event1, event2) => {
+                                return event1 === `eventId${i}` ? 1 : -1;
+                            },
+                        } as EventTimelineSet);
 
                     expect(room.getEventReadUpTo(userA)).toEqual(`eventId${i}`);
                 }
@@ -2681,9 +2918,10 @@ describe("Room", function() {
             describe("correctly compares by timestamp", () => {
                 it("should correctly compare, if we have all receipts", () => {
                     for (let i = 1; i <= 2; i++) {
-                        room.getUnfilteredTimelineSet = () => ({
-                            compareEventOrdering: (_1, _2) => null,
-                        } as EventTimelineSet);
+                        room.getUnfilteredTimelineSet = () =>
+                            ({
+                                compareEventOrdering: (_1, _2) => null,
+                            } as EventTimelineSet);
                         room.getReadReceiptForUserId = (userId, ignore, receiptType): WrappedReceipt | null => {
                             if (receiptType === ReceiptType.ReadPrivate) {
                                 return { eventId: "eventId1", data: { ts: i === 1 ? 2 : 1 } } as WrappedReceipt;
@@ -2699,9 +2937,10 @@ describe("Room", function() {
                 });
 
                 it("should correctly compare, if private read receipt is missing", () => {
-                    room.getUnfilteredTimelineSet = () => ({
-                        compareEventOrdering: (_1, _2) => null,
-                    } as EventTimelineSet);
+                    room.getUnfilteredTimelineSet = () =>
+                        ({
+                            compareEventOrdering: (_1, _2) => null,
+                        } as EventTimelineSet);
                     room.getReadReceiptForUserId = (userId, ignore, receiptType): WrappedReceipt | null => {
                         if (receiptType === ReceiptType.Read) {
                             return { eventId: "eventId2", data: { ts: 1 } } as WrappedReceipt;
@@ -2715,9 +2954,10 @@ describe("Room", function() {
 
             describe("fallback precedence", () => {
                 beforeAll(() => {
-                    room.getUnfilteredTimelineSet = () => ({
-                        compareEventOrdering: (_1, _2) => null,
-                    } as EventTimelineSet);
+                    room.getUnfilteredTimelineSet = () =>
+                        ({
+                            compareEventOrdering: (_1, _2) => null,
+                        } as EventTimelineSet);
                 });
 
                 it("should give precedence to m.read.private", () => {
@@ -2833,11 +3073,11 @@ describe("Room", function() {
     });
 
     describe("hasThreadUnreadNotification", () => {
-        it('has no notifications by default', () => {
+        it("has no notifications by default", () => {
             expect(room.hasThreadUnreadNotification()).toBe(false);
         });
 
-        it('main timeline notification does not affect this', () => {
+        it("main timeline notification does not affect this", () => {
             room.setUnreadNotificationCount(NotificationCountType.Highlight, 1);
             expect(room.hasThreadUnreadNotification()).toBe(false);
             room.setUnreadNotificationCount(NotificationCountType.Total, 1);
@@ -2847,7 +3087,7 @@ describe("Room", function() {
             expect(room.hasThreadUnreadNotification()).toBe(true);
         });
 
-        it('lets you reset', () => {
+        it("lets you reset", () => {
             room.setThreadUnreadNotificationCount("123", NotificationCountType.Highlight, 1);
             expect(room.hasThreadUnreadNotification()).toBe(true);
 
@@ -2893,23 +3133,26 @@ describe("Room", function() {
         client.crypto = {
             decryptEvent: jest.fn().mockResolvedValue({ clearEvent: { body: "enc" } }),
         } as unknown as Crypto;
-        client.store.getPendingEvents = jest.fn(async roomId => [{
-            event_id: "$1:server",
-            type: "m.room.message",
-            content: { body: "1" },
-            sender: "@1:server",
-            room_id: roomId,
-            origin_server_ts: 1,
-            txn_id: "txn1",
-        }, {
-            event_id: "$2:server",
-            type: "m.room.encrypted",
-            content: { body: "2" },
-            sender: "@2:server",
-            room_id: roomId,
-            origin_server_ts: 2,
-            txn_id: "txn2",
-        }]);
+        client.store.getPendingEvents = jest.fn(async (roomId) => [
+            {
+                event_id: "$1:server",
+                type: "m.room.message",
+                content: { body: "1" },
+                sender: "@1:server",
+                room_id: roomId,
+                origin_server_ts: 1,
+                txn_id: "txn1",
+            },
+            {
+                event_id: "$2:server",
+                type: "m.room.encrypted",
+                content: { body: "2" },
+                sender: "@2:server",
+                room_id: roomId,
+                origin_server_ts: 2,
+                txn_id: "txn2",
+            },
+        ]);
         const room = new Room(roomId, client, userA, {
             pendingEventOrdering: PendingEventOrdering.Detached,
         });
diff --git a/spec/unit/scheduler.spec.ts b/spec/unit/scheduler.spec.ts
index 2e7dcf30898..122b71fde1d 100644
--- a/spec/unit/scheduler.spec.ts
+++ b/spec/unit/scheduler.spec.ts
@@ -1,7 +1,7 @@
 // This file had a function whose name is all caps, which displeases eslint
 /* eslint new-cap: "off" */
 
-import { defer, IDeferred } from '../../src/utils';
+import { defer, IDeferred } from "../../src/utils";
 import { MatrixError } from "../../src/http-api";
 import { MatrixScheduler } from "../../src/scheduler";
 import * as utils from "../test-utils/test-utils";
@@ -9,47 +9,54 @@ import { MatrixEvent } from "../../src";
 
 jest.useFakeTimers();
 
-describe("MatrixScheduler", function() {
+describe("MatrixScheduler", function () {
     let scheduler: MatrixScheduler<Record<string, boolean>>;
     let retryFn: Function | null;
     let queueFn: ((event: MatrixEvent) => string | null) | null;
     let deferred: IDeferred<Record<string, boolean>>;
     const roomId = "!foo:bar";
     const eventA = utils.mkMessage({
-        user: "@alice:bar", room: roomId, event: true,
+        user: "@alice:bar",
+        room: roomId,
+        event: true,
     });
     const eventB = utils.mkMessage({
-        user: "@alice:bar", room: roomId, event: true,
+        user: "@alice:bar",
+        room: roomId,
+        event: true,
     });
 
-    beforeEach(function() {
-        scheduler = new MatrixScheduler(function(ev, attempts, err) {
-            if (retryFn) {
-                return retryFn(ev, attempts, err);
-            }
-            return -1;
-        }, function(event) {
-            if (queueFn) {
-                return queueFn(event);
-            }
-            return null;
-        });
+    beforeEach(function () {
+        scheduler = new MatrixScheduler(
+            function (ev, attempts, err) {
+                if (retryFn) {
+                    return retryFn(ev, attempts, err);
+                }
+                return -1;
+            },
+            function (event) {
+                if (queueFn) {
+                    return queueFn(event);
+                }
+                return null;
+            },
+        );
         retryFn = null;
         queueFn = null;
         deferred = defer();
     });
 
-    it("should process events in a queue in a FIFO manner", async function() {
-        retryFn = function() {
+    it("should process events in a queue in a FIFO manner", async function () {
+        retryFn = function () {
             return 0;
         };
-        queueFn = function() {
+        queueFn = function () {
             return "one_big_queue";
         };
         const deferA = defer<Record<string, boolean>>();
         const deferB = defer<Record<string, boolean>>();
         let yieldedA = false;
-        scheduler.setProcessFunction(function(event) {
+        scheduler.setProcessFunction(function (event) {
             if (yieldedA) {
                 expect(event).toEqual(eventB);
                 return deferB.promise;
@@ -59,10 +66,7 @@ describe("MatrixScheduler", function() {
                 return deferA.promise;
             }
         });
-        const abPromise = Promise.all([
-            scheduler.queueEvent(eventA),
-            scheduler.queueEvent(eventB),
-        ]);
+        const abPromise = Promise.all([scheduler.queueEvent(eventA), scheduler.queueEvent(eventB)]);
         deferB.resolve({ b: true });
         deferA.resolve({ a: true });
         const [a, b] = await abPromise;
@@ -70,89 +74,87 @@ describe("MatrixScheduler", function() {
         expect(b!.b).toEqual(true);
     });
 
-    it("should invoke the retryFn on failure and wait the amount of time specified",
-        async function() {
-            const waitTimeMs = 1500;
-            const retryDefer = defer();
-            retryFn = function() {
-                retryDefer.resolve();
-                return waitTimeMs;
-            };
-            queueFn = function() {
-                return "yep";
-            };
+    it("should invoke the retryFn on failure and wait the amount of time specified", async function () {
+        const waitTimeMs = 1500;
+        const retryDefer = defer();
+        retryFn = function () {
+            retryDefer.resolve();
+            return waitTimeMs;
+        };
+        queueFn = function () {
+            return "yep";
+        };
 
-            let procCount = 0;
-            scheduler.setProcessFunction(function(ev) {
-                procCount += 1;
-                if (procCount === 1) {
-                    expect(ev).toEqual(eventA);
-                    return deferred.promise;
-                } else if (procCount === 2) {
+        let procCount = 0;
+        scheduler.setProcessFunction(function (ev) {
+            procCount += 1;
+            if (procCount === 1) {
+                expect(ev).toEqual(eventA);
+                return deferred.promise;
+            } else if (procCount === 2) {
                 // don't care about this deferred
-                    return new Promise(() => {});
-                }
-                expect(procCount).toBeLessThan(3);
                 return new Promise(() => {});
-            });
-
-            scheduler.queueEvent(eventA);
-            // as queueing doesn't start processing synchronously anymore (see commit bbdb5ac)
-            // wait just long enough before it does
-            await Promise.resolve();
-            expect(procCount).toEqual(1);
-            deferred.reject({});
-            await retryDefer.promise;
-            expect(procCount).toEqual(1);
-            jest.advanceTimersByTime(waitTimeMs);
-            await Promise.resolve();
-            expect(procCount).toEqual(2);
+            }
+            expect(procCount).toBeLessThan(3);
+            return new Promise(() => {});
         });
 
-    it("should give up if the retryFn on failure returns -1 and try the next event",
-        async function() {
+        scheduler.queueEvent(eventA);
+        // as queueing doesn't start processing synchronously anymore (see commit bbdb5ac)
+        // wait just long enough before it does
+        await Promise.resolve();
+        expect(procCount).toEqual(1);
+        deferred.reject({});
+        await retryDefer.promise;
+        expect(procCount).toEqual(1);
+        jest.advanceTimersByTime(waitTimeMs);
+        await Promise.resolve();
+        expect(procCount).toEqual(2);
+    });
+
+    it("should give up if the retryFn on failure returns -1 and try the next event", async function () {
         // Queue A & B.
         // Reject A and return -1 on retry.
         // Expect B to be tried next and the promise for A to be rejected.
-            retryFn = function() {
-                return -1;
-            };
-            queueFn = function() {
-                return "yep";
-            };
-
-            const deferA = defer<Record<string, boolean>>();
-            const deferB = defer<Record<string, boolean>>();
-            let procCount = 0;
-            scheduler.setProcessFunction(function(ev) {
-                procCount += 1;
-                if (procCount === 1) {
-                    expect(ev).toEqual(eventA);
-                    return deferA.promise;
-                } else if (procCount === 2) {
-                    expect(ev).toEqual(eventB);
-                    return deferB.promise;
-                }
-                expect(procCount).toBeLessThan(3);
-                return new Promise<Record<string, boolean>>(() => {});
-            });
+        retryFn = function () {
+            return -1;
+        };
+        queueFn = function () {
+            return "yep";
+        };
 
-            const globalA = scheduler.queueEvent(eventA);
-            scheduler.queueEvent(eventB);
-            // as queueing doesn't start processing synchronously anymore (see commit bbdb5ac)
-            // wait just long enough before it does
-            await Promise.resolve();
-            expect(procCount).toEqual(1);
-            deferA.reject({});
-            try {
-                await globalA;
-            } catch (err) {
-                await Promise.resolve();
-                expect(procCount).toEqual(2);
+        const deferA = defer<Record<string, boolean>>();
+        const deferB = defer<Record<string, boolean>>();
+        let procCount = 0;
+        scheduler.setProcessFunction(function (ev) {
+            procCount += 1;
+            if (procCount === 1) {
+                expect(ev).toEqual(eventA);
+                return deferA.promise;
+            } else if (procCount === 2) {
+                expect(ev).toEqual(eventB);
+                return deferB.promise;
             }
+            expect(procCount).toBeLessThan(3);
+            return new Promise<Record<string, boolean>>(() => {});
         });
 
-    it("should treat each queue separately", function(done) {
+        const globalA = scheduler.queueEvent(eventA);
+        scheduler.queueEvent(eventB);
+        // as queueing doesn't start processing synchronously anymore (see commit bbdb5ac)
+        // wait just long enough before it does
+        await Promise.resolve();
+        expect(procCount).toEqual(1);
+        deferA.reject({});
+        try {
+            await globalA;
+        } catch (err) {
+            await Promise.resolve();
+            expect(procCount).toEqual(2);
+        }
+    });
+
+    it("should treat each queue separately", function (done) {
         // Queue messages A B C D.
         // Bucket A&D into queue_A
         // Bucket B&C into queue_B
@@ -168,18 +170,16 @@ describe("MatrixScheduler", function() {
         buckets[eventB.getId()!] = "queue_B";
         buckets[eventC.getId()!] = "queue_B";
 
-        retryFn = function() {
+        retryFn = function () {
             return 0;
         };
-        queueFn = function(event) {
+        queueFn = function (event) {
             return buckets[event.getId()!];
         };
 
-        const expectOrder = [
-            eventA.getId(), eventB.getId(), eventD.getId(),
-        ];
+        const expectOrder = [eventA.getId(), eventB.getId(), eventD.getId()];
         const deferA = defer<Record<string, boolean>>();
-        scheduler.setProcessFunction(function(event) {
+        scheduler.setProcessFunction(function (event) {
             const id = expectOrder.shift();
             expect(id).toEqual(event.getId());
             if (expectOrder.length === 0) {
@@ -193,22 +193,22 @@ describe("MatrixScheduler", function() {
         scheduler.queueEvent(eventD);
 
         // wait a bit then resolve A and we should get D (not C) next.
-        setTimeout(function() {
+        setTimeout(function () {
             deferA.resolve({});
         }, 1000);
         jest.advanceTimersByTime(1000);
     });
 
-    describe("queueEvent", function() {
-        it("should return null if the event shouldn't be queued", function() {
-            queueFn = function() {
+    describe("queueEvent", function () {
+        it("should return null if the event shouldn't be queued", function () {
+            queueFn = function () {
                 return null;
             };
             expect(scheduler.queueEvent(eventA)).toEqual(null);
         });
 
-        it("should return a Promise if the event is queued", function() {
-            queueFn = function() {
+        it("should return a Promise if the event is queued", function () {
+            queueFn = function () {
                 return "yep";
             };
             const prom = scheduler.queueEvent(eventA);
@@ -217,71 +217,75 @@ describe("MatrixScheduler", function() {
         });
     });
 
-    describe("getQueueForEvent", function() {
-        it("should return null if the event doesn't map to a queue name", function() {
-            queueFn = function() {
+    describe("getQueueForEvent", function () {
+        it("should return null if the event doesn't map to a queue name", function () {
+            queueFn = function () {
                 return null;
             };
             expect(scheduler.getQueueForEvent(eventA)).toBe(null);
         });
 
-        it("should return null if the mapped queue doesn't exist", function() {
-            queueFn = function() {
+        it("should return null if the mapped queue doesn't exist", function () {
+            queueFn = function () {
                 return "yep";
             };
             expect(scheduler.getQueueForEvent(eventA)).toBe(null);
         });
 
-        it("should return a list of events in the queue and modifications to" +
-        " the list should not affect the underlying queue.", function() {
-            queueFn = function() {
-                return "yep";
-            };
-            scheduler.queueEvent(eventA);
-            scheduler.queueEvent(eventB);
-            const queue = scheduler.getQueueForEvent(eventA);
-            expect(queue).toHaveLength(2);
-            expect(queue).toEqual([eventA, eventB]);
-            // modify the queue
-            const eventC = utils.mkMessage(
-                { user: "@a:bar", room: roomId, event: true },
-            );
-            queue!.push(eventC);
-            const queueAgain = scheduler.getQueueForEvent(eventA);
-            expect(queueAgain).toHaveLength(2);
-        });
+        it(
+            "should return a list of events in the queue and modifications to" +
+                " the list should not affect the underlying queue.",
+            function () {
+                queueFn = function () {
+                    return "yep";
+                };
+                scheduler.queueEvent(eventA);
+                scheduler.queueEvent(eventB);
+                const queue = scheduler.getQueueForEvent(eventA);
+                expect(queue).toHaveLength(2);
+                expect(queue).toEqual([eventA, eventB]);
+                // modify the queue
+                const eventC = utils.mkMessage({ user: "@a:bar", room: roomId, event: true });
+                queue!.push(eventC);
+                const queueAgain = scheduler.getQueueForEvent(eventA);
+                expect(queueAgain).toHaveLength(2);
+            },
+        );
 
-        it("should return a list of events in the queue and modifications to" +
-        " an event in the queue should affect the underlying queue.", function() {
-            queueFn = function() {
-                return "yep";
-            };
-            scheduler.queueEvent(eventA);
-            scheduler.queueEvent(eventB);
-            const queue = scheduler.getQueueForEvent(eventA)!;
-            queue[1].event.content!.body = "foo";
-            const queueAgain = scheduler.getQueueForEvent(eventA)!;
-            expect(queueAgain[1].event.content?.body).toEqual("foo");
-        });
+        it(
+            "should return a list of events in the queue and modifications to" +
+                " an event in the queue should affect the underlying queue.",
+            function () {
+                queueFn = function () {
+                    return "yep";
+                };
+                scheduler.queueEvent(eventA);
+                scheduler.queueEvent(eventB);
+                const queue = scheduler.getQueueForEvent(eventA)!;
+                queue[1].event.content!.body = "foo";
+                const queueAgain = scheduler.getQueueForEvent(eventA)!;
+                expect(queueAgain[1].event.content?.body).toEqual("foo");
+            },
+        );
     });
 
-    describe("removeEventFromQueue", function() {
-        it("should return false if the event doesn't map to a queue name", function() {
-            queueFn = function() {
+    describe("removeEventFromQueue", function () {
+        it("should return false if the event doesn't map to a queue name", function () {
+            queueFn = function () {
                 return null;
             };
             expect(scheduler.removeEventFromQueue(eventA)).toBe(false);
         });
 
-        it("should return false if the event isn't in the queue", function() {
-            queueFn = function() {
+        it("should return false if the event isn't in the queue", function () {
+            queueFn = function () {
                 return "yep";
             };
             expect(scheduler.removeEventFromQueue(eventA)).toBe(false);
         });
 
-        it("should return true if the event was removed", function() {
-            queueFn = function() {
+        it("should return true if the event was removed", function () {
+            queueFn = function () {
                 return "yep";
             };
             scheduler.queueEvent(eventA);
@@ -289,14 +293,14 @@ describe("MatrixScheduler", function() {
         });
     });
 
-    describe("setProcessFunction", function() {
-        it("should call the processFn if there are queued events", function() {
-            queueFn = function() {
+    describe("setProcessFunction", function () {
+        it("should call the processFn if there are queued events", function () {
+            queueFn = function () {
                 return "yep";
             };
             let procCount = 0;
             scheduler.queueEvent(eventA);
-            scheduler.setProcessFunction(function(ev) {
+            scheduler.setProcessFunction(function (ev) {
                 procCount += 1;
                 expect(ev).toEqual(eventA);
                 return deferred.promise;
@@ -308,12 +312,12 @@ describe("MatrixScheduler", function() {
             });
         });
 
-        it("should not call the processFn if there are no queued events", function() {
-            queueFn = function() {
+        it("should not call the processFn if there are no queued events", function () {
+            queueFn = function () {
                 return "yep";
             };
             let procCount = 0;
-            scheduler.setProcessFunction(function(ev) {
+            scheduler.setProcessFunction(function (ev) {
                 procCount += 1;
                 return deferred.promise;
             });
@@ -321,48 +325,46 @@ describe("MatrixScheduler", function() {
         });
     });
 
-    describe("QUEUE_MESSAGES", function() {
-        it("should queue m.room.message events only", function() {
+    describe("QUEUE_MESSAGES", function () {
+        it("should queue m.room.message events only", function () {
             expect(MatrixScheduler.QUEUE_MESSAGES(eventA)).toEqual("message");
-            expect(MatrixScheduler.QUEUE_MESSAGES(
-                utils.mkMembership({
-                    user: "@alice:bar", room: roomId, mship: "join", event: true,
-                }),
-            )).toEqual(null);
+            expect(
+                MatrixScheduler.QUEUE_MESSAGES(
+                    utils.mkMembership({
+                        user: "@alice:bar",
+                        room: roomId,
+                        mship: "join",
+                        event: true,
+                    }),
+                ),
+            ).toEqual(null);
         });
     });
 
-    describe("RETRY_BACKOFF_RATELIMIT", function() {
-        it("should wait at least the time given on M_LIMIT_EXCEEDED", function() {
+    describe("RETRY_BACKOFF_RATELIMIT", function () {
+        it("should wait at least the time given on M_LIMIT_EXCEEDED", function () {
             const res = MatrixScheduler.RETRY_BACKOFF_RATELIMIT(
-                eventA, 1, new MatrixError({
-                    errcode: "M_LIMIT_EXCEEDED", retry_after_ms: 5000,
+                eventA,
+                1,
+                new MatrixError({
+                    errcode: "M_LIMIT_EXCEEDED",
+                    retry_after_ms: 5000,
                 }),
             );
             expect(res >= 500).toBe(true);
         });
 
-        it("should give up after 5 attempts", function() {
-            const res = MatrixScheduler.RETRY_BACKOFF_RATELIMIT(
-                eventA, 5, new MatrixError({}),
-            );
+        it("should give up after 5 attempts", function () {
+            const res = MatrixScheduler.RETRY_BACKOFF_RATELIMIT(eventA, 5, new MatrixError({}));
             expect(res).toBe(-1);
         });
 
-        it("should do exponential backoff", function() {
+        it("should do exponential backoff", function () {
             const error = new MatrixError({});
-            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(
-                eventA, 1, error,
-            )).toEqual(2000);
-            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(
-                eventA, 2, error,
-            )).toEqual(4000);
-            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(
-                eventA, 3, error,
-            )).toEqual(8000);
-            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(
-                eventA, 4, error,
-            )).toEqual(16000);
+            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(eventA, 1, error)).toEqual(2000);
+            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(eventA, 2, error)).toEqual(4000);
+            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(eventA, 3, error)).toEqual(8000);
+            expect(MatrixScheduler.RETRY_BACKOFF_RATELIMIT(eventA, 4, error)).toEqual(16000);
         });
     });
 });
diff --git a/spec/unit/stores/indexeddb.spec.ts b/spec/unit/stores/indexeddb.spec.ts
index abd71274bea..f2ce29e47e6 100644
--- a/spec/unit/stores/indexeddb.spec.ts
+++ b/spec/unit/stores/indexeddb.spec.ts
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import 'fake-indexeddb/auto';
-import 'jest-localstorage-mock';
+import "fake-indexeddb/auto";
+import "jest-localstorage-mock";
 
 import { IndexedDBStore, IStateEventWithRoomId, MemoryStore } from "../../../src";
 import { emitPromise } from "../../test-utils/test-utils";
@@ -61,8 +61,9 @@ describe("IndexedDBStore", () => {
 
         // Simulate a broken IDB
         (store.backend as LocalIndexedDBStoreBackend)["db"]!.transaction = (): IDBTransaction => {
-            const err = new Error("Failed to execute 'transaction' on 'IDBDatabase': " +
-                "The database connection is closing.");
+            const err = new Error(
+                "Failed to execute 'transaction' on 'IDBDatabase': " + "The database connection is closing.",
+            );
             err.name = "InvalidStateError";
             throw err;
         };
diff --git a/spec/unit/sync-accumulator.spec.ts b/spec/unit/sync-accumulator.spec.ts
index 9a72a6b3397..9255d7ec89c 100644
--- a/spec/unit/sync-accumulator.spec.ts
+++ b/spec/unit/sync-accumulator.spec.ts
@@ -58,10 +58,10 @@ const RES_WITH_AGE = {
     },
 } as unknown as ISyncResponse;
 
-describe("SyncAccumulator", function() {
+describe("SyncAccumulator", function () {
     let sa: SyncAccumulator;
 
-    beforeEach(function() {
+    beforeEach(function () {
         sa = new SyncAccumulator({
             maxTimelineEntries: 10,
         });
@@ -82,10 +82,7 @@ describe("SyncAccumulator", function() {
                         ephemeral: { events: [] },
                         unread_notifications: {},
                         state: {
-                            events: [
-                                member("alice", "join"),
-                                member("bob", "join"),
-                            ],
+                            events: [member("alice", "join"), member("bob", "join")],
                         },
                         summary: {
                             "m.heroes": undefined,
@@ -109,46 +106,47 @@ describe("SyncAccumulator", function() {
     it("should prune the timeline to the oldest prev_batch within the limit", () => {
         // maxTimelineEntries is 10 so we should get back all
         // 10 timeline messages with a prev_batch of "pinned_to_1"
-        sa.accumulate(syncSkeleton({
-            state: { events: [member("alice", "join")] },
-            timeline: {
-                events: [
-                    msg("alice", "1"),
-                    msg("alice", "2"),
-                    msg("alice", "3"),
-                    msg("alice", "4"),
-                    msg("alice", "5"),
-                    msg("alice", "6"),
-                    msg("alice", "7"),
-                ],
-                prev_batch: "pinned_to_1",
-            },
-        }));
-        sa.accumulate(syncSkeleton({
-            state: { events: [] },
-            timeline: {
-                events: [
-                    msg("alice", "8"),
-                ],
-                prev_batch: "pinned_to_8",
-            },
-        }));
-        sa.accumulate(syncSkeleton({
-            state: { events: [] },
-            timeline: {
-                events: [
-                    msg("alice", "9"),
-                    msg("alice", "10"),
-                ],
-                prev_batch: "pinned_to_10",
-            },
-        }));
+        sa.accumulate(
+            syncSkeleton({
+                state: { events: [member("alice", "join")] },
+                timeline: {
+                    events: [
+                        msg("alice", "1"),
+                        msg("alice", "2"),
+                        msg("alice", "3"),
+                        msg("alice", "4"),
+                        msg("alice", "5"),
+                        msg("alice", "6"),
+                        msg("alice", "7"),
+                    ],
+                    prev_batch: "pinned_to_1",
+                },
+            }),
+        );
+        sa.accumulate(
+            syncSkeleton({
+                state: { events: [] },
+                timeline: {
+                    events: [msg("alice", "8")],
+                    prev_batch: "pinned_to_8",
+                },
+            }),
+        );
+        sa.accumulate(
+            syncSkeleton({
+                state: { events: [] },
+                timeline: {
+                    events: [msg("alice", "9"), msg("alice", "10")],
+                    prev_batch: "pinned_to_10",
+                },
+            }),
+        );
 
         let output = sa.getJSON().roomsData.join["!foo:bar"];
 
         expect(output.timeline.events.length).toEqual(10);
         output.timeline.events.forEach((e, i) => {
-            expect(e.content.body).toEqual(""+(i+1));
+            expect(e.content.body).toEqual("" + (i + 1));
         });
         expect(output.timeline.prev_batch).toEqual("pinned_to_1");
 
@@ -156,62 +154,60 @@ describe("SyncAccumulator", function() {
         // AND give us <= 10 messages without losing messages in-between.
         // It should try to find the oldest prev_batch which still fits into 10
         // messages, which is "pinned to 8".
-        sa.accumulate(syncSkeleton({
-            state: { events: [] },
-            timeline: {
-                events: [
-                    msg("alice", "11"),
-                    msg("alice", "12"),
-                    msg("alice", "13"),
-                    msg("alice", "14"),
-                    msg("alice", "15"),
-                    msg("alice", "16"),
-                    msg("alice", "17"),
-                ],
-                prev_batch: "pinned_to_11",
-            },
-        }));
+        sa.accumulate(
+            syncSkeleton({
+                state: { events: [] },
+                timeline: {
+                    events: [
+                        msg("alice", "11"),
+                        msg("alice", "12"),
+                        msg("alice", "13"),
+                        msg("alice", "14"),
+                        msg("alice", "15"),
+                        msg("alice", "16"),
+                        msg("alice", "17"),
+                    ],
+                    prev_batch: "pinned_to_11",
+                },
+            }),
+        );
 
         output = sa.getJSON().roomsData.join["!foo:bar"];
 
         expect(output.timeline.events.length).toEqual(10);
         output.timeline.events.forEach((e, i) => {
-            expect(e.content.body).toEqual(""+(i+8));
+            expect(e.content.body).toEqual("" + (i + 8));
         });
         expect(output.timeline.prev_batch).toEqual("pinned_to_8");
     });
 
     it("should remove the stored timeline on limited syncs", () => {
-        sa.accumulate(syncSkeleton({
-            state: { events: [member("alice", "join")] },
-            timeline: {
-                events: [
-                    msg("alice", "1"),
-                    msg("alice", "2"),
-                    msg("alice", "3"),
-                ],
-                prev_batch: "pinned_to_1",
-            },
-        }));
+        sa.accumulate(
+            syncSkeleton({
+                state: { events: [member("alice", "join")] },
+                timeline: {
+                    events: [msg("alice", "1"), msg("alice", "2"), msg("alice", "3")],
+                    prev_batch: "pinned_to_1",
+                },
+            }),
+        );
         // some time passes and now we get a limited sync
-        sa.accumulate(syncSkeleton({
-            state: { events: [] },
-            timeline: {
-                limited: true,
-                events: [
-                    msg("alice", "51"),
-                    msg("alice", "52"),
-                    msg("alice", "53"),
-                ],
-                prev_batch: "pinned_to_51",
-            },
-        }));
+        sa.accumulate(
+            syncSkeleton({
+                state: { events: [] },
+                timeline: {
+                    limited: true,
+                    events: [msg("alice", "51"), msg("alice", "52"), msg("alice", "53")],
+                    prev_batch: "pinned_to_51",
+                },
+            }),
+        );
 
         const output = sa.getJSON().roomsData.join["!foo:bar"];
 
         expect(output.timeline.events.length).toEqual(3);
         output.timeline.events.forEach((e, i) => {
-            expect(e.content.body).toEqual(""+(i+51));
+            expect(e.content.body).toEqual("" + (i + 51));
         });
         expect(output.timeline.prev_batch).toEqual("pinned_to_51");
     });
@@ -219,18 +215,18 @@ describe("SyncAccumulator", function() {
     it("should drop typing notifications", () => {
         const res = syncSkeleton({
             ephemeral: {
-                events: [{
-                    type: "m.typing",
-                    content: {
-                        user_ids: ["@alice:localhost"],
+                events: [
+                    {
+                        type: "m.typing",
+                        content: {
+                            user_ids: ["@alice:localhost"],
+                        },
                     },
-                }],
+                ],
             },
         });
         sa.accumulate(res);
-        expect(
-            sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events.length,
-        ).toEqual(0);
+        expect(sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events.length).toEqual(0);
     });
 
     it("should clobber account data based on event type", () => {
@@ -246,22 +242,22 @@ describe("SyncAccumulator", function() {
                 food: "apple",
             },
         };
-        sa.accumulate(syncSkeleton({
-            account_data: {
-                events: [acc1],
-            },
-        }));
-        sa.accumulate(syncSkeleton({
-            account_data: {
-                events: [acc2],
-            },
-        }));
-        expect(
-            sa.getJSON().roomsData.join["!foo:bar"].account_data.events.length,
-        ).toEqual(1);
-        expect(
-            sa.getJSON().roomsData.join["!foo:bar"].account_data.events[0],
-        ).toEqual(acc2);
+        sa.accumulate(
+            syncSkeleton({
+                account_data: {
+                    events: [acc1],
+                },
+            }),
+        );
+        sa.accumulate(
+            syncSkeleton({
+                account_data: {
+                    events: [acc2],
+                },
+            }),
+        );
+        expect(sa.getJSON().roomsData.join["!foo:bar"].account_data.events.length).toEqual(1);
+        expect(sa.getJSON().roomsData.join["!foo:bar"].account_data.events[0]).toEqual(acc2);
     });
 
     it("should clobber global account data based on event type", () => {
@@ -287,12 +283,8 @@ describe("SyncAccumulator", function() {
                 events: [acc2],
             },
         } as unknown as ISyncResponse);
-        expect(
-            sa.getJSON().accountData.length,
-        ).toEqual(1);
-        expect(
-            sa.getJSON().accountData[0],
-        ).toEqual(acc2);
+        expect(sa.getJSON().accountData.length).toEqual(1);
+        expect(sa.getJSON().accountData[0]).toEqual(acc2);
     });
 
     it("should accumulate read receipts", () => {
@@ -326,23 +318,23 @@ describe("SyncAccumulator", function() {
                 },
             },
         };
-        sa.accumulate(syncSkeleton({
-            ephemeral: {
-                events: [receipt1],
-            },
-        }));
-        sa.accumulate(syncSkeleton({
-            ephemeral: {
-                events: [receipt2],
-            },
-        }));
-
-        expect(
-            sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events.length,
-        ).toEqual(1);
-        expect(
-            sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events[0],
-        ).toEqual({
+        sa.accumulate(
+            syncSkeleton({
+                ephemeral: {
+                    events: [receipt1],
+                },
+            }),
+        );
+        sa.accumulate(
+            syncSkeleton({
+                ephemeral: {
+                    events: [receipt2],
+                },
+            }),
+        );
+
+        expect(sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events.length).toEqual(1);
+        expect(sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events[0]).toEqual({
             type: "m.receipt",
             room_id: "!foo:bar",
             content: {
@@ -387,23 +379,23 @@ describe("SyncAccumulator", function() {
                 },
             },
         };
-        sa.accumulate(syncSkeleton({
-            ephemeral: {
-                events: [receipt1],
-            },
-        }));
-        sa.accumulate(syncSkeleton({
-            ephemeral: {
-                events: [receipt2],
-            },
-        }));
-
-        expect(
-            sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events.length,
-        ).toEqual(1);
-        expect(
-            sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events[0],
-        ).toEqual({
+        sa.accumulate(
+            syncSkeleton({
+                ephemeral: {
+                    events: [receipt1],
+                },
+            }),
+        );
+        sa.accumulate(
+            syncSkeleton({
+                ephemeral: {
+                    events: [receipt2],
+                },
+            }),
+        );
+
+        expect(sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events.length).toEqual(1);
+        expect(sa.getJSON().roomsData.join["!foo:bar"].ephemeral.events[0]).toEqual({
             type: "m.receipt",
             room_id: "!foo:bar",
             content: {
@@ -421,7 +413,7 @@ describe("SyncAccumulator", function() {
         });
     });
 
-    describe("summary field", function() {
+    describe("summary field", function () {
         function createSyncResponseWithSummary(summary: IRoomSummary): ISyncResponse {
             return {
                 next_batch: "abc",
@@ -448,28 +440,34 @@ describe("SyncAccumulator", function() {
         }
 
         afterEach(() => {
-            jest.spyOn(global.Date, 'now').mockRestore();
+            jest.spyOn(global.Date, "now").mockRestore();
         });
 
-        it("should copy summary properties", function() {
-            sa.accumulate(createSyncResponseWithSummary({
-                "m.heroes": ["@alice:bar"],
-                "m.invited_member_count": 2,
-            }));
+        it("should copy summary properties", function () {
+            sa.accumulate(
+                createSyncResponseWithSummary({
+                    "m.heroes": ["@alice:bar"],
+                    "m.invited_member_count": 2,
+                }),
+            );
             const summary = sa.getJSON().roomsData.join["!foo:bar"].summary;
             expect(summary["m.invited_member_count"]).toEqual(2);
             expect(summary["m.heroes"]).toEqual(["@alice:bar"]);
         });
 
-        it("should accumulate summary properties", function() {
-            sa.accumulate(createSyncResponseWithSummary({
-                "m.heroes": ["@alice:bar"],
-                "m.invited_member_count": 2,
-            }));
-            sa.accumulate(createSyncResponseWithSummary({
-                "m.heroes": ["@bob:bar"],
-                "m.joined_member_count": 5,
-            }));
+        it("should accumulate summary properties", function () {
+            sa.accumulate(
+                createSyncResponseWithSummary({
+                    "m.heroes": ["@alice:bar"],
+                    "m.invited_member_count": 2,
+                }),
+            );
+            sa.accumulate(
+                createSyncResponseWithSummary({
+                    "m.heroes": ["@bob:bar"],
+                    "m.joined_member_count": 5,
+                }),
+            );
             const summary = sa.getJSON().roomsData.join["!foo:bar"].summary;
             expect(summary["m.invited_member_count"]).toEqual(2);
             expect(summary["m.joined_member_count"]).toEqual(5);
@@ -480,11 +478,11 @@ describe("SyncAccumulator", function() {
             const delta = 1000;
             const startingTs = 1000;
 
-            jest.spyOn(global.Date, 'now').mockReturnValue(startingTs);
+            jest.spyOn(global.Date, "now").mockReturnValue(startingTs);
 
             sa.accumulate(RES_WITH_AGE);
 
-            jest.spyOn(global.Date, 'now').mockReturnValue(startingTs + delta);
+            jest.spyOn(global.Date, "now").mockReturnValue(startingTs + delta);
 
             const output = sa.getJSON();
             expect(output.roomsData.join["!foo:bar"].timeline.events[0].unsigned?.age).toEqual(
@@ -506,8 +504,9 @@ describe("SyncAccumulator", function() {
         it("should retrieve unread thread notifications", () => {
             sa.accumulate(RES_WITH_AGE);
             const output = sa.getJSON();
-            expect(output.roomsData.join["!foo:bar"]
-                .unread_thread_notifications!["$143273582443PhrSn:example.org"]).not.toBeUndefined();
+            expect(
+                output.roomsData.join["!foo:bar"].unread_thread_notifications!["$143273582443PhrSn:example.org"],
+            ).not.toBeUndefined();
         });
     });
 });
diff --git a/spec/unit/timeline-window.spec.ts b/spec/unit/timeline-window.spec.ts
index f6dec04e786..f786a513d64 100644
--- a/spec/unit/timeline-window.spec.ts
+++ b/spec/unit/timeline-window.spec.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MockedObject } from 'jest-mock';
+import { MockedObject } from "jest-mock";
 
 import { MatrixClient } from "../../src/client";
 import { EventTimelineSet } from "../../src/models/event-timeline-set";
@@ -37,7 +37,7 @@ const mockClient = {
 function createTimeline(numEvents = 3, baseIndex = 1): EventTimeline {
     const room = new Room(ROOM_ID, mockClient, USER_ID);
     const timelineSet = new EventTimelineSet(room);
-    jest.spyOn(room, 'getUnfilteredTimelineSet').mockReturnValue(timelineSet);
+    jest.spyOn(room, "getUnfilteredTimelineSet").mockReturnValue(timelineSet);
 
     const timeline = new EventTimeline(timelineSet);
 
@@ -55,7 +55,8 @@ function addEventsToTimeline(timeline: EventTimeline, numEvents: number, toStart
     for (let i = 0; i < numEvents; i++) {
         timeline.addEvent(
             mkMessage({
-                room: ROOM_ID, user: USER_ID,
+                room: ROOM_ID,
+                user: USER_ID,
                 event: true,
             }),
             { toStartOfTimeline },
@@ -74,42 +75,42 @@ function createLinkedTimelines(): [EventTimeline, EventTimeline] {
     return [tl1, tl2];
 }
 
-describe("TimelineIndex", function() {
+describe("TimelineIndex", function () {
     beforeEach(() => {
         jest.clearAllMocks();
         mockClient.getEventTimeline.mockResolvedValue(undefined);
     });
 
-    describe("minIndex", function() {
-        it("should return the min index relative to BaseIndex", function() {
+    describe("minIndex", function () {
+        it("should return the min index relative to BaseIndex", function () {
             const timelineIndex = new TimelineIndex(createTimeline(), 0);
             expect(timelineIndex.minIndex()).toEqual(-1);
         });
     });
 
-    describe("maxIndex", function() {
-        it("should return the max index relative to BaseIndex", function() {
+    describe("maxIndex", function () {
+        it("should return the max index relative to BaseIndex", function () {
             const timelineIndex = new TimelineIndex(createTimeline(), 0);
             expect(timelineIndex.maxIndex()).toEqual(2);
         });
     });
 
-    describe("advance", function() {
-        it("should advance up to the end of the timeline", function() {
+    describe("advance", function () {
+        it("should advance up to the end of the timeline", function () {
             const timelineIndex = new TimelineIndex(createTimeline(), 0);
             const result = timelineIndex.advance(3);
             expect(result).toEqual(2);
             expect(timelineIndex.index).toEqual(2);
         });
 
-        it("should retreat back to the start of the timeline", function() {
+        it("should retreat back to the start of the timeline", function () {
             const timelineIndex = new TimelineIndex(createTimeline(), 0);
             const result = timelineIndex.advance(-2);
             expect(result).toEqual(-1);
             expect(timelineIndex.index).toEqual(-1);
         });
 
-        it("should advance into the next timeline", function() {
+        it("should advance into the next timeline", function () {
             const timelines = createLinkedTimelines();
             const tl1 = timelines[0];
             const tl2 = timelines[1];
@@ -127,7 +128,7 @@ describe("TimelineIndex", function() {
             expect(timelineIndex.index).toEqual(0);
         });
 
-        it("should retreat into the previous timeline", function() {
+        it("should retreat into the previous timeline", function () {
             const timelines = createLinkedTimelines();
             const tl1 = timelines[0];
             const tl2 = timelines[1];
@@ -143,8 +144,8 @@ describe("TimelineIndex", function() {
         });
     });
 
-    describe("retreat", function() {
-        it("should retreat up to the start of the timeline", function() {
+    describe("retreat", function () {
+        it("should retreat up to the start of the timeline", function () {
             const timelineIndex = new TimelineIndex(createTimeline(), 0);
             const result = timelineIndex.retreat(2);
             expect(result).toEqual(1);
@@ -153,14 +154,17 @@ describe("TimelineIndex", function() {
     });
 });
 
-describe("TimelineWindow", function() {
+describe("TimelineWindow", function () {
     /**
      * create a dummy eventTimelineSet and client, and a TimelineWindow
      * attached to them.
      */
-    function createWindow(timeline: EventTimeline, opts?: {
-        windowLimit?: number;
-    }): [TimelineWindow, EventTimelineSet] {
+    function createWindow(
+        timeline: EventTimeline,
+        opts?: {
+            windowLimit?: number;
+        },
+    ): [TimelineWindow, EventTimelineSet] {
         const timelineSet = { getTimelineForEvent: () => null } as unknown as EventTimelineSet;
         mockClient.getEventTimeline.mockResolvedValue(timeline);
 
@@ -173,12 +177,12 @@ describe("TimelineWindow", function() {
         mockClient.paginateEventTimeline.mockResolvedValue(false);
     });
 
-    describe("load", function() {
-        it("should initialise from the live timeline", async function() {
+    describe("load", function () {
+        it("should initialise from the live timeline", async function () {
             const liveTimeline = createTimeline();
             const room = new Room(ROOM_ID, mockClient, USER_ID);
             const timelineSet = new EventTimelineSet(room);
-            jest.spyOn(timelineSet, 'getLiveTimeline').mockReturnValue(liveTimeline);
+            jest.spyOn(timelineSet, "getLiveTimeline").mockReturnValue(liveTimeline);
 
             const timelineWindow = new TimelineWindow(mockClient, timelineSet);
             await timelineWindow.load(undefined, 2);
@@ -189,7 +193,7 @@ describe("TimelineWindow", function() {
             expect(timelineWindow.getEvents()).toEqual(expectedEvents);
         });
 
-        it("should initialise from a specific event", async function() {
+        it("should initialise from a specific event", async function () {
             const timeline = createTimeline();
             const eventId = timeline.getEvents()[1].getId();
 
@@ -203,7 +207,7 @@ describe("TimelineWindow", function() {
             expect(timelineWindow.getEvents()).toEqual(expectedEvents);
         });
 
-        it("canPaginate should return false until load has returned", async function() {
+        it("canPaginate should return false until load has returned", async function () {
             const timeline = createTimeline();
             timeline.setPaginationToken("toktok1", EventTimeline.BACKWARDS);
             timeline.setPaginationToken("toktok2", EventTimeline.FORWARDS);
@@ -227,15 +231,13 @@ describe("TimelineWindow", function() {
             expect(timelineWindow.getEvents()).toEqual(expectedEvents);
 
             // can paginate now
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(true);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(true);
         });
     });
 
-    describe("pagination", function() {
-        it("should be able to advance across the initial timeline", async function() {
+    describe("pagination", function () {
+        it("should be able to advance across the initial timeline", async function () {
             const timeline = createTimeline();
             const eventId = timeline.getEvents()[1].getId();
             const [timelineWindow] = createWindow(timeline);
@@ -245,19 +247,15 @@ describe("TimelineWindow", function() {
             const expectedEvents = [timeline.getEvents()[1]];
             expect(timelineWindow.getEvents()).toEqual(expectedEvents);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(true);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(true);
 
             expect(await timelineWindow.paginate(EventTimeline.FORWARDS, 2)).toBe(true);
             const expectedEventsAfterPagination = timeline.getEvents().slice(1);
             expect(timelineWindow.getEvents()).toEqual(expectedEventsAfterPagination);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(true);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(false);
 
             // cant paginate forward anymore
             expect(await timelineWindow.paginate(EventTimeline.FORWARDS, 2)).toBe(false);
@@ -268,14 +266,12 @@ describe("TimelineWindow", function() {
             const expectedEvents3 = timeline.getEvents();
             expect(timelineWindow.getEvents()).toEqual(expectedEvents3);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(false);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(false);
             expect(await timelineWindow.paginate(EventTimeline.BACKWARDS, 2)).toBe(false);
         });
 
-        it("should advance into next timeline", async function() {
+        it("should advance into next timeline", async function () {
             const tls = createLinkedTimelines();
             const eventId = tls[0].getEvents()[1].getId();
             const [timelineWindow] = createWindow(tls[0], { windowLimit: 5 });
@@ -284,37 +280,29 @@ describe("TimelineWindow", function() {
             const expectedEvents = tls[0].getEvents();
             expect(timelineWindow.getEvents()).toEqual(expectedEvents);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(false);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(true);
 
             expect(await timelineWindow.paginate(EventTimeline.FORWARDS, 2)).toBe(true);
-            const expectedEvents2 = tls[0].getEvents()
-                .concat(tls[1].getEvents().slice(0, 2));
+            const expectedEvents2 = tls[0].getEvents().concat(tls[1].getEvents().slice(0, 2));
             expect(timelineWindow.getEvents()).toEqual(expectedEvents2);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(false);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(true);
 
             expect(await timelineWindow.paginate(EventTimeline.FORWARDS, 2)).toBe(true);
 
             // the windowLimit should have made us drop an event from
             // tls[0]
-            const expectedEvents3 = tls[0].getEvents().slice(1)
-                .concat(tls[1].getEvents());
+            const expectedEvents3 = tls[0].getEvents().slice(1).concat(tls[1].getEvents());
             expect(timelineWindow.getEvents()).toEqual(expectedEvents3);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(true);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(false);
             expect(await timelineWindow.paginate(EventTimeline.FORWARDS, 2)).toBe(false);
         });
 
-        it("should retreat into previous timeline", async function() {
+        it("should retreat into previous timeline", async function () {
             const tls = createLinkedTimelines();
             const eventId = tls[1].getEvents()[1].getId();
             const [timelineWindow] = createWindow(tls[1], { windowLimit: 5 });
@@ -324,36 +312,28 @@ describe("TimelineWindow", function() {
             const expectedEvents = tls[1].getEvents();
             expect(timelineWindow.getEvents()).toEqual(expectedEvents);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(true);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(false);
 
             expect(await timelineWindow.paginate(EventTimeline.BACKWARDS, 2)).toBe(true);
-            const expectedEvents2 = tls[0].getEvents().slice(1, 3)
-                .concat(tls[1].getEvents());
+            const expectedEvents2 = tls[0].getEvents().slice(1, 3).concat(tls[1].getEvents());
             expect(timelineWindow.getEvents()).toEqual(expectedEvents2);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(true);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(false);
 
             expect(await timelineWindow.paginate(EventTimeline.BACKWARDS, 2)).toBe(true);
             // the windowLimit should have made us drop an event from
             // tls[1]
-            const expectedEvents3 = tls[0].getEvents()
-                .concat(tls[1].getEvents().slice(0, 2));
+            const expectedEvents3 = tls[0].getEvents().concat(tls[1].getEvents().slice(0, 2));
             expect(timelineWindow.getEvents()).toEqual(expectedEvents3);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(false);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(true);
             expect(await timelineWindow.paginate(EventTimeline.BACKWARDS, 2)).toBe(false);
         });
 
-        it("should make forward pagination requests", async function() {
+        it("should make forward pagination requests", async function () {
             const timeline = createTimeline();
             timeline.setPaginationToken("toktok", EventTimeline.FORWARDS);
 
@@ -377,7 +357,7 @@ describe("TimelineWindow", function() {
             expect(timelineWindow.getEvents()).toEqual(expectedEvents2);
         });
 
-        it("should make backward pagination requests", async function() {
+        it("should make backward pagination requests", async function () {
             const timeline = createTimeline();
             timeline.setPaginationToken("toktok", EventTimeline.BACKWARDS);
 
@@ -403,7 +383,7 @@ describe("TimelineWindow", function() {
             expect(timelineWindow.getEvents()).toEqual(expectedEvents2);
         });
 
-        it("should limit the number of unsuccessful pagination requests", async function() {
+        it("should limit the number of unsuccessful pagination requests", async function () {
             const timeline = createTimeline();
             timeline.setPaginationToken("toktok", EventTimeline.FORWARDS);
 
@@ -418,10 +398,8 @@ describe("TimelineWindow", function() {
             const expectedEvents = timeline.getEvents();
             expect(timelineWindow.getEvents()).toEqual(expectedEvents);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(false);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(true);
             expect(await timelineWindow.paginate(EventTimeline.FORWARDS, 2, true, 3)).toBe(false);
 
             expect(mockClient.paginateEventTimeline).toHaveBeenCalledWith(timeline, { backwards: false, limit: 2 });
@@ -430,10 +408,8 @@ describe("TimelineWindow", function() {
             const expectedEvents2 = timeline.getEvents().slice(0, 3);
             expect(timelineWindow.getEvents()).toEqual(expectedEvents2);
 
-            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS))
-                .toBe(false);
-            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS))
-                .toBe(true);
+            expect(timelineWindow.canPaginate(EventTimeline.BACKWARDS)).toBe(false);
+            expect(timelineWindow.canPaginate(EventTimeline.FORWARDS)).toBe(true);
         });
     });
 });
diff --git a/spec/unit/user.spec.ts b/spec/unit/user.spec.ts
index 42cf42150f7..089fcc91e64 100644
--- a/spec/unit/user.spec.ts
+++ b/spec/unit/user.spec.ts
@@ -17,28 +17,30 @@ limitations under the License.
 import { User, UserEvent } from "../../src/models/user";
 import { mkEvent } from "../test-utils/test-utils";
 
-describe("User", function() {
+describe("User", function () {
     const userId = "@alice:bar";
     let user: User;
 
-    beforeEach(function() {
+    beforeEach(function () {
         user = new User(userId);
     });
 
-    describe("setPresenceEvent", function() {
+    describe("setPresenceEvent", function () {
         const event = mkEvent({
-            type: "m.presence", content: {
+            type: "m.presence",
+            content: {
                 presence: "online",
                 user_id: userId,
                 displayname: "Alice",
                 last_active_ago: 1085,
                 avatar_url: "mxc://foo/bar",
-            }, event: true,
+            },
+            event: true,
         });
 
-        it("should emit 'User.displayName' if the display name changes", function() {
+        it("should emit 'User.displayName' if the display name changes", function () {
             let emitCount = 0;
-            user.on(UserEvent.DisplayName, function(ev, usr) {
+            user.on(UserEvent.DisplayName, function (ev, usr) {
                 emitCount += 1;
             });
             user.setPresenceEvent(event);
@@ -47,9 +49,9 @@ describe("User", function() {
             expect(emitCount).toEqual(1);
         });
 
-        it("should emit 'User.avatarUrl' if the avatar URL changes", function() {
+        it("should emit 'User.avatarUrl' if the avatar URL changes", function () {
             let emitCount = 0;
-            user.on(UserEvent.AvatarUrl, function(ev, usr) {
+            user.on(UserEvent.AvatarUrl, function (ev, usr) {
                 emitCount += 1;
             });
             user.setPresenceEvent(event);
@@ -58,9 +60,9 @@ describe("User", function() {
             expect(emitCount).toEqual(1);
         });
 
-        it("should emit 'User.presence' if the presence changes", function() {
+        it("should emit 'User.presence' if the presence changes", function () {
             let emitCount = 0;
-            user.on(UserEvent.Presence, function(ev, usr) {
+            user.on(UserEvent.Presence, function (ev, usr) {
                 emitCount += 1;
             });
             user.setPresenceEvent(event);
@@ -69,27 +71,27 @@ describe("User", function() {
             expect(emitCount).toEqual(1);
         });
 
-        it("should set User.displayName", function() {
+        it("should set User.displayName", function () {
             user.setPresenceEvent(event);
             expect(user.displayName).toEqual("Alice");
         });
 
-        it("should set User.avatarUrl", function() {
+        it("should set User.avatarUrl", function () {
             user.setPresenceEvent(event);
             expect(user.avatarUrl).toEqual("mxc://foo/bar");
         });
 
-        it("should set User.presence", function() {
+        it("should set User.presence", function () {
             user.setPresenceEvent(event);
             expect(user.presence).toEqual("online");
         });
 
-        it("should set User.lastActiveAgo", function() {
+        it("should set User.lastActiveAgo", function () {
             user.setPresenceEvent(event);
             expect(user.lastActiveAgo).toEqual(1085);
         });
 
-        it("should set User.events.presence", function() {
+        it("should set User.events.presence", function () {
             user.setPresenceEvent(event);
             expect(user.events.presence).toEqual(event);
         });
diff --git a/spec/unit/utils.spec.ts b/spec/unit/utils.spec.ts
index c9fc75c3e85..8104cba0815 100644
--- a/spec/unit/utils.spec.ts
+++ b/spec/unit/utils.spec.ts
@@ -19,9 +19,9 @@ import { ReceiptType } from "../../src/@types/read_receipts";
 
 // TODO: Fix types throughout
 
-describe("utils", function() {
-    describe("encodeParams", function() {
-        it("should url encode and concat with &s", function() {
+describe("utils", function () {
+    describe("encodeParams", function () {
+        it("should url encode and concat with &s", function () {
             const params = {
                 foo: "bar",
                 baz: "beer@",
@@ -29,7 +29,7 @@ describe("utils", function() {
             expect(utils.encodeParams(params).toString()).toEqual("foo=bar&baz=beer%40");
         });
 
-        it("should handle boolean and numeric values", function() {
+        it("should handle boolean and numeric values", function () {
             const params = {
                 string: "foobar",
                 number: 12345,
@@ -56,38 +56,36 @@ describe("utils", function() {
         });
     });
 
-    describe("encodeUri", function() {
-        it("should replace based on object keys and url encode", function() {
+    describe("encodeUri", function () {
+        it("should replace based on object keys and url encode", function () {
             const path = "foo/bar/%something/%here";
             const vals = {
                 "%something": "baz",
                 "%here": "beer@",
             };
-            expect(utils.encodeUri(path, vals)).toEqual(
-                "foo/bar/baz/beer%40",
-            );
+            expect(utils.encodeUri(path, vals)).toEqual("foo/bar/baz/beer%40");
         });
     });
 
-    describe("removeElement", function() {
-        it("should remove only 1 element if there is a match", function() {
-            const matchFn = function() {
+    describe("removeElement", function () {
+        it("should remove only 1 element if there is a match", function () {
+            const matchFn = function () {
                 return true;
             };
             const arr = [55, 66, 77];
             utils.removeElement(arr, matchFn);
             expect(arr).toEqual([66, 77]);
         });
-        it("should be able to remove in reverse order", function() {
-            const matchFn = function() {
+        it("should be able to remove in reverse order", function () {
+            const matchFn = function () {
                 return true;
             };
             const arr = [55, 66, 77];
             utils.removeElement(arr, matchFn, true);
             expect(arr).toEqual([55, 66]);
         });
-        it("should remove nothing if the function never returns true", function() {
-            const matchFn = function() {
+        it("should remove nothing if the function never returns true", function () {
+            const matchFn = function () {
                 return false;
             };
             const arr = [55, 66, 77];
@@ -96,8 +94,8 @@ describe("utils", function() {
         });
     });
 
-    describe("isFunction", function() {
-        it("should return true for functions", function() {
+    describe("isFunction", function () {
+        it("should return true for functions", function () {
             expect(utils.isFunction([])).toBe(false);
             expect(utils.isFunction([5, 3, 7])).toBe(false);
             expect(utils.isFunction(undefined)).toBe(false);
@@ -106,36 +104,39 @@ describe("utils", function() {
             expect(utils.isFunction("foo")).toBe(false);
             expect(utils.isFunction(555)).toBe(false);
 
-            expect(utils.isFunction(function() {})).toBe(true);
-            const s = { foo: function() {} };
+            expect(utils.isFunction(function () {})).toBe(true);
+            const s = { foo: function () {} };
             expect(utils.isFunction(s.foo)).toBe(true);
         });
     });
 
-    describe("checkObjectHasKeys", function() {
-        it("should throw for missing keys", function() {
-            expect(function() {
+    describe("checkObjectHasKeys", function () {
+        it("should throw for missing keys", function () {
+            expect(function () {
                 utils.checkObjectHasKeys({}, ["foo"]);
             }).toThrow();
-            expect(function() {
-                utils.checkObjectHasKeys({
-                    foo: "bar",
-                }, ["foo"]);
+            expect(function () {
+                utils.checkObjectHasKeys(
+                    {
+                        foo: "bar",
+                    },
+                    ["foo"],
+                );
             }).not.toThrow();
         });
     });
 
-    describe("deepCompare", function() {
+    describe("deepCompare", function () {
         const assert = {
-            isTrue: function(x: any) {
+            isTrue: function (x: any) {
                 expect(x).toBe(true);
             },
-            isFalse: function(x: any) {
+            isFalse: function (x: any) {
                 expect(x).toBe(false);
             },
         };
 
-        it("should handle primitives", function() {
+        it("should handle primitives", function () {
             assert.isTrue(utils.deepCompare(null, null));
             assert.isFalse(utils.deepCompare(null, undefined));
             assert.isTrue(utils.deepCompare("hi", "hi"));
@@ -143,26 +144,26 @@ describe("utils", function() {
             assert.isFalse(utils.deepCompare(5, 10));
         });
 
-        it("should handle regexps", function() {
+        it("should handle regexps", function () {
             assert.isTrue(utils.deepCompare(/abc/, /abc/));
             assert.isFalse(utils.deepCompare(/abc/, /123/));
             const r = /abc/;
             assert.isTrue(utils.deepCompare(r, r));
         });
 
-        it("should handle dates", function() {
+        it("should handle dates", function () {
             assert.isTrue(utils.deepCompare(new Date("2011-03-31"), new Date("2011-03-31")));
             assert.isFalse(utils.deepCompare(new Date("2011-03-31"), new Date("1970-01-01")));
         });
 
-        it("should handle arrays", function() {
+        it("should handle arrays", function () {
             assert.isTrue(utils.deepCompare([], []));
             assert.isTrue(utils.deepCompare([1, 2], [1, 2]));
             assert.isFalse(utils.deepCompare([1, 2], [2, 1]));
             assert.isFalse(utils.deepCompare([1, 2], [1, 2, 3]));
         });
 
-        it("should handle simple objects", function() {
+        it("should handle simple objects", function () {
             assert.isTrue(utils.deepCompare({}, {}));
             assert.isTrue(utils.deepCompare({ a: 1, b: 2 }, { a: 1, b: 2 }));
             assert.isTrue(utils.deepCompare({ a: 1, b: 2 }, { b: 2, a: 1 }));
@@ -171,34 +172,44 @@ describe("utils", function() {
             assert.isFalse(utils.deepCompare({ a: 1 }, { a: 1, b: 2 }));
             assert.isFalse(utils.deepCompare({ a: 1 }, { b: 1 }));
 
-            assert.isTrue(utils.deepCompare({
-                1: { name: "mhc", age: 28 },
-                2: { name: "arb", age: 26 },
-            }, {
-                1: { name: "mhc", age: 28 },
-                2: { name: "arb", age: 26 },
-            }));
-
-            assert.isFalse(utils.deepCompare({
-                1: { name: "mhc", age: 28 },
-                2: { name: "arb", age: 26 },
-            }, {
-                1: { name: "mhc", age: 28 },
-                2: { name: "arb", age: 27 },
-            }));
+            assert.isTrue(
+                utils.deepCompare(
+                    {
+                        1: { name: "mhc", age: 28 },
+                        2: { name: "arb", age: 26 },
+                    },
+                    {
+                        1: { name: "mhc", age: 28 },
+                        2: { name: "arb", age: 26 },
+                    },
+                ),
+            );
+
+            assert.isFalse(
+                utils.deepCompare(
+                    {
+                        1: { name: "mhc", age: 28 },
+                        2: { name: "arb", age: 26 },
+                    },
+                    {
+                        1: { name: "mhc", age: 28 },
+                        2: { name: "arb", age: 27 },
+                    },
+                ),
+            );
 
             assert.isFalse(utils.deepCompare({}, null));
             assert.isFalse(utils.deepCompare({}, undefined));
         });
 
-        it("should handle functions", function() {
+        it("should handle functions", function () {
             // no two different function is equal really, they capture their
             // context variables so even if they have same toString(), they
             // won't have same functionality
-            const func = function() {
+            const func = function () {
                 return true;
             };
-            const func2 = function() {
+            const func2 = function () {
                 return true;
             };
             assert.isTrue(utils.deepCompare(func, func));
@@ -208,8 +219,8 @@ describe("utils", function() {
         });
     });
 
-    describe("chunkPromises", function() {
-        it("should execute promises in chunks", async function() {
+    describe("chunkPromises", function () {
+        it("should execute promises in chunks", async function () {
             let promiseCount = 0;
 
             async function fn1() {
@@ -228,8 +239,8 @@ describe("utils", function() {
         });
     });
 
-    describe('simpleRetryOperation', () => {
-        it('should retry', async () => {
+    describe("simpleRetryOperation", () => {
+        it("should retry", async () => {
             let count = 0;
             const val = {};
             const fn = (attempt: any) => {
@@ -256,24 +267,24 @@ describe("utils", function() {
         // all that concerns us.
     });
 
-    describe('DEFAULT_ALPHABET', () => {
-        it('should be usefully printable ASCII in order', () => {
+    describe("DEFAULT_ALPHABET", () => {
+        it("should be usefully printable ASCII in order", () => {
             expect(DEFAULT_ALPHABET).toEqual(
                 " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
             );
         });
     });
 
-    describe('alphabetPad', () => {
-        it('should pad to the alphabet length', () => {
+    describe("alphabetPad", () => {
+        it("should pad to the alphabet length", () => {
             const len = 12;
-            expect(alphabetPad("a", len)).toEqual("a" + ("".padEnd(len - 1, DEFAULT_ALPHABET[0])));
-            expect(alphabetPad("a", len, "123")).toEqual("a" + ("".padEnd(len - 1, '1')));
+            expect(alphabetPad("a", len)).toEqual("a" + "".padEnd(len - 1, DEFAULT_ALPHABET[0]));
+            expect(alphabetPad("a", len, "123")).toEqual("a" + "".padEnd(len - 1, "1"));
         });
     });
 
-    describe('baseToString', () => {
-        it('should calculate the appropriate string from numbers', () => {
+    describe("baseToString", () => {
+        it("should calculate the appropriate string from numbers", () => {
             // Verify the whole alphabet
             for (let i = BigInt(1); i <= DEFAULT_ALPHABET.length; i++) {
                 logger.log({ i }); // for debugging
@@ -290,14 +301,14 @@ describe("utils", function() {
             expect(baseToString(BigInt(7820126496))).toEqual(DEFAULT_ALPHABET[0].repeat(6));
 
             expect(baseToString(BigInt(10))).toEqual(DEFAULT_ALPHABET[9]);
-            expect(baseToString(BigInt(10), "abcdefghijklmnopqrstuvwxyz")).toEqual('j');
+            expect(baseToString(BigInt(10), "abcdefghijklmnopqrstuvwxyz")).toEqual("j");
             expect(baseToString(BigInt(6337))).toEqual("ab");
-            expect(baseToString(BigInt(80), "abcdefghijklmnopqrstuvwxyz")).toEqual('cb');
+            expect(baseToString(BigInt(80), "abcdefghijklmnopqrstuvwxyz")).toEqual("cb");
         });
     });
 
-    describe('stringToBase', () => {
-        it('should calculate the appropriate number for a string', () => {
+    describe("stringToBase", () => {
+        it("should calculate the appropriate number for a string", () => {
             expect(stringToBase(DEFAULT_ALPHABET[0].repeat(1))).toEqual(BigInt(1));
             expect(stringToBase(DEFAULT_ALPHABET[0].repeat(2))).toEqual(BigInt(96));
             expect(stringToBase(DEFAULT_ALPHABET[0].repeat(3))).toEqual(BigInt(9121));
@@ -312,42 +323,42 @@ describe("utils", function() {
         });
     });
 
-    describe('averageBetweenStrings', () => {
-        it('should average appropriately', () => {
+    describe("averageBetweenStrings", () => {
+        it("should average appropriately", () => {
             expect(averageBetweenStrings("  ", "!!")).toEqual(" P");
             expect(averageBetweenStrings(" ", "!")).toEqual("  ");
-            expect(averageBetweenStrings('A', 'B')).toEqual('A ');
-            expect(averageBetweenStrings('AA', 'BB')).toEqual('Aq');
-            expect(averageBetweenStrings('A', 'z')).toEqual(']');
-            expect(averageBetweenStrings('a', 'z', "abcdefghijklmnopqrstuvwxyz")).toEqual('m');
-            expect(averageBetweenStrings('AA', 'zz')).toEqual('^.');
-            expect(averageBetweenStrings('aa', 'zz', "abcdefghijklmnopqrstuvwxyz")).toEqual('mz');
-            expect(averageBetweenStrings('cat', 'doggo')).toEqual("d9>Cw");
-            expect(averageBetweenStrings('cat', 'doggo', "abcdefghijklmnopqrstuvwxyz")).toEqual("cumqh");
+            expect(averageBetweenStrings("A", "B")).toEqual("A ");
+            expect(averageBetweenStrings("AA", "BB")).toEqual("Aq");
+            expect(averageBetweenStrings("A", "z")).toEqual("]");
+            expect(averageBetweenStrings("a", "z", "abcdefghijklmnopqrstuvwxyz")).toEqual("m");
+            expect(averageBetweenStrings("AA", "zz")).toEqual("^.");
+            expect(averageBetweenStrings("aa", "zz", "abcdefghijklmnopqrstuvwxyz")).toEqual("mz");
+            expect(averageBetweenStrings("cat", "doggo")).toEqual("d9>Cw");
+            expect(averageBetweenStrings("cat", "doggo", "abcdefghijklmnopqrstuvwxyz")).toEqual("cumqh");
         });
     });
 
-    describe('nextString', () => {
-        it('should find the next string appropriately', () => {
-            expect(nextString('A')).toEqual('B');
-            expect(nextString('b', 'abcdefghijklmnopqrstuvwxyz')).toEqual('c');
-            expect(nextString('cat')).toEqual('cau');
-            expect(nextString('cat', 'abcdefghijklmnopqrstuvwxyz')).toEqual('cau');
+    describe("nextString", () => {
+        it("should find the next string appropriately", () => {
+            expect(nextString("A")).toEqual("B");
+            expect(nextString("b", "abcdefghijklmnopqrstuvwxyz")).toEqual("c");
+            expect(nextString("cat")).toEqual("cau");
+            expect(nextString("cat", "abcdefghijklmnopqrstuvwxyz")).toEqual("cau");
         });
     });
 
-    describe('prevString', () => {
-        it('should find the next string appropriately', () => {
-            expect(prevString('B')).toEqual('A');
-            expect(prevString('c', 'abcdefghijklmnopqrstuvwxyz')).toEqual('b');
-            expect(prevString('cau')).toEqual('cat');
-            expect(prevString('cau', 'abcdefghijklmnopqrstuvwxyz')).toEqual('cat');
+    describe("prevString", () => {
+        it("should find the next string appropriately", () => {
+            expect(prevString("B")).toEqual("A");
+            expect(prevString("c", "abcdefghijklmnopqrstuvwxyz")).toEqual("b");
+            expect(prevString("cau")).toEqual("cat");
+            expect(prevString("cau", "abcdefghijklmnopqrstuvwxyz")).toEqual("cat");
         });
     });
 
     // Let's just ensure the ordering is sensible for lexicographic ordering
-    describe('string averaging unified', () => {
-        it('should be truly previous and next', () => {
+    describe("string averaging unified", () => {
+        it("should be truly previous and next", () => {
             let midpoint = "cat";
 
             // We run this test 100 times to ensure we end up with a sane sequence.
@@ -364,7 +375,7 @@ describe("utils", function() {
             }
         });
 
-        it('should roll over', () => {
+        it("should roll over", () => {
             const lastAlpha = DEFAULT_ALPHABET[DEFAULT_ALPHABET.length - 1];
             const firstAlpha = DEFAULT_ALPHABET[0];
 
@@ -375,14 +386,14 @@ describe("utils", function() {
             expect(prevString(highRoll)).toEqual(lowRoll);
         });
 
-        it('should be reversible on small strings', () => {
+        it("should be reversible on small strings", () => {
             // Large scale reversibility is tested for max space order value
             const input = "cats";
             expect(prevString(nextString(input))).toEqual(input);
         });
 
         // We want to explicitly make sure that Space order values are supported and roll appropriately
-        it('should properly handle rolling over at 50 characters', () => {
+        it("should properly handle rolling over at 50 characters", () => {
             // Note: we also test reversibility of large strings here.
 
             const maxSpaceValue = DEFAULT_ALPHABET[DEFAULT_ALPHABET.length - 1].repeat(50);
@@ -397,30 +408,30 @@ describe("utils", function() {
         });
     });
 
-    describe('lexicographicCompare', () => {
-        it('should work', () => {
+    describe("lexicographicCompare", () => {
+        it("should work", () => {
             // Simple tests
-            expect(lexicographicCompare('a', 'b') < 0).toBe(true);
-            expect(lexicographicCompare('ab', 'b') < 0).toBe(true);
-            expect(lexicographicCompare('cat', 'dog') < 0).toBe(true);
+            expect(lexicographicCompare("a", "b") < 0).toBe(true);
+            expect(lexicographicCompare("ab", "b") < 0).toBe(true);
+            expect(lexicographicCompare("cat", "dog") < 0).toBe(true);
 
             // Simple tests (reversed)
-            expect(lexicographicCompare('b', 'a') > 0).toBe(true);
-            expect(lexicographicCompare('b', 'ab') > 0).toBe(true);
-            expect(lexicographicCompare('dog', 'cat') > 0).toBe(true);
+            expect(lexicographicCompare("b", "a") > 0).toBe(true);
+            expect(lexicographicCompare("b", "ab") > 0).toBe(true);
+            expect(lexicographicCompare("dog", "cat") > 0).toBe(true);
 
             // Simple equality tests
-            expect(lexicographicCompare('a', 'a') === 0).toBe(true);
-            expect(lexicographicCompare('A', 'A') === 0).toBe(true);
+            expect(lexicographicCompare("a", "a") === 0).toBe(true);
+            expect(lexicographicCompare("A", "A") === 0).toBe(true);
 
             // ASCII rule testing
-            expect(lexicographicCompare('A', 'a') < 0).toBe(true);
-            expect(lexicographicCompare('a', 'A') > 0).toBe(true);
+            expect(lexicographicCompare("A", "a") < 0).toBe(true);
+            expect(lexicographicCompare("a", "A") > 0).toBe(true);
         });
     });
 
-    describe('deepSortedObjectEntries', () => {
-        it('should auto-return non-objects', () => {
+    describe("deepSortedObjectEntries", () => {
+        it("should auto-return non-objects", () => {
             expect(deepSortedObjectEntries(42)).toEqual(42);
             expect(deepSortedObjectEntries("not object")).toEqual("not object");
             expect(deepSortedObjectEntries(true)).toEqual(true);
@@ -429,7 +440,7 @@ describe("utils", function() {
             expect(deepSortedObjectEntries(undefined)).toEqual(undefined);
         });
 
-        it('should sort objects appropriately', () => {
+        it("should sort objects appropriately", () => {
             const input = {
                 a: 42,
                 b: {
@@ -442,11 +453,14 @@ describe("utils", function() {
             const output: any = [
                 ["72", "test"],
                 ["a", 42],
-                ["b", [
-                    ["a", "test"],
-                    ["b", "alpha"],
-                    ["d", []],
-                ]],
+                [
+                    "b",
+                    [
+                        ["a", "test"],
+                        ["b", "alpha"],
+                        ["d", []],
+                    ],
+                ],
             ];
 
             expect(deepSortedObjectEntries(input)).toMatchObject(output);
@@ -455,16 +469,20 @@ describe("utils", function() {
 
     describe("recursivelyAssign", () => {
         it("doesn't override with null/undefined", () => {
-            const result = utils.recursivelyAssign<{
-                string: string;
-                object: object;
-                float: number;
-            }, {}>(
+            const result = utils.recursivelyAssign<
+                {
+                    string: string;
+                    object: object;
+                    float: number;
+                },
+                {}
+            >(
                 {
                     string: "Hello world",
                     object: {},
                     float: 0.1,
-                }, {
+                },
+                {
                     string: null,
                     object: undefined,
                 },
@@ -479,11 +497,14 @@ describe("utils", function() {
         });
 
         it("assigns recursively", () => {
-            const result = utils.recursivelyAssign<{
-                number: number;
-                object: object;
-                thing: string | object;
-            }, {}>(
+            const result = utils.recursivelyAssign<
+                {
+                    number: number;
+                    object: object;
+                    thing: string | object;
+                },
+                {}
+            >(
                 {
                     number: 42,
                     object: {
@@ -494,7 +515,8 @@ describe("utils", function() {
                         },
                     },
                     thing: "string",
-                }, {
+                },
+                {
                     number: 2,
                     object: {
                         message: "How are you",
@@ -525,9 +547,9 @@ describe("utils", function() {
         });
     });
 
-    describe('sortEventsByLatestContentTimestamp', () => {
-        const roomId = '!room:server';
-        const userId = '@user:server';
+    describe("sortEventsByLatestContentTimestamp", () => {
+        const roomId = "!room:server";
+        const userId = "@user:server";
         const eventWithoutContentTimestamp = mkMessage({ room: roomId, user: userId, event: true });
         // m.beacon events have timestamp in content
         const beaconEvent1 = makeBeaconEvent(userId, { timestamp: 1648804528557 });
@@ -535,32 +557,33 @@ describe("utils", function() {
         const beaconEvent3 = makeBeaconEvent(userId, { timestamp: 1648804528000 });
         const beaconEvent4 = makeBeaconEvent(userId, { timestamp: 0 });
 
-        it('sorts events with timestamps as later than events without', () => {
+        it("sorts events with timestamps as later than events without", () => {
             expect(
-                [beaconEvent4, eventWithoutContentTimestamp, beaconEvent1]
-                    .sort(utils.sortEventsByLatestContentTimestamp),
-            ).toEqual([
-                beaconEvent1, beaconEvent4, eventWithoutContentTimestamp,
-            ]);
+                [beaconEvent4, eventWithoutContentTimestamp, beaconEvent1].sort(
+                    utils.sortEventsByLatestContentTimestamp,
+                ),
+            ).toEqual([beaconEvent1, beaconEvent4, eventWithoutContentTimestamp]);
         });
 
-        it('sorts by content timestamps correctly', () => {
-            expect(
-                [beaconEvent1, beaconEvent2, beaconEvent3].sort(sortEventsByLatestContentTimestamp),
-            ).toEqual([beaconEvent2, beaconEvent1, beaconEvent3]);
+        it("sorts by content timestamps correctly", () => {
+            expect([beaconEvent1, beaconEvent2, beaconEvent3].sort(sortEventsByLatestContentTimestamp)).toEqual([
+                beaconEvent2,
+                beaconEvent1,
+                beaconEvent3,
+            ]);
         });
     });
 
-    describe('isSupportedReceiptType', () => {
-        it('should support m.read', () => {
+    describe("isSupportedReceiptType", () => {
+        it("should support m.read", () => {
             expect(utils.isSupportedReceiptType(ReceiptType.Read)).toBeTruthy();
         });
 
-        it('should support m.read.private', () => {
+        it("should support m.read.private", () => {
             expect(utils.isSupportedReceiptType(ReceiptType.ReadPrivate)).toBeTruthy();
         });
 
-        it('should not support other receipt types', () => {
+        it("should not support other receipt types", () => {
             expect(utils.isSupportedReceiptType("this is a receipt type")).toBeFalsy();
         });
     });
diff --git a/spec/unit/webrtc/call.spec.ts b/spec/unit/webrtc/call.spec.ts
index eb5d4c18e80..9ddf880aba9 100644
--- a/spec/unit/webrtc/call.spec.ts
+++ b/spec/unit/webrtc/call.spec.ts
@@ -16,7 +16,7 @@ limitations under the License.
 
 import { mocked } from "jest-mock";
 
-import { TestClient } from '../../TestClient';
+import { TestClient } from "../../TestClient";
 import {
     MatrixCall,
     CallErrorCode,
@@ -25,14 +25,14 @@ import {
     CallType,
     CallState,
     CallParty,
-} from '../../../src/webrtc/call';
+} from "../../../src/webrtc/call";
 import {
     MCallAnswer,
     MCallHangupReject,
     SDPStreamMetadata,
     SDPStreamMetadataKey,
     SDPStreamMetadataPurpose,
-} from '../../../src/webrtc/callEventTypes';
+} from "../../../src/webrtc/callEventTypes";
 import {
     DUMMY_SDP,
     MockMediaHandler,
@@ -78,17 +78,19 @@ const fakeIncomingCall = async (client: TestClient, call: MatrixCall, version: s
         getSender: () => "@test:foo",
         getLocalAge: () => 1,
     } as unknown as MatrixEvent);
-    call.getFeeds().push(new CallFeed({
-        client: client.client,
-        userId: "remote_user_id",
-        deviceId: undefined,
-        stream: new MockMediaStream(
-            "remote_stream_id", [new MockMediaStreamTrack("remote_tack_id", "audio")],
-        ) as unknown as MediaStream,
-        purpose: SDPStreamMetadataPurpose.Usermedia,
-        audioMuted: false,
-        videoMuted: false,
-    }));
+    call.getFeeds().push(
+        new CallFeed({
+            client: client.client,
+            userId: "remote_user_id",
+            deviceId: undefined,
+            stream: new MockMediaStream("remote_stream_id", [
+                new MockMediaStreamTrack("remote_tack_id", "audio"),
+            ]) as unknown as MediaStream,
+            purpose: SDPStreamMetadataPurpose.Usermedia,
+            audioMuted: false,
+            videoMuted: false,
+        }),
+    );
     await callPromise;
 };
 
@@ -101,7 +103,7 @@ function makeMockEvent(sender: string, content: Record<string, any>): MatrixEven
     } as MatrixEvent;
 }
 
-describe('Call', function() {
+describe("Call", function () {
     let client: TestClient;
     let call: MatrixCall;
     let prevNavigator: Navigator;
@@ -112,7 +114,7 @@ describe('Call', function() {
 
     const errorListener = () => {};
 
-    beforeEach(function() {
+    beforeEach(function () {
         prevNavigator = global.navigator;
         prevDocument = global.document;
         prevWindow = global.window;
@@ -125,8 +127,8 @@ describe('Call', function() {
         client.client.sendEvent = mockSendEvent = jest.fn();
         {
             // in which we do naughty assignments to private members
-            const untypedClient = (client.client as any);
-            untypedClient.mediaHandler = new MockMediaHandler;
+            const untypedClient = client.client as any;
+            untypedClient.mediaHandler = new MockMediaHandler();
             untypedClient.turnServersExpiry = Date.now() + 60 * 60 * 1000;
         }
 
@@ -148,7 +150,7 @@ describe('Call', function() {
         call.on(CallEvent.Error, errorListener);
     });
 
-    afterEach(function() {
+    afterEach(function () {
         // Hangup to stop timers
         call.hangup(CallErrorCode.UserHangup, true);
 
@@ -160,115 +162,131 @@ describe('Call', function() {
         jest.useRealTimers();
     });
 
-    it('should ignore candidate events from non-matching party ID', async function() {
+    it("should ignore candidate events from non-matching party ID", async function () {
         await startVoiceCall(client, call);
 
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'the_correct_party_id',
-            answer: {
-                sdp: DUMMY_SDP,
-            },
-        }));
-
-        const mockAddIceCandidate = call.peerConn!.addIceCandidate = jest.fn();
-        call.onRemoteIceCandidatesReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'the_correct_party_id',
-            candidates: [
-                {
-                    candidate: '',
-                    sdpMid: '',
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "the_correct_party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
                 },
-            ],
-        }));
+            }),
+        );
+
+        const mockAddIceCandidate = (call.peerConn!.addIceCandidate = jest.fn());
+        call.onRemoteIceCandidatesReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "the_correct_party_id",
+                candidates: [
+                    {
+                        candidate: "",
+                        sdpMid: "",
+                    },
+                ],
+            }),
+        );
         expect(mockAddIceCandidate).toHaveBeenCalled();
 
-        call.onRemoteIceCandidatesReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'some_other_party_id',
-            candidates: [
-                {
-                    candidate: '',
-                    sdpMid: '',
-                },
-            ],
-        }));
+        call.onRemoteIceCandidatesReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "some_other_party_id",
+                candidates: [
+                    {
+                        candidate: "",
+                        sdpMid: "",
+                    },
+                ],
+            }),
+        );
         expect(mockAddIceCandidate).toHaveBeenCalled();
     });
 
-    it('should add candidates received before answer if party ID is correct', async function() {
+    it("should add candidates received before answer if party ID is correct", async function () {
         await startVoiceCall(client, call);
-        const mockAddIceCandidate = call.peerConn!.addIceCandidate = jest.fn();
-
-        call.onRemoteIceCandidatesReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'the_correct_party_id',
-            candidates: [
-                {
-                    candidate: 'the_correct_candidate',
-                    sdpMid: '',
-                },
-            ],
-        }));
-
-        call.onRemoteIceCandidatesReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'some_other_party_id',
-            candidates: [
-                {
-                    candidate: 'the_wrong_candidate',
-                    sdpMid: '',
-                },
-            ],
-        }));
+        const mockAddIceCandidate = (call.peerConn!.addIceCandidate = jest.fn());
+
+        call.onRemoteIceCandidatesReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "the_correct_party_id",
+                candidates: [
+                    {
+                        candidate: "the_correct_candidate",
+                        sdpMid: "",
+                    },
+                ],
+            }),
+        );
+
+        call.onRemoteIceCandidatesReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "some_other_party_id",
+                candidates: [
+                    {
+                        candidate: "the_wrong_candidate",
+                        sdpMid: "",
+                    },
+                ],
+            }),
+        );
 
         expect(mockAddIceCandidate).not.toHaveBeenCalled();
 
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'the_correct_party_id',
-            answer: {
-                sdp: DUMMY_SDP,
-            },
-        }));
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "the_correct_party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
+                },
+            }),
+        );
 
         expect(mockAddIceCandidate).toHaveBeenCalled();
         expect(mockAddIceCandidate).toHaveBeenCalledWith({
-            candidate: 'the_correct_candidate',
-            sdpMid: '',
+            candidate: "the_correct_candidate",
+            sdpMid: "",
         });
     });
 
-    it('should map asserted identity messages to remoteAssertedIdentity', async function() {
+    it("should map asserted identity messages to remoteAssertedIdentity", async function () {
         await startVoiceCall(client, call);
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'party_id',
-            answer: {
-                sdp: DUMMY_SDP,
-            },
-        }));
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
+                },
+            }),
+        );
 
         const identChangedCallback = jest.fn();
         call.on(CallEvent.AssertedIdentityChanged, identChangedCallback);
 
-        await call.onAssertedIdentityReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'party_id',
-            asserted_identity: {
-                id: "@steve:example.com",
-                display_name: "Steve Gibbons",
-            },
-        }));
+        await call.onAssertedIdentityReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                asserted_identity: {
+                    id: "@steve:example.com",
+                    display_name: "Steve Gibbons",
+                },
+            }),
+        );
 
         expect(identChangedCallback).toHaveBeenCalled();
 
@@ -280,30 +298,29 @@ describe('Call', function() {
     it("should map SDPStreamMetadata to feeds", async () => {
         await startVoiceCall(client, call);
 
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'party_id',
-            answer: {
-                sdp: DUMMY_SDP,
-            },
-            [SDPStreamMetadataKey]: {
-                "remote_stream": {
-                    purpose: SDPStreamMetadataPurpose.Usermedia,
-                    audio_muted: true,
-                    video_muted: false,
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
                 },
-            },
-        }));
+                [SDPStreamMetadataKey]: {
+                    remote_stream: {
+                        purpose: SDPStreamMetadataPurpose.Usermedia,
+                        audio_muted: true,
+                        video_muted: false,
+                    },
+                },
+            }),
+        );
 
         (call as any).pushRemoteFeed(
-            new MockMediaStream(
-                "remote_stream",
-                [
-                    new MockMediaStreamTrack("remote_audio_track", "audio"),
-                    new MockMediaStreamTrack("remote_video_track", "video"),
-                ],
-            ),
+            new MockMediaStream("remote_stream", [
+                new MockMediaStreamTrack("remote_audio_track", "audio"),
+                new MockMediaStreamTrack("remote_video_track", "video"),
+            ]),
         );
         const feed = call.getFeeds().find((feed) => feed.stream.id === "remote_stream");
         expect(feed?.purpose).toBe(SDPStreamMetadataPurpose.Usermedia);
@@ -314,16 +331,18 @@ describe('Call', function() {
     it("should fallback to replaceTrack() if the other side doesn't support SPDStreamMetadata", async () => {
         await startVoiceCall(client, call);
 
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'party_id',
-            answer: {
-                sdp: DUMMY_SDP,
-            },
-        }));
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
+                },
+            }),
+        );
 
-        const mockScreenshareNoMetadata = (call as any).setScreensharingEnabledWithoutMetadataSupport = jest.fn();
+        const mockScreenshareNoMetadata = ((call as any).setScreensharingEnabledWithoutMetadataSupport = jest.fn());
 
         call.setScreensharingEnabled(true);
         expect(mockScreenshareNoMetadata).toHaveBeenCalled();
@@ -342,34 +361,33 @@ describe('Call', function() {
     });
 
     it("should handle mid-call device changes", async () => {
-        client.client.getMediaHandler().getUserMediaStream = jest.fn().mockReturnValue(
-            new MockMediaStream(
-                "stream", [
+        client.client.getMediaHandler().getUserMediaStream = jest
+            .fn()
+            .mockReturnValue(
+                new MockMediaStream("stream", [
                     new MockMediaStreamTrack("audio_track", "audio"),
                     new MockMediaStreamTrack("video_track", "video"),
-                ],
-            ),
-        );
+                ]),
+            );
 
         await startVoiceCall(client, call);
 
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'party_id',
-            answer: {
-                sdp: DUMMY_SDP,
-            },
-        }));
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
+                },
+            }),
+        );
 
         await call.updateLocalUsermediaStream(
-            new MockMediaStream(
-                "replacement_stream",
-                [
-                    new MockMediaStreamTrack("new_audio_track", "audio"),
-                    new MockMediaStreamTrack("video_track", "video"),
-                ],
-            ).typed(),
+            new MockMediaStream("replacement_stream", [
+                new MockMediaStreamTrack("new_audio_track", "audio"),
+                new MockMediaStreamTrack("video_track", "video"),
+            ]).typed(),
         );
 
         // XXX: Lots of inspecting the prvate state of the call object here
@@ -386,15 +404,17 @@ describe('Call', function() {
     it("should handle upgrade to video call", async () => {
         await startVoiceCall(client, call);
 
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'party_id',
-            answer: {
-                sdp: DUMMY_SDP,
-            },
-            [SDPStreamMetadataKey]: {},
-        }));
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
+                },
+                [SDPStreamMetadataKey]: {},
+            }),
+        );
 
         // XXX Should probably test using the public interfaces, ie.
         // setLocalVideoMuted probably?
@@ -413,7 +433,7 @@ describe('Call', function() {
         await startVoiceCall(client, call);
 
         (call as any).updateRemoteSDPStreamMetadata({
-            "remote_stream": {
+            remote_stream: {
                 purpose: SDPStreamMetadataPurpose.Usermedia,
                 audio_muted: false,
                 video_muted: false,
@@ -422,16 +442,18 @@ describe('Call', function() {
         (call as any).pushRemoteFeed(new MockMediaStream("remote_stream", []));
         const feed = call.getFeeds().find((feed) => feed.stream.id === "remote_stream");
 
-        call.onSDPStreamMetadataChangedReceived(makeMockEvent("@test:foo", {
-            [SDPStreamMetadataKey]: {
-                "remote_stream": {
-                    purpose: SDPStreamMetadataPurpose.Screenshare,
-                    audio_muted: true,
-                    video_muted: true,
-                    id: "feed_id2",
+        call.onSDPStreamMetadataChangedReceived(
+            makeMockEvent("@test:foo", {
+                [SDPStreamMetadataKey]: {
+                    remote_stream: {
+                        purpose: SDPStreamMetadataPurpose.Screenshare,
+                        audio_muted: true,
+                        video_muted: true,
+                        id: "feed_id2",
+                    },
                 },
-            },
-        }));
+            }),
+        );
 
         expect(feed?.purpose).toBe(SDPStreamMetadataPurpose.Screenshare);
         expect(feed?.isAudioMuted()).toBe(true);
@@ -462,11 +484,13 @@ describe('Call', function() {
             "m.call.transferee": true,
             "m.call.dtmf": false,
         };
-        (call as any).chooseOpponent(makeMockEvent(opponentMember.userId, {
-            version: 1,
-            party_id: "party_id",
-            capabilities: opponentCaps,
-        }));
+        (call as any).chooseOpponent(
+            makeMockEvent(opponentMember.userId, {
+                version: 1,
+                party_id: "party_id",
+                capabilities: opponentCaps,
+            }),
+        );
 
         expect(call.getOpponentMember()).toBe(opponentMember);
         expect((call as any).opponentPartyId).toBe("party_id");
@@ -522,40 +546,42 @@ describe('Call', function() {
     });
 
     it("should correctly generate local SDPStreamMetadata", async () => {
-        const callPromise = call.placeCallWithCallFeeds([new CallFeed({
-            client: client.client,
-            stream: new MockMediaStream(
-                "local_stream1", [new MockMediaStreamTrack("track_id", "audio")],
-            ) as unknown as MediaStream,
-            roomId: call.roomId,
-            userId: client.getUserId(),
-            deviceId: undefined,
-            purpose: SDPStreamMetadataPurpose.Usermedia,
-            audioMuted: false,
-            videoMuted: false,
-        })]);
+        const callPromise = call.placeCallWithCallFeeds([
+            new CallFeed({
+                client: client.client,
+                stream: new MockMediaStream("local_stream1", [
+                    new MockMediaStreamTrack("track_id", "audio"),
+                ]) as unknown as MediaStream,
+                roomId: call.roomId,
+                userId: client.getUserId(),
+                deviceId: undefined,
+                purpose: SDPStreamMetadataPurpose.Usermedia,
+                audioMuted: false,
+                videoMuted: false,
+            }),
+        ]);
         await client.httpBackend!.flush("");
         await callPromise;
         call.getOpponentMember = jest.fn().mockReturnValue({ userId: "@bob:bar.uk" });
 
         (call as any).pushNewLocalFeed(
-            new MockMediaStream(
-                "local_stream2", [new MockMediaStreamTrack("track_id", "video")],
-            ) as unknown as MediaStream,
+            new MockMediaStream("local_stream2", [
+                new MockMediaStreamTrack("track_id", "video"),
+            ]) as unknown as MediaStream,
             SDPStreamMetadataPurpose.Screenshare,
         );
         await call.setMicrophoneMuted(true);
 
         expect((call as any).getLocalSDPStreamMetadata()).toStrictEqual({
-            "local_stream1": {
-                "purpose": SDPStreamMetadataPurpose.Usermedia,
-                "audio_muted": true,
-                "video_muted": true,
+            local_stream1: {
+                purpose: SDPStreamMetadataPurpose.Usermedia,
+                audio_muted: true,
+                video_muted: true,
             },
-            "local_stream2": {
-                "purpose": SDPStreamMetadataPurpose.Screenshare,
-                "audio_muted": true,
-                "video_muted": false,
+            local_stream2: {
+                purpose: SDPStreamMetadataPurpose.Screenshare,
+                audio_muted: true,
+                video_muted: false,
             },
         });
     });
@@ -591,12 +617,12 @@ describe('Call', function() {
         call.getOpponentMember = jest.fn().mockReturnValue({ userId: "@bob:bar.uk" });
 
         (call as any).updateRemoteSDPStreamMetadata({
-            "remote_usermedia_stream_id": {
+            remote_usermedia_stream_id: {
                 purpose: SDPStreamMetadataPurpose.Usermedia,
                 audio_muted: false,
                 video_muted: false,
             },
-            "remote_screensharing_stream_id": {
+            remote_screensharing_stream_id: {
                 purpose: SDPStreamMetadataPurpose.Screenshare,
                 id: "remote_screensharing_feed_id",
                 audio_muted: false,
@@ -623,12 +649,14 @@ describe('Call', function() {
         const callHangupCallback = jest.fn();
         call.on(CallEvent.Hangup, callHangupCallback);
 
-        await call.onSelectAnswerReceived(makeMockEvent("@test:foo.bar", {
-            version: 1,
-            call_id: call.callId,
-            party_id: 'party_id',
-            selected_party_id: "different_party_id",
-        }));
+        await call.onSelectAnswerReceived(
+            makeMockEvent("@test:foo.bar", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                selected_party_id: "different_party_id",
+            }),
+        );
 
         expect(callHangupCallback).toHaveBeenCalled();
     });
@@ -638,7 +666,7 @@ describe('Call', function() {
             client.client.isFallbackICEServerAllowed = () => true;
             const localCall = new MatrixCall({
                 client: client.client,
-                roomId: '!room_id',
+                roomId: "!room_id",
             });
 
             expect((localCall as any).turnServers).toStrictEqual([{ urls: ["stun:turn.matrix.org"] }]);
@@ -648,7 +676,7 @@ describe('Call', function() {
             client.client.isFallbackICEServerAllowed = () => false;
             const localCall = new MatrixCall({
                 client: client.client,
-                roomId: '!room_id',
+                roomId: "!room_id",
             });
 
             expect((localCall as any).turnServers).toStrictEqual([]);
@@ -659,7 +687,7 @@ describe('Call', function() {
             const turnServers = [{ urls: ["turn.server.org"] }];
             const localCall = new MatrixCall({
                 client: client.client,
-                roomId: '!room_id',
+                roomId: "!room_id",
                 turnServers,
             });
 
@@ -704,16 +732,18 @@ describe('Call', function() {
             expect(supportsMatrixCall()).toBe(false);
         });
 
-        it("should return false if RTCPeerConnection & RTCSessionDescription " +
-            "& RTCIceCandidate & mediaDevices are unavailable",
-        () => {
-            global.window.RTCPeerConnection = undefined!;
-            global.window.RTCSessionDescription = undefined!;
-            global.window.RTCIceCandidate = undefined!;
-            // @ts-ignore - writing to a read-only property as we are simulating faulty browsers
-            global.navigator.mediaDevices = undefined;
-            expect(supportsMatrixCall()).toBe(false);
-        });
+        it(
+            "should return false if RTCPeerConnection & RTCSessionDescription " +
+                "& RTCIceCandidate & mediaDevices are unavailable",
+            () => {
+                global.window.RTCPeerConnection = undefined!;
+                global.window.RTCSessionDescription = undefined!;
+                global.window.RTCIceCandidate = undefined!;
+                // @ts-ignore - writing to a read-only property as we are simulating faulty browsers
+                global.navigator.mediaDevices = undefined;
+                expect(supportsMatrixCall()).toBe(false);
+            },
+        );
     });
 
     describe("ignoring streams with ids for which we already have a feed", () => {
@@ -733,19 +763,21 @@ describe('Call', function() {
         });
 
         it("should ignore stream passed to pushRemoteFeed()", async () => {
-            await call.onAnswerReceived(makeMockEvent("@test:foo", {
-                version: 1,
-                call_id: call.callId,
-                party_id: 'party_id',
-                answer: {
-                    sdp: DUMMY_SDP,
-                },
-                [SDPStreamMetadataKey]: {
-                    [STREAM_ID]: {
-                        purpose: SDPStreamMetadataPurpose.Usermedia,
+            await call.onAnswerReceived(
+                makeMockEvent("@test:foo", {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: "party_id",
+                    answer: {
+                        sdp: DUMMY_SDP,
                     },
-                },
-            }));
+                    [SDPStreamMetadataKey]: {
+                        [STREAM_ID]: {
+                            purpose: SDPStreamMetadataPurpose.Usermedia,
+                        },
+                    },
+                }),
+            );
 
             (call as any).pushRemoteFeed(new MockMediaStream(STREAM_ID));
             (call as any).pushRemoteFeed(new MockMediaStream(STREAM_ID));
@@ -780,9 +812,13 @@ describe('Call', function() {
             await call.transferToCall(targetCall);
 
             const newCallId = (sendEvent.mock.calls[0][2] as any)!.await_call;
-            expect(sendEvent).toHaveBeenCalledWith(call.roomId, EventType.CallReplaces, expect.objectContaining({
-                create_call: newCallId,
-            }));
+            expect(sendEvent).toHaveBeenCalledWith(
+                call.roomId,
+                EventType.CallReplaces,
+                expect.objectContaining({
+                    create_call: newCallId,
+                }),
+            );
         });
     });
 
@@ -830,10 +866,12 @@ describe('Call', function() {
                         video_muted: video,
                     },
                 };
-                (call as any).pushRemoteFeed(new MockMediaStream("stream", [
-                    new MockMediaStreamTrack("track1", "audio"),
-                    new MockMediaStreamTrack("track1", "video"),
-                ]));
+                (call as any).pushRemoteFeed(
+                    new MockMediaStream("stream", [
+                        new MockMediaStreamTrack("track1", "audio"),
+                        new MockMediaStreamTrack("track1", "video"),
+                    ]),
+                );
                 call.onSDPStreamMetadataChangedReceived({
                     getContent: () => ({
                         [SDPStreamMetadataKey]: metadata,
@@ -938,7 +976,7 @@ describe('Call', function() {
 
             for (let tries = 0; tries < maxTries; ++tries) {
                 if (tries) {
-                    await new Promise(resolve => {
+                    await new Promise((resolve) => {
                         realSetTimeout(resolve, 100);
                     });
                 }
@@ -964,7 +1002,7 @@ describe('Call', function() {
                 expect.objectContaining({
                     call_id: call.callId,
                     answer: expect.objectContaining({
-                        type: 'offer',
+                        type: "offer",
                     }),
                 }),
             );
@@ -977,18 +1015,14 @@ describe('Call', function() {
                 candidate: {
                     candidate: fakeCandidateString,
                     sdpMLineIndex: 0,
-                    sdpMid: '0',
+                    sdpMid: "0",
                     toJSON: jest.fn().mockReturnValue(fakeCandidateString),
                 },
             } as unknown as RTCPeerConnectionIceEvent;
 
             beforeEach(async () => {
                 await call.answer();
-                await untilEventSent(
-                    FAKE_ROOM_ID,
-                    EventType.CallAnswer,
-                    expect.objectContaining({}),
-                );
+                await untilEventSent(FAKE_ROOM_ID, EventType.CallAnswer, expect.objectContaining({}));
                 mockPeerConn = call.peerConn as unknown as MockRTCPeerConnection;
             });
 
@@ -1003,9 +1037,7 @@ describe('Call', function() {
                     FAKE_ROOM_ID,
                     EventType.CallCandidates,
                     expect.objectContaining({
-                        candidates: [
-                            fakeCandidateString,
-                        ],
+                        candidates: [fakeCandidateString],
                     }),
                 );
             });
@@ -1021,9 +1053,7 @@ describe('Call', function() {
                     FAKE_ROOM_ID,
                     EventType.CallCandidates,
                     expect.objectContaining({
-                        candidates: [
-                            fakeCandidateString,
-                        ],
+                        candidates: [fakeCandidateString],
                     }),
                 );
 
@@ -1033,9 +1063,7 @@ describe('Call', function() {
                     FAKE_ROOM_ID,
                     EventType.CallCandidates,
                     expect.objectContaining({
-                        candidates: [
-                            fakeCandidateString,
-                        ],
+                        candidates: [fakeCandidateString],
                     }),
                 );
             });
@@ -1059,9 +1087,7 @@ describe('Call', function() {
                         FAKE_ROOM_ID,
                         EventType.CallCandidates,
                         expect.objectContaining({
-                            candidates: [
-                                fakeCandidateString,
-                            ],
+                            candidates: [fakeCandidateString],
                         }),
                     );
                     if (!call.callHasEnded) {
@@ -1104,21 +1130,23 @@ describe('Call', function() {
             MockRTCPeerConnection.triggerAllNegotiations();
             await sendNegotiatePromise;
 
-            await call.onAnswerReceived(makeMockEvent("@test:foo", {
-                "version": 1,
-                "call_id": call.callId,
-                "party_id": 'party_id',
-                "answer": {
-                    sdp: DUMMY_SDP,
-                },
-                "org.matrix.msc3077.sdp_stream_metadata": {
-                    "foo": {
-                        "purpose": "m.usermedia",
-                        "audio_muted": false,
-                        "video_muted": false,
+            await call.onAnswerReceived(
+                makeMockEvent("@test:foo", {
+                    "version": 1,
+                    "call_id": call.callId,
+                    "party_id": "party_id",
+                    "answer": {
+                        sdp: DUMMY_SDP,
                     },
-                },
-            }));
+                    "org.matrix.msc3077.sdp_stream_metadata": {
+                        foo: {
+                            purpose: "m.usermedia",
+                            audio_muted: false,
+                            video_muted: false,
+                        },
+                    },
+                }),
+            );
         });
 
         afterEach(() => {
@@ -1129,9 +1157,9 @@ describe('Call', function() {
         it("enables and disables screensharing", async () => {
             await call.setScreensharingEnabled(true);
 
-            expect(
-                call.getLocalFeeds().filter(f => f.purpose == SDPStreamMetadataPurpose.Screenshare),
-            ).toHaveLength(1);
+            expect(call.getLocalFeeds().filter((f) => f.purpose == SDPStreamMetadataPurpose.Screenshare)).toHaveLength(
+                1,
+            );
 
             mockSendEvent.mockReset();
             const sendNegotiatePromise = new Promise<void>(waitNegotiateFunc);
@@ -1155,9 +1183,9 @@ describe('Call', function() {
 
             await call.setScreensharingEnabled(false);
 
-            expect(
-                call.getLocalFeeds().filter(f => f.purpose == SDPStreamMetadataPurpose.Screenshare),
-            ).toHaveLength(0);
+            expect(call.getLocalFeeds().filter((f) => f.purpose == SDPStreamMetadataPurpose.Screenshare)).toHaveLength(
+                0,
+            );
         });
 
         it("removes RTX codec from screen sharing transcievers", async () => {
@@ -1221,47 +1249,49 @@ describe('Call', function() {
     it("falls back to replaceTrack for opponents that don't support stream metadata", async () => {
         await startVideoCall(client, call);
 
-        await call.onAnswerReceived(makeMockEvent("@test:foo", {
-            "version": 1,
-            "call_id": call.callId,
-            "party_id": 'party_id',
-            "answer": {
-                sdp: DUMMY_SDP,
-            },
-        }));
+        await call.onAnswerReceived(
+            makeMockEvent("@test:foo", {
+                version: 1,
+                call_id: call.callId,
+                party_id: "party_id",
+                answer: {
+                    sdp: DUMMY_SDP,
+                },
+            }),
+        );
 
         MockRTCPeerConnection.triggerAllNegotiations();
 
-        const mockVideoSender = call.peerConn!.getSenders().find(s => s.track!.kind === "video");
-        const mockReplaceTrack = mockVideoSender!.replaceTrack = jest.fn();
+        const mockVideoSender = call.peerConn!.getSenders().find((s) => s.track!.kind === "video");
+        const mockReplaceTrack = (mockVideoSender!.replaceTrack = jest.fn());
 
         await call.setScreensharingEnabled(true);
 
         // our local feed should still reflect the purpose of the feed (ie. screenshare)
-        expect(
-            call.getLocalFeeds().filter(f => f.purpose == SDPStreamMetadataPurpose.Screenshare).length,
-        ).toEqual(1);
+        expect(call.getLocalFeeds().filter((f) => f.purpose == SDPStreamMetadataPurpose.Screenshare).length).toEqual(1);
 
         // but we should not have re-negotiated
         expect(MockRTCPeerConnection.hasAnyPendingNegotiations()).toEqual(false);
 
-        expect(mockReplaceTrack).toHaveBeenCalledWith(expect.objectContaining({
-            id: "screenshare_video_track",
-        }));
+        expect(mockReplaceTrack).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: "screenshare_video_track",
+            }),
+        );
         mockReplaceTrack.mockClear();
 
         await call.setScreensharingEnabled(false);
 
-        expect(
-            call.getLocalFeeds().filter(f => f.purpose == SDPStreamMetadataPurpose.Screenshare),
-        ).toHaveLength(0);
+        expect(call.getLocalFeeds().filter((f) => f.purpose == SDPStreamMetadataPurpose.Screenshare)).toHaveLength(0);
         expect(call.getLocalFeeds()).toHaveLength(1);
 
         expect(MockRTCPeerConnection.hasAnyPendingNegotiations()).toEqual(false);
 
-        expect(mockReplaceTrack).toHaveBeenCalledWith(expect.objectContaining({
-            id: "usermedia_video_track",
-        }));
+        expect(mockReplaceTrack).toHaveBeenCalledWith(
+            expect.objectContaining({
+                id: "usermedia_video_track",
+            }),
+        );
     });
 
     describe("call transfers", () => {
@@ -1301,7 +1331,7 @@ describe('Call', function() {
             const newCallHangupListener = jest.fn();
 
             call.on(CallEvent.Hangup, callHangupListener);
-            newCall.on(CallEvent.Error, () => { });
+            newCall.on(CallEvent.Error, () => {});
             newCall.on(CallEvent.Hangup, newCallHangupListener);
 
             await startVoiceCall(client, call, ALICE_USER_ID);
@@ -1309,20 +1339,28 @@ describe('Call', function() {
 
             await call.transferToCall(newCall);
 
-            expect(mockSendEvent).toHaveBeenCalledWith(FAKE_ROOM_ID, EventType.CallReplaces, expect.objectContaining({
-                target_user: {
-                    id: ALICE_USER_ID,
-                    display_name: ALICE_DISPLAY_NAME,
-                    avatar_url: ALICE_AVATAR_URL,
-                },
-            }));
-            expect(mockSendEvent).toHaveBeenCalledWith(FAKE_ROOM_ID, EventType.CallReplaces, expect.objectContaining({
-                target_user: {
-                    id: BOB_USER_ID,
-                    display_name: BOB_DISPLAY_NAME,
-                    avatar_url: BOB_AVATAR_URL,
-                },
-            }));
+            expect(mockSendEvent).toHaveBeenCalledWith(
+                FAKE_ROOM_ID,
+                EventType.CallReplaces,
+                expect.objectContaining({
+                    target_user: {
+                        id: ALICE_USER_ID,
+                        display_name: ALICE_DISPLAY_NAME,
+                        avatar_url: ALICE_AVATAR_URL,
+                    },
+                }),
+            );
+            expect(mockSendEvent).toHaveBeenCalledWith(
+                FAKE_ROOM_ID,
+                EventType.CallReplaces,
+                expect.objectContaining({
+                    target_user: {
+                        id: BOB_USER_ID,
+                        display_name: BOB_DISPLAY_NAME,
+                        avatar_url: BOB_AVATAR_URL,
+                    },
+                }),
+            );
 
             expect(callHangupListener).toHaveBeenCalledWith(call);
             expect(newCallHangupListener).toHaveBeenCalledWith(newCall);
@@ -1335,13 +1373,17 @@ describe('Call', function() {
             await startVoiceCall(client, call, ALICE_USER_ID);
             await call.transfer(BOB_USER_ID);
 
-            expect(mockSendEvent).toHaveBeenCalledWith(FAKE_ROOM_ID, EventType.CallReplaces, expect.objectContaining({
-                target_user: {
-                    id: BOB_USER_ID,
-                    display_name: BOB_DISPLAY_NAME,
-                    avatar_url: BOB_AVATAR_URL,
-                },
-            }));
+            expect(mockSendEvent).toHaveBeenCalledWith(
+                FAKE_ROOM_ID,
+                EventType.CallReplaces,
+                expect.objectContaining({
+                    target_user: {
+                        id: BOB_USER_ID,
+                        display_name: BOB_DISPLAY_NAME,
+                        avatar_url: BOB_AVATAR_URL,
+                    },
+                }),
+            );
             // @ts-ignore Mock
             expect(call.terminate).toHaveBeenCalledWith(CallParty.Local, CallErrorCode.Transfered, true);
         });
@@ -1354,9 +1396,10 @@ describe('Call', function() {
 
             await call.placeVoiceCall();
 
-            (call.peerConn as unknown as MockRTCPeerConnection).onTrackListener!(
-                { streams: [], track: new MockMediaStreamTrack("track_ev", "audio") } as unknown as RTCTrackEvent,
-            );
+            (call.peerConn as unknown as MockRTCPeerConnection).onTrackListener!({
+                streams: [],
+                track: new MockMediaStreamTrack("track_ev", "audio"),
+            } as unknown as RTCTrackEvent);
 
             // @ts-ignore Mock pushRemoteFeed() is private
             expect(call.pushRemoteFeed).not.toHaveBeenCalled();
@@ -1367,19 +1410,22 @@ describe('Call', function() {
             jest.spyOn(call, "pushRemoteFeed");
 
             await call.placeVoiceCall();
-            await call.onAnswerReceived(makeMockEvent("@test:foo", {
-                version: 1,
-                call_id: call.callId,
-                party_id: 'the_correct_party_id',
-                answer: {
-                    sdp: DUMMY_SDP,
-                },
-            }));
+            await call.onAnswerReceived(
+                makeMockEvent("@test:foo", {
+                    version: 1,
+                    call_id: call.callId,
+                    party_id: "the_correct_party_id",
+                    answer: {
+                        sdp: DUMMY_SDP,
+                    },
+                }),
+            );
 
             const stream = new MockMediaStream("stream_ev", [new MockMediaStreamTrack("track_ev", "audio")]);
-            (call.peerConn as unknown as MockRTCPeerConnection).onTrackListener!(
-                { streams: [stream], track: stream.getAudioTracks()[0] } as unknown as RTCTrackEvent,
-            );
+            (call.peerConn as unknown as MockRTCPeerConnection).onTrackListener!({
+                streams: [stream],
+                track: stream.getAudioTracks()[0],
+            } as unknown as RTCTrackEvent);
 
             // @ts-ignore Mock pushRemoteFeed() is private
             expect(call.pushRemoteFeed).toHaveBeenCalledWith(stream);
@@ -1419,18 +1465,19 @@ describe('Call', function() {
         });
     });
 
-    it.each(
-        Object.values(CallState),
-    )("ends call on onRejectReceived() if in correct state (state=%s)", async (state: CallState) => {
-        expect(call.callHasEnded()).toBe(false);
+    it.each(Object.values(CallState))(
+        "ends call on onRejectReceived() if in correct state (state=%s)",
+        async (state: CallState) => {
+            expect(call.callHasEnded()).toBe(false);
 
-        (call as any).state = state;
-        call.onRejectReceived({} as MCallHangupReject);
+            (call as any).state = state;
+            call.onRejectReceived({} as MCallHangupReject);
 
-        expect(call.callHasEnded()).toBe(
-            [CallState.InviteSent, CallState.Ringing, CallState.Ended].includes(state),
-        );
-    });
+            expect(call.callHasEnded()).toBe(
+                [CallState.InviteSent, CallState.Ringing, CallState.Ended].includes(state),
+            );
+        },
+    );
 
     it("terminates call when answered elsewhere", async () => {
         await call.placeVoiceCall();
@@ -1487,7 +1534,7 @@ describe('Call', function() {
 
             await fakeIncomingCall(client, call, "1");
 
-            mockPeerConn = (call.peerConn as unknown as MockRTCPeerConnection);
+            mockPeerConn = call.peerConn as unknown as MockRTCPeerConnection;
             mockPeerConn.iceConnectionState = "disconnected";
             mockPeerConn.iceConnectionStateChangeListener!();
         });
diff --git a/spec/unit/webrtc/callEventHandler.spec.ts b/spec/unit/webrtc/callEventHandler.spec.ts
index b7687cdc2fc..82826363b83 100644
--- a/spec/unit/webrtc/callEventHandler.spec.ts
+++ b/spec/unit/webrtc/callEventHandler.spec.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { TestClient } from '../../TestClient';
+import { TestClient } from "../../TestClient";
 import {
     ClientEvent,
     EventTimeline,
@@ -166,14 +166,20 @@ describe("CallEventHandler", () => {
         const room = new Room("!room:id", client, "@user:id");
         const timelineData: IRoomTimelineData = { timeline: new EventTimeline(new EventTimelineSet(room, {})) };
 
-        client.emit(RoomEvent.Timeline, new MatrixEvent({
-            type: EventType.RoomMessage,
-            room_id: "!room:id",
-            content: {
-                text: "hello",
-
-            },
-        }), room, false, false, timelineData);
+        client.emit(
+            RoomEvent.Timeline,
+            new MatrixEvent({
+                type: EventType.RoomMessage,
+                room_id: "!room:id",
+                content: {
+                    text: "hello",
+                },
+            }),
+            room,
+            false,
+            false,
+            timelineData,
+        );
         await sync();
 
         // @ts-ignore Mock handleCallEvent is private
@@ -202,13 +208,20 @@ describe("CallEventHandler", () => {
         });
 
         it("should create a call when receiving an invite", async () => {
-            client.emit(RoomEvent.Timeline, new MatrixEvent({
-                type: EventType.CallInvite,
-                room_id: "!room:id",
-                content: {
-                    call_id: "123",
-                },
-            }), room, false, false, timelineData);
+            client.emit(
+                RoomEvent.Timeline,
+                new MatrixEvent({
+                    type: EventType.CallInvite,
+                    room_id: "!room:id",
+                    content: {
+                        call_id: "123",
+                    },
+                }),
+                room,
+                false,
+                false,
+                timelineData,
+            );
             await sync();
 
             expect(incomingCallListener).toHaveBeenCalled();
@@ -226,23 +239,30 @@ describe("CallEventHandler", () => {
             const GROUP_CALL_ID = "group_call_id";
             const DEVICE_ID = "device_id";
 
-            incomingCallListener.mockImplementation((c) => call = c);
+            incomingCallListener.mockImplementation((c) => (call = c));
             jest.spyOn(client.groupCallEventHandler!, "getGroupCallById").mockReturnValue(groupCall);
             // @ts-ignore Mock onIncomingCall is private
             jest.spyOn(groupCall, "onIncomingCall");
 
             await groupCall.enter();
-            client.emit(RoomEvent.Timeline, new MatrixEvent({
-                type: EventType.CallInvite,
-                room_id: "!room:id",
-                content: {
-                    call_id: "123",
-                    conf_id: GROUP_CALL_ID,
-                    device_id: DEVICE_ID,
-                    sender_session_id: SESSION_ID,
-                    dest_session_id: client.getSessionId(),
-                },
-            }), room, false, false, timelineData);
+            client.emit(
+                RoomEvent.Timeline,
+                new MatrixEvent({
+                    type: EventType.CallInvite,
+                    room_id: "!room:id",
+                    content: {
+                        call_id: "123",
+                        conf_id: GROUP_CALL_ID,
+                        device_id: DEVICE_ID,
+                        sender_session_id: SESSION_ID,
+                        dest_session_id: client.getSessionId(),
+                    },
+                }),
+                room,
+                false,
+                false,
+                timelineData,
+            );
             await sync();
 
             expect(incomingCallListener).toHaveBeenCalled();
@@ -257,14 +277,21 @@ describe("CallEventHandler", () => {
         });
 
         it("ignores a call with a different invitee than us", async () => {
-            client.emit(RoomEvent.Timeline, new MatrixEvent({
-                type: EventType.CallInvite,
-                room_id: "!room:id",
-                content: {
-                    call_id: "123",
-                    invitee: "@bob:bar",
-                },
-            }), room, false, false, timelineData);
+            client.emit(
+                RoomEvent.Timeline,
+                new MatrixEvent({
+                    type: EventType.CallInvite,
+                    room_id: "!room:id",
+                    content: {
+                        call_id: "123",
+                        invitee: "@bob:bar",
+                    },
+                }),
+                room,
+                false,
+                false,
+                timelineData,
+            );
             await sync();
 
             expect(incomingCallListener).not.toHaveBeenCalled();
diff --git a/spec/unit/webrtc/groupCall.spec.ts b/spec/unit/webrtc/groupCall.spec.ts
index ad77e15bdc7..fc09c353788 100644
--- a/spec/unit/webrtc/groupCall.spec.ts
+++ b/spec/unit/webrtc/groupCall.spec.ts
@@ -14,15 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {
-    EventType,
-    GroupCallIntent,
-    GroupCallType,
-    MatrixCall,
-    MatrixEvent,
-    Room,
-    RoomMember,
-} from '../../../src';
+import { EventType, GroupCallIntent, GroupCallType, MatrixCall, MatrixEvent, Room, RoomMember } from "../../../src";
 import { RoomStateEvent } from "../../../src/models/room-state";
 import { GroupCall, GroupCallEvent, GroupCallState } from "../../../src/webrtc/groupCall";
 import { IMyDevice, MatrixClient } from "../../../src/client";
@@ -43,13 +35,13 @@ import {
     FAKE_DEVICE_ID_1,
     FAKE_SESSION_ID_1,
     FAKE_USER_ID_3,
-} from '../../test-utils/webrtc';
+} from "../../test-utils/webrtc";
 import { SDPStreamMetadataKey, SDPStreamMetadataPurpose } from "../../../src/webrtc/callEventTypes";
 import { sleep } from "../../../src/utils";
-import { CallEventHandlerEvent } from '../../../src/webrtc/callEventHandler';
-import { CallFeed } from '../../../src/webrtc/callFeed';
-import { CallEvent, CallState } from '../../../src/webrtc/call';
-import { flushPromises } from '../../test-utils/flushPromises';
+import { CallEventHandlerEvent } from "../../../src/webrtc/callEventHandler";
+import { CallFeed } from "../../../src/webrtc/callFeed";
+import { CallEvent, CallState } from "../../../src/webrtc/call";
+import { flushPromises } from "../../test-utils/flushPromises";
 
 const FAKE_STATE_EVENTS = [
     {
@@ -62,31 +54,40 @@ const FAKE_STATE_EVENTS = [
     },
     {
         getContent: () => ({
-            "m.calls": [{
-                "m.call_id": FAKE_CONF_ID,
-                "m.devices": [{
-                    device_id: FAKE_DEVICE_ID_2,
-                    session_id: FAKE_SESSION_ID_2,
-                    expires_ts: Date.now() + ONE_HOUR,
-                    feeds: [],
-                }],
-            }],
+            "m.calls": [
+                {
+                    "m.call_id": FAKE_CONF_ID,
+                    "m.devices": [
+                        {
+                            device_id: FAKE_DEVICE_ID_2,
+                            session_id: FAKE_SESSION_ID_2,
+                            expires_ts: Date.now() + ONE_HOUR,
+                            feeds: [],
+                        },
+                    ],
+                },
+            ],
         }),
         getStateKey: () => FAKE_USER_ID_2,
         getRoomId: () => FAKE_ROOM_ID,
         getTs: () => 0,
-    }, {
+    },
+    {
         getContent: () => ({
             "m.expires_ts": Date.now() + ONE_HOUR,
-            "m.calls": [{
-                "m.call_id": FAKE_CONF_ID,
-                "m.devices": [{
-                    device_id: "user3_device",
-                    session_id: "user3_session",
-                    expires_ts: Date.now() + ONE_HOUR,
-                    feeds: [],
-                }],
-            }],
+            "m.calls": [
+                {
+                    "m.call_id": FAKE_CONF_ID,
+                    "m.devices": [
+                        {
+                            device_id: "user3_device",
+                            session_id: "user3_session",
+                            expires_ts: Date.now() + ONE_HOUR,
+                            feeds: [],
+                        },
+                    ],
+                },
+            ],
         }),
         getStateKey: () => "user3",
         getRoomId: () => FAKE_ROOM_ID,
@@ -97,8 +98,8 @@ const FAKE_STATE_EVENTS = [
 const mockGetStateEvents = (type: EventType, userId?: string): MatrixEvent[] | MatrixEvent | null => {
     if (type === EventType.GroupCallMemberPrefix) {
         return userId === undefined
-            ? FAKE_STATE_EVENTS as MatrixEvent[]
-            : FAKE_STATE_EVENTS.find(e => e.getStateKey() === userId) as MatrixEvent;
+            ? (FAKE_STATE_EVENTS as MatrixEvent[])
+            : (FAKE_STATE_EVENTS.find((e) => e.getStateKey() === userId) as MatrixEvent);
     } else {
         const fakeEvent = { getContent: () => ({}), getTs: () => 0 } as MatrixEvent;
         return userId === undefined ? [fakeEvent] : fakeEvent;
@@ -108,14 +109,7 @@ const mockGetStateEvents = (type: EventType, userId?: string): MatrixEvent[] | M
 const ONE_HOUR = 1000 * 60 * 60;
 
 const createAndEnterGroupCall = async (cli: MatrixClient, room: Room): Promise<GroupCall> => {
-    const groupCall = new GroupCall(
-        cli,
-        room,
-        GroupCallType.Video,
-        false,
-        GroupCallIntent.Prompt,
-        FAKE_CONF_ID,
-    );
+    const groupCall = new GroupCall(cli, room, GroupCallType.Video, false, GroupCallIntent.Prompt, FAKE_CONF_ID);
 
     await groupCall.create();
     await groupCall.enter();
@@ -123,21 +117,19 @@ const createAndEnterGroupCall = async (cli: MatrixClient, room: Room): Promise<G
     return groupCall;
 };
 
-describe('Group Call', function() {
-    beforeEach(function() {
+describe("Group Call", function () {
+    beforeEach(function () {
         installWebRTCMocks();
     });
 
-    describe('Basic functionality', function() {
+    describe("Basic functionality", function () {
         let mockSendState: jest.Mock;
         let mockClient: MatrixClient;
         let room: Room;
         let groupCall: GroupCall;
 
-        beforeEach(function() {
-            const typedMockClient = new MockCallMatrixClient(
-                FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1,
-            );
+        beforeEach(function () {
+            const typedMockClient = new MockCallMatrixClient(FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1);
             mockSendState = typedMockClient.sendStateEvent;
 
             mockClient = typedMockClient as unknown as MatrixClient;
@@ -171,7 +163,9 @@ describe('Group Call', function() {
             await groupCall.create();
 
             expect(mockSendState).toHaveBeenCalledWith(
-                FAKE_ROOM_ID, EventType.GroupCallPrefix, expect.objectContaining({
+                FAKE_ROOM_ID,
+                EventType.GroupCallPrefix,
+                expect.objectContaining({
                     "m.type": GroupCallType.Video,
                     "m.intent": GroupCallIntent.Prompt,
                 }),
@@ -224,9 +218,9 @@ describe('Group Call', function() {
         });
 
         it("includes local device in participants when entered via another session", async () => {
-            const hasLocalParticipant = () => groupCall.participants.get(
-                room.getMember(mockClient.getUserId()!)!,
-            )?.has(mockClient.getDeviceId()!) ?? false;
+            const hasLocalParticipant = () =>
+                groupCall.participants.get(room.getMember(mockClient.getUserId()!)!)?.has(mockClient.getDeviceId()!) ??
+                false;
 
             expect(groupCall.enteredViaAnotherSession).toBe(false);
             expect(hasLocalParticipant()).toBe(false);
@@ -486,7 +480,7 @@ describe('Group Call', function() {
                 );
 
                 let metadataUpdateResolve: () => void;
-                const metadataUpdatePromise = new Promise<void>(resolve => {
+                const metadataUpdatePromise = new Promise<void>((resolve) => {
                     metadataUpdateResolve = resolve;
                 });
                 mockCall.sendMetadataUpdate = jest.fn().mockReturnValue(metadataUpdatePromise);
@@ -516,7 +510,7 @@ describe('Group Call', function() {
                 mockCall.localUsermediaFeed.setAudioVideoMuted.mockReset();
 
                 let metadataUpdateResolve: () => void;
-                const metadataUpdatePromise = new Promise<void>(resolve => {
+                const metadataUpdatePromise = new Promise<void>((resolve) => {
                     metadataUpdateResolve = resolve;
                 });
                 mockCall.sendMetadataUpdate = jest.fn().mockReturnValue(metadataUpdatePromise);
@@ -534,27 +528,21 @@ describe('Group Call', function() {
         });
     });
 
-    describe('Placing calls', function() {
+    describe("Placing calls", function () {
         let groupCall1: GroupCall;
         let groupCall2: GroupCall;
         let client1: MockCallMatrixClient;
         let client2: MockCallMatrixClient;
 
-        beforeEach(function() {
+        beforeEach(function () {
             MockRTCPeerConnection.resetInstances();
 
-            client1 = new MockCallMatrixClient(
-                FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1,
-            );
+            client1 = new MockCallMatrixClient(FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1);
 
-            client2 = new MockCallMatrixClient(
-                FAKE_USER_ID_2, FAKE_DEVICE_ID_2, FAKE_SESSION_ID_2,
-            );
+            client2 = new MockCallMatrixClient(FAKE_USER_ID_2, FAKE_DEVICE_ID_2, FAKE_SESSION_ID_2);
 
             // Inject the state events directly into each client when sent
-            const fakeSendStateEvents = (
-                roomId: string, eventType: EventType, content: any, statekey: string,
-            ) => {
+            const fakeSendStateEvents = (roomId: string, eventType: EventType, content: any, statekey: string) => {
                 if (eventType === EventType.GroupCallMemberPrefix) {
                     const fakeEvent = {
                         getContent: () => content,
@@ -575,7 +563,7 @@ describe('Group Call', function() {
                     client1Room.currentState.emit(RoomStateEvent.Update, client1Room.currentState);
                     client2Room.currentState.emit(RoomStateEvent.Update, client2Room.currentState);
                 }
-                return Promise.resolve({ "event_id": "foo" });
+                return Promise.resolve({ event_id: "foo" });
             };
 
             client1.sendStateEvent.mockImplementation(fakeSendStateEvents);
@@ -594,15 +582,25 @@ describe('Group Call', function() {
             } as unknown as RoomMember;
 
             groupCall1 = new GroupCall(
-                client1.typed(), client1Room, GroupCallType.Video, false, GroupCallIntent.Prompt, FAKE_CONF_ID,
+                client1.typed(),
+                client1Room,
+                GroupCallType.Video,
+                false,
+                GroupCallIntent.Prompt,
+                FAKE_CONF_ID,
             );
 
             groupCall2 = new GroupCall(
-                client2.typed(), client2Room, GroupCallType.Video, false, GroupCallIntent.Prompt, FAKE_CONF_ID,
+                client2.typed(),
+                client2Room,
+                GroupCallType.Video,
+                false,
+                GroupCallIntent.Prompt,
+                FAKE_CONF_ID,
             );
         });
 
-        afterEach(function() {
+        afterEach(function () {
             groupCall1.leave();
             groupCall2.leave();
             jest.useRealTimers();
@@ -610,11 +608,11 @@ describe('Group Call', function() {
             MockRTCPeerConnection.resetInstances();
         });
 
-        it("Places a call to a peer", async function() {
+        it("Places a call to a peer", async function () {
             await groupCall1.create();
 
             try {
-                const toDeviceProm = new Promise<void>(resolve => {
+                const toDeviceProm = new Promise<void>((resolve) => {
                     client1.sendToDevice.mockImplementation(() => {
                         resolve();
                         return Promise.resolve({});
@@ -644,12 +642,12 @@ describe('Group Call', function() {
             }
         });
 
-        it("Retries calls", async function() {
+        it("Retries calls", async function () {
             jest.useFakeTimers();
             await groupCall1.create();
 
             try {
-                const toDeviceProm = new Promise<void>(resolve => {
+                const toDeviceProm = new Promise<void>((resolve) => {
                     client1.sendToDevice.mockImplementation(() => {
                         resolve();
                         return Promise.resolve({});
@@ -665,14 +663,14 @@ describe('Group Call', function() {
                 expect(client1.sendToDevice).toHaveBeenCalled();
 
                 // @ts-ignore
-                const oldCall = groupCall1.calls.get(
-                    groupCall1.room.getMember(client2.userId)!,
-                )!.get(client2.deviceId)!;
+                const oldCall = groupCall1.calls
+                    .get(groupCall1.room.getMember(client2.userId)!)!
+                    .get(client2.deviceId)!;
                 oldCall.emit(CallEvent.Hangup, oldCall!);
 
                 client1.sendToDevice.mockClear();
 
-                const toDeviceProm2 = new Promise<void>(resolve => {
+                const toDeviceProm2 = new Promise<void>((resolve) => {
                     client1.sendToDevice.mockImplementation(() => {
                         resolve();
                         return Promise.resolve({});
@@ -687,11 +685,11 @@ describe('Group Call', function() {
                 let newCall: MatrixCall | undefined;
                 while (
                     // @ts-ignore
-                    (newCall = groupCall1.calls.get(
-                        groupCall1.room.getMember(client2.userId)!,
-                    )?.get(client2.deviceId)) === undefined
-                    || newCall.peerConn === undefined
-                    || newCall.callId == oldCall.callId
+                    (newCall = groupCall1.calls
+                        .get(groupCall1.room.getMember(client2.userId)!)
+                        ?.get(client2.deviceId)) === undefined ||
+                    newCall.peerConn === undefined ||
+                    newCall.callId == oldCall.callId
                 ) {
                     await flushPromises();
                 }
@@ -711,11 +709,11 @@ describe('Group Call', function() {
             }
         });
 
-        it("Updates call mute status correctly on call state change", async function() {
+        it("Updates call mute status correctly on call state change", async function () {
             await groupCall1.create();
 
             try {
-                const toDeviceProm = new Promise<void>(resolve => {
+                const toDeviceProm = new Promise<void>((resolve) => {
                     client1.sendToDevice.mockImplementation(() => {
                         resolve();
                         return Promise.resolve({});
@@ -732,9 +730,7 @@ describe('Group Call', function() {
                 groupCall1.setLocalVideoMuted(false);
 
                 // @ts-ignore
-                const call = groupCall1.calls.get(
-                    groupCall1.room.getMember(client2.userId)!,
-                )!.get(client2.deviceId)!;
+                const call = groupCall1.calls.get(groupCall1.room.getMember(client2.userId)!)!.get(client2.deviceId)!;
                 call.isMicrophoneMuted = jest.fn().mockReturnValue(true);
                 call.setMicrophoneMuted = jest.fn();
                 call.isLocalVideoMuted = jest.fn().mockReturnValue(true);
@@ -755,9 +751,7 @@ describe('Group Call', function() {
         let room: Room;
 
         beforeEach(() => {
-            const typedMockClient = new MockCallMatrixClient(
-                FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1,
-            );
+            const typedMockClient = new MockCallMatrixClient(FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1);
             mockClient = typedMockClient as unknown as MatrixClient;
 
             room = new Room(FAKE_ROOM_ID, mockClient, FAKE_USER_ID_1);
@@ -780,19 +774,19 @@ describe('Group Call', function() {
                 const setAVMutedArray: ((audioMuted: boolean | null, videoMuted: boolean | null) => void)[] = [];
                 const tracksArray: MediaStreamTrack[] = [];
                 const sendMetadataUpdateArray: (() => Promise<void>)[] = [];
-                groupCall.forEachCall(call => {
-                    setAVMutedArray.push(call.localUsermediaFeed!.setAudioVideoMuted = jest.fn());
+                groupCall.forEachCall((call) => {
+                    setAVMutedArray.push((call.localUsermediaFeed!.setAudioVideoMuted = jest.fn()));
                     tracksArray.push(...call.localUsermediaStream!.getAudioTracks());
-                    sendMetadataUpdateArray.push(call.sendMetadataUpdate = jest.fn());
+                    sendMetadataUpdateArray.push((call.sendMetadataUpdate = jest.fn()));
                 });
 
                 await groupCall.setMicrophoneMuted(true);
 
-                groupCall.localCallFeed!.stream.getAudioTracks().forEach(track => expect(track.enabled).toBe(false));
+                groupCall.localCallFeed!.stream.getAudioTracks().forEach((track) => expect(track.enabled).toBe(false));
                 expect(groupCall.localCallFeed!.setAudioVideoMuted).toHaveBeenCalledWith(true, null);
-                setAVMutedArray.forEach(f => expect(f).toHaveBeenCalledWith(true, null));
-                tracksArray.forEach(track => expect(track.enabled).toBe(false));
-                sendMetadataUpdateArray.forEach(f => expect(f).toHaveBeenCalled());
+                setAVMutedArray.forEach((f) => expect(f).toHaveBeenCalledWith(true, null));
+                tracksArray.forEach((track) => expect(track.enabled).toBe(false));
+                sendMetadataUpdateArray.forEach((f) => expect(f).toHaveBeenCalled());
 
                 groupCall.terminate();
             });
@@ -804,37 +798,38 @@ describe('Group Call', function() {
                 const setAVMutedArray: ((audioMuted: boolean | null, videoMuted: boolean | null) => void)[] = [];
                 const tracksArray: MediaStreamTrack[] = [];
                 const sendMetadataUpdateArray: (() => Promise<void>)[] = [];
-                groupCall.forEachCall(call => {
+                groupCall.forEachCall((call) => {
                     call.localUsermediaFeed!.isVideoMuted = jest.fn().mockReturnValue(true);
-                    setAVMutedArray.push(call.localUsermediaFeed!.setAudioVideoMuted = jest.fn());
+                    setAVMutedArray.push((call.localUsermediaFeed!.setAudioVideoMuted = jest.fn()));
                     tracksArray.push(...call.localUsermediaStream!.getVideoTracks());
-                    sendMetadataUpdateArray.push(call.sendMetadataUpdate = jest.fn());
+                    sendMetadataUpdateArray.push((call.sendMetadataUpdate = jest.fn()));
                 });
 
                 await groupCall.setLocalVideoMuted(true);
 
-                groupCall.localCallFeed!.stream.getVideoTracks().forEach(track => expect(track.enabled).toBe(false));
+                groupCall.localCallFeed!.stream.getVideoTracks().forEach((track) => expect(track.enabled).toBe(false));
                 expect(groupCall.localCallFeed!.setAudioVideoMuted).toHaveBeenCalledWith(null, true);
-                setAVMutedArray.forEach(f => expect(f).toHaveBeenCalledWith(null, true));
-                tracksArray.forEach(track => expect(track.enabled).toBe(false));
-                sendMetadataUpdateArray.forEach(f => expect(f).toHaveBeenCalled());
+                setAVMutedArray.forEach((f) => expect(f).toHaveBeenCalledWith(null, true));
+                tracksArray.forEach((track) => expect(track.enabled).toBe(false));
+                sendMetadataUpdateArray.forEach((f) => expect(f).toHaveBeenCalled());
 
                 groupCall.terminate();
             });
         });
 
         describe("remote muting", () => {
-            const getMetadataEvent = (audio: boolean, video: boolean): MatrixEvent => ({
-                getContent: () => ({
-                    [SDPStreamMetadataKey]: {
-                        stream: {
-                            purpose: SDPStreamMetadataPurpose.Usermedia,
-                            audio_muted: audio,
-                            video_muted: video,
+            const getMetadataEvent = (audio: boolean, video: boolean): MatrixEvent =>
+                ({
+                    getContent: () => ({
+                        [SDPStreamMetadataKey]: {
+                            stream: {
+                                purpose: SDPStreamMetadataPurpose.Usermedia,
+                                audio_muted: audio,
+                                video_muted: video,
+                            },
                         },
-                    },
-                }),
-            } as MatrixEvent);
+                    }),
+                } as MatrixEvent);
 
             it("should mute remote feed's audio after receiving metadata with video audio", async () => {
                 const metadataEvent = getMetadataEvent(true, false);
@@ -844,15 +839,15 @@ describe('Group Call', function() {
                 await sleep(10);
 
                 // @ts-ignore
-                const call = groupCall.calls
-                    .get(groupCall.room.getMember(FAKE_USER_ID_2)!)!
-                    .get(FAKE_DEVICE_ID_2)!;
-                call.getOpponentMember = () => ({ userId: call.invitee }) as RoomMember;
+                const call = groupCall.calls.get(groupCall.room.getMember(FAKE_USER_ID_2)!)!.get(FAKE_DEVICE_ID_2)!;
+                call.getOpponentMember = () => ({ userId: call.invitee } as RoomMember);
                 // @ts-ignore Mock
-                call.pushRemoteFeed(new MockMediaStream("stream", [
-                    new MockMediaStreamTrack("audio_track", "audio"),
-                    new MockMediaStreamTrack("video_track", "video"),
-                ]));
+                call.pushRemoteFeed(
+                    new MockMediaStream("stream", [
+                        new MockMediaStreamTrack("audio_track", "audio"),
+                        new MockMediaStreamTrack("video_track", "video"),
+                    ]),
+                );
                 call.onSDPStreamMetadataChangedReceived(metadataEvent);
 
                 const feed = groupCall.getUserMediaFeed(call.invitee!, call.getOpponentDeviceId()!);
@@ -870,15 +865,15 @@ describe('Group Call', function() {
                 await sleep(10);
 
                 // @ts-ignore
-                const call = groupCall.calls
-                    .get(groupCall.room.getMember(FAKE_USER_ID_2)!)!
-                    .get(FAKE_DEVICE_ID_2)!;
-                call.getOpponentMember = () => ({ userId: call.invitee }) as RoomMember;
+                const call = groupCall.calls.get(groupCall.room.getMember(FAKE_USER_ID_2)!)!.get(FAKE_DEVICE_ID_2)!;
+                call.getOpponentMember = () => ({ userId: call.invitee } as RoomMember);
                 // @ts-ignore Mock
-                call.pushRemoteFeed(new MockMediaStream("stream", [
-                    new MockMediaStreamTrack("audio_track", "audio"),
-                    new MockMediaStreamTrack("video_track", "video"),
-                ]));
+                call.pushRemoteFeed(
+                    new MockMediaStream("stream", [
+                        new MockMediaStreamTrack("audio_track", "audio"),
+                        new MockMediaStreamTrack("video_track", "video"),
+                    ]),
+                );
                 call.onSDPStreamMetadataChangedReceived(metadataEvent);
 
                 const feed = groupCall.getUserMediaFeed(call.invitee!, call.getOpponentDeviceId()!);
@@ -898,9 +893,7 @@ describe('Group Call', function() {
         beforeEach(async () => {
             // we are bob here because we're testing incoming calls, and since alice's user id
             // is lexicographically before Bob's, the spec requires that she calls Bob.
-            const typedMockClient = new MockCallMatrixClient(
-                FAKE_USER_ID_2, FAKE_DEVICE_ID_2, FAKE_SESSION_ID_2,
-            );
+            const typedMockClient = new MockCallMatrixClient(FAKE_USER_ID_2, FAKE_DEVICE_ID_2, FAKE_SESSION_ID_2);
             mockClient = typedMockClient as unknown as MatrixClient;
 
             room = new Room(FAKE_ROOM_ID, mockClient, FAKE_USER_ID_2);
@@ -948,10 +941,9 @@ describe('Group Call', function() {
             expect(mockCall.reject).not.toHaveBeenCalled();
             expect(mockCall.answerWithCallFeeds).toHaveBeenCalled();
             // @ts-ignore
-            expect(groupCall.calls).toEqual(new Map([[
-                groupCall.room.getMember(FAKE_USER_ID_1)!,
-                new Map([[FAKE_DEVICE_ID_1, mockCall]]),
-            ]]));
+            expect(groupCall.calls).toEqual(
+                new Map([[groupCall.room.getMember(FAKE_USER_ID_1)!, new Map([[FAKE_DEVICE_ID_1, mockCall]])]]),
+            );
         });
 
         it("replaces calls if it already has one with the same user", async () => {
@@ -966,10 +958,9 @@ describe('Group Call', function() {
             expect(oldMockCall.hangup).toHaveBeenCalled();
             expect(newMockCall.answerWithCallFeeds).toHaveBeenCalled();
             // @ts-ignore
-            expect(groupCall.calls).toEqual(new Map([[
-                groupCall.room.getMember(FAKE_USER_ID_1)!,
-                new Map([[FAKE_DEVICE_ID_1, newMockCall]]),
-            ]]));
+            expect(groupCall.calls).toEqual(
+                new Map([[groupCall.room.getMember(FAKE_USER_ID_1)!, new Map([[FAKE_DEVICE_ID_1, newMockCall]])]]),
+            );
         });
 
         it("starts to process incoming calls when we've entered", async () => {
@@ -977,9 +968,7 @@ describe('Group Call', function() {
             groupCall.leave();
 
             const call = new MockMatrixCall(room.roomId, groupCall.groupCallId);
-            mockClient.callEventHandler!.calls = new Map<string, MatrixCall>([
-                [call.callId, call.typed()],
-            ]);
+            mockClient.callEventHandler!.calls = new Map<string, MatrixCall>([[call.callId, call.typed()]]);
             await groupCall.enter();
 
             expect(call.answerWithCallFeeds).toHaveBeenCalled();
@@ -993,9 +982,7 @@ describe('Group Call', function() {
         let groupCall: GroupCall;
 
         beforeEach(async () => {
-            typedMockClient = new MockCallMatrixClient(
-                FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1,
-            );
+            typedMockClient = new MockCallMatrixClient(FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1);
             mockClient = typedMockClient.typed();
 
             room = new Room(FAKE_ROOM_ID, mockClient, FAKE_USER_ID_1);
@@ -1014,9 +1001,9 @@ describe('Group Call', function() {
 
         it("sending screensharing stream", async () => {
             const onNegotiationNeededArray: (() => Promise<void>)[] = [];
-            groupCall.forEachCall(call => {
+            groupCall.forEachCall((call) => {
                 // @ts-ignore Mock
-                onNegotiationNeededArray.push(call.gotLocalOffer = jest.fn());
+                onNegotiationNeededArray.push((call.gotLocalOffer = jest.fn()));
             });
 
             let enabledResult: boolean;
@@ -1026,10 +1013,10 @@ describe('Group Call', function() {
             MockRTCPeerConnection.triggerAllNegotiations();
 
             expect(groupCall.screenshareFeeds).toHaveLength(1);
-            groupCall.forEachCall(c => {
-                expect(c.getLocalFeeds().find(f => f.purpose === SDPStreamMetadataPurpose.Screenshare)).toBeDefined();
+            groupCall.forEachCall((c) => {
+                expect(c.getLocalFeeds().find((f) => f.purpose === SDPStreamMetadataPurpose.Screenshare)).toBeDefined();
             });
-            onNegotiationNeededArray.forEach(f => expect(f).toHaveBeenCalled());
+            onNegotiationNeededArray.forEach((f) => expect(f).toHaveBeenCalled());
 
             // Enabling it again should do nothing
             typedMockClient.mediaHandler.getScreensharingStream.mockClear();
@@ -1050,14 +1037,12 @@ describe('Group Call', function() {
             await sleep(10);
 
             // @ts-ignore
-            const call = groupCall.calls
-                .get(groupCall.room.getMember(FAKE_USER_ID_2)!)!
-                .get(FAKE_DEVICE_ID_2)!;
-            call.getOpponentMember = () => ({ userId: call.invitee }) as RoomMember;
+            const call = groupCall.calls.get(groupCall.room.getMember(FAKE_USER_ID_2)!)!.get(FAKE_DEVICE_ID_2)!;
+            call.getOpponentMember = () => ({ userId: call.invitee } as RoomMember);
             call.onNegotiateReceived({
                 getContent: () => ({
                     [SDPStreamMetadataKey]: {
-                        "screensharing_stream": {
+                        screensharing_stream: {
                             purpose: SDPStreamMetadataPurpose.Screenshare,
                         },
                     },
@@ -1068,9 +1053,9 @@ describe('Group Call', function() {
                 }),
             } as MatrixEvent);
             // @ts-ignore Mock
-            call.pushRemoteFeed(new MockMediaStream("screensharing_stream", [
-                new MockMediaStreamTrack("video_track", "video"),
-            ]));
+            call.pushRemoteFeed(
+                new MockMediaStream("screensharing_stream", [new MockMediaStreamTrack("video_track", "video")]),
+            );
 
             expect(groupCall.screenshareFeeds).toHaveLength(1);
             expect(groupCall.getScreenshareFeed(call.invitee!, call.getOpponentDeviceId()!)).toBeDefined();
@@ -1108,9 +1093,7 @@ describe('Group Call', function() {
         beforeEach(async () => {
             jest.useFakeTimers();
 
-            const mockClient = new MockCallMatrixClient(
-                FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1,
-            );
+            const mockClient = new MockCallMatrixClient(FAKE_USER_ID_1, FAKE_DEVICE_ID_1, FAKE_SESSION_ID_1);
 
             room = new Room(FAKE_ROOM_ID, mockClient.typed(), FAKE_USER_ID_1);
             room.currentState.members[FAKE_USER_ID_1] = {
@@ -1123,7 +1106,7 @@ describe('Group Call', function() {
                 roomId: FAKE_ROOM_ID,
                 userId: FAKE_USER_ID_2,
                 deviceId: FAKE_DEVICE_ID_1,
-                stream: (new MockMediaStream("foo", [])).typed(),
+                stream: new MockMediaStream("foo", []).typed(),
                 purpose: SDPStreamMetadataPurpose.Usermedia,
                 audioMuted: false,
                 videoMuted: true,
@@ -1135,7 +1118,7 @@ describe('Group Call', function() {
                 roomId: FAKE_ROOM_ID,
                 userId: FAKE_USER_ID_3,
                 deviceId: FAKE_DEVICE_ID_1,
-                stream: (new MockMediaStream("foo", [])).typed(),
+                stream: new MockMediaStream("foo", []).typed(),
                 purpose: SDPStreamMetadataPurpose.Usermedia,
                 audioMuted: false,
                 videoMuted: true,
@@ -1185,28 +1168,17 @@ describe('Group Call', function() {
         it("throws when there already is a call", async () => {
             jest.spyOn(client, "getRoom").mockReturnValue(new Room("room_id", client, "my_user_id"));
 
-            await client.createGroupCall(
-                "room_id",
-                GroupCallType.Video,
-                false,
-                GroupCallIntent.Prompt,
-            );
+            await client.createGroupCall("room_id", GroupCallType.Video, false, GroupCallIntent.Prompt);
 
-            await expect(client.createGroupCall(
-                "room_id",
-                GroupCallType.Video,
-                false,
-                GroupCallIntent.Prompt,
-            )).rejects.toThrow("room_id already has an existing group call");
+            await expect(
+                client.createGroupCall("room_id", GroupCallType.Video, false, GroupCallIntent.Prompt),
+            ).rejects.toThrow("room_id already has an existing group call");
         });
 
         it("throws if the room doesn't exist", async () => {
-            await expect(client.createGroupCall(
-                "room_id",
-                GroupCallType.Video,
-                false,
-                GroupCallIntent.Prompt,
-            )).rejects.toThrow("Cannot find room room_id");
+            await expect(
+                client.createGroupCall("room_id", GroupCallType.Video, false, GroupCallIntent.Prompt),
+            ).rejects.toThrow("Cannot find room room_id");
         });
 
         describe("correctly passes parameters", () => {
@@ -1273,24 +1245,35 @@ describe('Group Call', function() {
         };
 
         const mkContent = (devices: IMyDevice[]) => ({
-            "m.calls": [{
-                "m.call_id": groupCall.groupCallId,
-                "m.devices": devices.map(d => ({
-                    device_id: d.device_id, session_id: "1", feeds: [], expires_ts: 1000 * 60 * 10,
-                })),
-            }],
+            "m.calls": [
+                {
+                    "m.call_id": groupCall.groupCallId,
+                    "m.devices": devices.map((d) => ({
+                        device_id: d.device_id,
+                        session_id: "1",
+                        feeds: [],
+                        expires_ts: 1000 * 60 * 10,
+                    })),
+                },
+            ],
         });
 
-        const expectDevices = (devices: IMyDevice[]) => expect(
-            room.currentState.getStateEvents(EventType.GroupCallMemberPrefix, FAKE_USER_ID_2)?.getContent(),
-        ).toEqual({
-            "m.calls": [{
-                "m.call_id": groupCall.groupCallId,
-                "m.devices": devices.map(d => ({
-                    device_id: d.device_id, session_id: "1", feeds: [], expires_ts: expect.any(Number),
-                })),
-            }],
-        });
+        const expectDevices = (devices: IMyDevice[]) =>
+            expect(
+                room.currentState.getStateEvents(EventType.GroupCallMemberPrefix, FAKE_USER_ID_2)?.getContent(),
+            ).toEqual({
+                "m.calls": [
+                    {
+                        "m.call_id": groupCall.groupCallId,
+                        "m.devices": devices.map((d) => ({
+                            device_id: d.device_id,
+                            session_id: "1",
+                            feeds: [],
+                            expires_ts: expect.any(Number),
+                        })),
+                    },
+                ],
+            });
 
         let mockClient: MatrixClient;
         let room: Room;
@@ -1304,21 +1287,21 @@ describe('Group Call', function() {
         afterAll(() => jest.useRealTimers());
 
         beforeEach(async () => {
-            const typedMockClient = new MockCallMatrixClient(
-                FAKE_USER_ID_2, bobWeb.device_id, FAKE_SESSION_ID_2,
-            );
+            const typedMockClient = new MockCallMatrixClient(FAKE_USER_ID_2, bobWeb.device_id, FAKE_SESSION_ID_2);
             jest.spyOn(typedMockClient, "sendStateEvent").mockImplementation(
                 async (roomId, eventType, content, stateKey) => {
                     const eventId = `$${Math.random()}`;
                     if (roomId === room.roomId) {
-                        room.addLiveEvents([new MatrixEvent({
-                            event_id: eventId,
-                            type: eventType,
-                            room_id: roomId,
-                            sender: FAKE_USER_ID_2,
-                            content,
-                            state_key: stateKey,
-                        })]);
+                        room.addLiveEvents([
+                            new MatrixEvent({
+                                event_id: eventId,
+                                type: eventType,
+                                room_id: roomId,
+                                sender: FAKE_USER_ID_2,
+                                content,
+                                state_key: stateKey,
+                            }),
+                        ]);
                     }
                     return { event_id: eventId };
                 },
@@ -1339,12 +1322,7 @@ describe('Group Call', function() {
             await groupCall.create();
 
             mockClient.getDevices = async () => ({
-                devices: [
-                    bobWeb,
-                    bobDesktop,
-                    bobDesktopOffline,
-                    bobDesktopNeverOnline,
-                ],
+                devices: [bobWeb, bobDesktop, bobDesktopOffline, bobDesktopNeverOnline],
             });
         });
 
diff --git a/spec/unit/webrtc/groupCallEventHandler.spec.ts b/spec/unit/webrtc/groupCallEventHandler.spec.ts
index de70e42085b..6c97988bf46 100644
--- a/spec/unit/webrtc/groupCallEventHandler.spec.ts
+++ b/spec/unit/webrtc/groupCallEventHandler.spec.ts
@@ -38,16 +38,14 @@ const FAKE_SESSION_ID = "session1";
 const FAKE_ROOM_ID = "!roomid:test.dummy";
 const FAKE_GROUP_CALL_ID = "fakegroupcallid";
 
-describe('Group Call Event Handler', function() {
+describe("Group Call Event Handler", function () {
     let groupCallEventHandler: GroupCallEventHandler;
     let mockClient: MockCallMatrixClient;
     let mockRoom: Room;
     let mockMember: RoomMember;
 
     beforeEach(() => {
-        mockClient = new MockCallMatrixClient(
-            FAKE_USER_ID, FAKE_DEVICE_ID, FAKE_SESSION_ID,
-        );
+        mockClient = new MockCallMatrixClient(FAKE_USER_ID, FAKE_DEVICE_ID, FAKE_SESSION_ID);
         groupCallEventHandler = new GroupCallEventHandler(mockClient.typed());
 
         mockMember = {
@@ -70,7 +68,7 @@ describe('Group Call Event Handler', function() {
                     }
                 }),
             },
-            getMember: (userId: string) => userId === FAKE_USER_ID ? mockMember : null,
+            getMember: (userId: string) => (userId === FAKE_USER_ID ? mockMember : null),
         } as unknown as Room;
 
         (mockClient as any).getRoom = jest.fn().mockReturnValue(mockRoom);
@@ -79,23 +77,20 @@ describe('Group Call Event Handler', function() {
     describe("reacts to state changes", () => {
         it("terminates call", async () => {
             await groupCallEventHandler.start();
-            mockClient.emitRoomState(
-                makeMockGroupCallStateEvent(FAKE_ROOM_ID, FAKE_GROUP_CALL_ID),
-                { roomId: FAKE_ROOM_ID } as unknown as RoomState,
-            );
+            mockClient.emitRoomState(makeMockGroupCallStateEvent(FAKE_ROOM_ID, FAKE_GROUP_CALL_ID), {
+                roomId: FAKE_ROOM_ID,
+            } as unknown as RoomState);
 
             const groupCall = groupCallEventHandler.groupCalls.get(FAKE_ROOM_ID)!;
 
             expect(groupCall.state).toBe(GroupCallState.LocalCallFeedUninitialized);
 
             mockClient.emitRoomState(
-                makeMockGroupCallStateEvent(
-                    FAKE_ROOM_ID, FAKE_GROUP_CALL_ID, {
-                        "m.type": GroupCallType.Video,
-                        "m.intent": GroupCallIntent.Prompt,
-                        "m.terminated": GroupCallTerminationReason.CallEnded,
-                    },
-                ),
+                makeMockGroupCallStateEvent(FAKE_ROOM_ID, FAKE_GROUP_CALL_ID, {
+                    "m.type": GroupCallType.Video,
+                    "m.intent": GroupCallIntent.Prompt,
+                    "m.terminated": GroupCallTerminationReason.CallEnded,
+                }),
                 {
                     roomId: FAKE_ROOM_ID,
                 } as unknown as RoomState,
@@ -131,7 +126,7 @@ describe('Group Call Event Handler', function() {
     });
 
     it("finds existing group calls when started", async () => {
-        const mockClientEmit = mockClient.emit = jest.fn();
+        const mockClientEmit = (mockClient.emit = jest.fn());
 
         mockClient.getRooms.mockReturnValue([mockRoom]);
         await groupCallEventHandler.start();
@@ -171,18 +166,15 @@ describe('Group Call Event Handler', function() {
         mockClient.on(GroupCallEventHandlerEvent.Incoming, onIncomingGroupCall);
         await groupCallEventHandler.start();
 
-        mockClient.emitRoomState(
-            makeMockGroupCallStateEvent(
-                FAKE_ROOM_ID, FAKE_GROUP_CALL_ID,
-            ),
-            {
-                roomId: FAKE_ROOM_ID,
-            } as unknown as RoomState,
-        );
+        mockClient.emitRoomState(makeMockGroupCallStateEvent(FAKE_ROOM_ID, FAKE_GROUP_CALL_ID), {
+            roomId: FAKE_ROOM_ID,
+        } as unknown as RoomState);
 
-        expect(onIncomingGroupCall).toHaveBeenCalledWith(expect.objectContaining({
-            groupCallId: FAKE_GROUP_CALL_ID,
-        }));
+        expect(onIncomingGroupCall).toHaveBeenCalledWith(
+            expect.objectContaining({
+                groupCallId: FAKE_GROUP_CALL_ID,
+            }),
+        );
 
         mockClient.off(GroupCallEventHandlerEvent.Incoming, onIncomingGroupCall);
     });
@@ -191,23 +183,19 @@ describe('Group Call Event Handler', function() {
         await groupCallEventHandler.start();
 
         const dataChannelOptions = {
-            "maxPacketLifeTime": "life_time",
-            "maxRetransmits": "retransmits",
-            "ordered": "ordered",
-            "protocol": "protocol",
+            maxPacketLifeTime: "life_time",
+            maxRetransmits: "retransmits",
+            ordered: "ordered",
+            protocol: "protocol",
         };
 
         mockClient.emitRoomState(
-            makeMockGroupCallStateEvent(
-                FAKE_ROOM_ID,
-                FAKE_GROUP_CALL_ID,
-                {
-                    "m.type": GroupCallType.Video,
-                    "m.intent": GroupCallIntent.Prompt,
-                    "dataChannelsEnabled": true,
-                    dataChannelOptions,
-                },
-            ),
+            makeMockGroupCallStateEvent(FAKE_ROOM_ID, FAKE_GROUP_CALL_ID, {
+                "m.type": GroupCallType.Video,
+                "m.intent": GroupCallIntent.Prompt,
+                "dataChannelsEnabled": true,
+                dataChannelOptions,
+            }),
             {
                 roomId: FAKE_ROOM_ID,
             } as unknown as RoomState,
@@ -236,11 +224,7 @@ describe('Group Call Event Handler', function() {
 
         const setupCallAndStart = async (content?: IContent) => {
             mocked(mockRoom.currentState.getStateEvents).mockReturnValue([
-                makeMockGroupCallStateEvent(
-                    FAKE_ROOM_ID,
-                    FAKE_GROUP_CALL_ID,
-                    content,
-                ),
+                makeMockGroupCallStateEvent(FAKE_ROOM_ID, FAKE_GROUP_CALL_ID, content),
             ] as unknown as MatrixEvent);
             mockClient.getRooms.mockReturnValue([mockRoom]);
             await groupCallEventHandler.start();
diff --git a/spec/unit/webrtc/mediaHandler.spec.ts b/spec/unit/webrtc/mediaHandler.spec.ts
index 252d8d65438..8a595cdc0a9 100644
--- a/spec/unit/webrtc/mediaHandler.spec.ts
+++ b/spec/unit/webrtc/mediaHandler.spec.ts
@@ -22,7 +22,7 @@ const FAKE_AUDIO_INPUT_ID = "aaaaaaaa";
 const FAKE_VIDEO_INPUT_ID = "vvvvvvvv";
 const FAKE_DESKTOP_SOURCE_ID = "ddddddd";
 
-describe('Media Handler', function() {
+describe("Media Handler", function () {
     let mockMediaDevices: MockMediaDevices;
     let mediaHandler: MediaHandler;
     let calls: Map<string, MatrixCall>;
@@ -58,25 +58,29 @@ describe('Media Handler', function() {
         mediaHandler.restoreMediaSettings(FAKE_AUDIO_INPUT_ID, FAKE_VIDEO_INPUT_ID);
 
         await mediaHandler.getUserMediaStream(true, true);
-        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(expect.objectContaining({
-            audio: expect.objectContaining({
-                deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
+            expect.objectContaining({
+                audio: expect.objectContaining({
+                    deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+                }),
+                video: expect.objectContaining({
+                    deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+                }),
             }),
-            video: expect.objectContaining({
-                deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
-            }),
-        }));
+        );
     });
 
     it("sets audio device ID", async () => {
         await mediaHandler.setAudioInput(FAKE_AUDIO_INPUT_ID);
 
         await mediaHandler.getUserMediaStream(true, false);
-        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(expect.objectContaining({
-            audio: expect.objectContaining({
-                deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
+            expect.objectContaining({
+                audio: expect.objectContaining({
+                    deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+                }),
             }),
-        }));
+        );
     });
 
     it("sets audio settings", async () => {
@@ -87,38 +91,44 @@ describe('Media Handler', function() {
         });
 
         await mediaHandler.getUserMediaStream(true, false);
-        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(expect.objectContaining({
-            audio: expect.objectContaining({
-                autoGainControl: { ideal: false },
-                echoCancellation: { ideal: true },
-                noiseSuppression: { ideal: false },
+        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
+            expect.objectContaining({
+                audio: expect.objectContaining({
+                    autoGainControl: { ideal: false },
+                    echoCancellation: { ideal: true },
+                    noiseSuppression: { ideal: false },
+                }),
             }),
-        }));
+        );
     });
 
     it("sets video device ID", async () => {
         await mediaHandler.setVideoInput(FAKE_VIDEO_INPUT_ID);
 
         await mediaHandler.getUserMediaStream(false, true);
-        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(expect.objectContaining({
-            video: expect.objectContaining({
-                deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
+            expect.objectContaining({
+                video: expect.objectContaining({
+                    deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+                }),
             }),
-        }));
+        );
     });
 
     it("sets media inputs", async () => {
         await mediaHandler.setMediaInputs(FAKE_AUDIO_INPUT_ID, FAKE_VIDEO_INPUT_ID);
 
         await mediaHandler.getUserMediaStream(true, true);
-        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(expect.objectContaining({
-            audio: expect.objectContaining({
-                deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
-            }),
-            video: expect.objectContaining({
-                deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+        expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
+            expect.objectContaining({
+                audio: expect.objectContaining({
+                    deviceId: { ideal: FAKE_AUDIO_INPUT_ID },
+                }),
+                video: expect.objectContaining({
+                    deviceId: { ideal: FAKE_VIDEO_INPUT_ID },
+                }),
             }),
-        }));
+        );
     });
 
     describe("updateLocalUsermediaStreams", () => {
@@ -153,9 +163,11 @@ describe('Media Handler', function() {
 
                 mediaHandler.userMediaStreams = [
                     {
-                        getTracks: () => [{
-                            stop: stopTrack,
-                        } as unknown as MediaStreamTrack],
+                        getTracks: () => [
+                            {
+                                stop: stopTrack,
+                            } as unknown as MediaStreamTrack,
+                        ],
                     } as unknown as MediaStream,
                 ];
 
@@ -225,9 +237,9 @@ describe('Media Handler', function() {
         });
 
         it("returns false if the system has no audio inputs", async () => {
-            mockMediaDevices.enumerateDevices.mockReturnValue(Promise.resolve([
-                new MockMediaDeviceInfo("videoinput").typed(),
-            ]));
+            mockMediaDevices.enumerateDevices.mockReturnValue(
+                Promise.resolve([new MockMediaDeviceInfo("videoinput").typed()]),
+            );
             expect(await mediaHandler.hasAudioDevice()).toEqual(false);
         });
     });
@@ -238,9 +250,9 @@ describe('Media Handler', function() {
         });
 
         it("returns false if the system has no video inputs", async () => {
-            mockMediaDevices.enumerateDevices.mockReturnValue(Promise.resolve([
-                new MockMediaDeviceInfo("audioinput").typed(),
-            ]));
+            mockMediaDevices.enumerateDevices.mockReturnValue(
+                Promise.resolve([new MockMediaDeviceInfo("audioinput").typed()]),
+            );
             expect(await mediaHandler.hasVideoDevice()).toEqual(false);
         });
     });
@@ -270,35 +282,35 @@ describe('Media Handler', function() {
 
         it("returns the same stream for reusable streams", async () => {
             const stream1 = await mediaHandler.getUserMediaStream(true, false);
-            const stream2 = await mediaHandler.getUserMediaStream(true, false) as unknown as MockMediaStream;
+            const stream2 = (await mediaHandler.getUserMediaStream(true, false)) as unknown as MockMediaStream;
 
             expect(stream2.isCloneOf(stream1)).toEqual(true);
         });
 
         it("doesn't re-use stream if reusable is false", async () => {
             const stream1 = await mediaHandler.getUserMediaStream(true, false, false);
-            const stream2 = await mediaHandler.getUserMediaStream(true, false) as unknown as MockMediaStream;
+            const stream2 = (await mediaHandler.getUserMediaStream(true, false)) as unknown as MockMediaStream;
 
             expect(stream2.isCloneOf(stream1)).toEqual(false);
         });
 
         it("doesn't re-use stream if existing stream lacks audio", async () => {
             const stream1 = await mediaHandler.getUserMediaStream(false, true);
-            const stream2 = await mediaHandler.getUserMediaStream(true, false) as unknown as MockMediaStream;
+            const stream2 = (await mediaHandler.getUserMediaStream(true, false)) as unknown as MockMediaStream;
 
             expect(stream2.isCloneOf(stream1)).toEqual(false);
         });
 
         it("doesn't re-use stream if existing stream lacks video", async () => {
             const stream1 = await mediaHandler.getUserMediaStream(true, false);
-            const stream2 = await mediaHandler.getUserMediaStream(false, true) as unknown as MockMediaStream;
+            const stream2 = (await mediaHandler.getUserMediaStream(false, true)) as unknown as MockMediaStream;
 
             expect(stream2.isCloneOf(stream1)).toEqual(false);
         });
 
         it("strips unwanted audio tracks from re-used stream", async () => {
             const stream1 = await mediaHandler.getUserMediaStream(true, true);
-            const stream2 = await mediaHandler.getUserMediaStream(false, true) as unknown as MockMediaStream;
+            const stream2 = (await mediaHandler.getUserMediaStream(false, true)) as unknown as MockMediaStream;
 
             expect(stream2.isCloneOf(stream1)).toEqual(true);
             expect(stream2.getAudioTracks().length).toEqual(0);
@@ -306,7 +318,7 @@ describe('Media Handler', function() {
 
         it("strips unwanted video tracks from re-used stream", async () => {
             const stream1 = await mediaHandler.getUserMediaStream(true, true);
-            const stream2 = await mediaHandler.getUserMediaStream(true, false) as unknown as MockMediaStream;
+            const stream2 = (await mediaHandler.getUserMediaStream(true, false)) as unknown as MockMediaStream;
 
             expect(stream2.isCloneOf(stream1)).toEqual(true);
             expect(stream2.getVideoTracks().length).toEqual(0);
@@ -326,7 +338,7 @@ describe('Media Handler', function() {
             expect(mockMediaDevices.getDisplayMedia).toHaveBeenCalled();
             mockMediaDevices.getDisplayMedia.mockClear();
 
-            const stream2 = await mediaHandler.getScreensharingStream() as unknown as MockMediaStream;
+            const stream2 = (await mediaHandler.getScreensharingStream()) as unknown as MockMediaStream;
 
             expect(mockMediaDevices.getDisplayMedia).not.toHaveBeenCalled();
 
@@ -338,14 +350,16 @@ describe('Media Handler', function() {
                 desktopCapturerSourceId: FAKE_DESKTOP_SOURCE_ID,
             });
 
-            expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(expect.objectContaining({
-                video: {
-                    mandatory: expect.objectContaining({
-                        chromeMediaSource: "desktop",
-                        chromeMediaSourceId: FAKE_DESKTOP_SOURCE_ID,
-                    }),
-                },
-            }));
+            expect(mockMediaDevices.getUserMedia).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    video: {
+                        mandatory: expect.objectContaining({
+                            chromeMediaSource: "desktop",
+                            chromeMediaSourceId: FAKE_DESKTOP_SOURCE_ID,
+                        }),
+                    },
+                }),
+            );
         });
 
         it("emits LocalStreamsChanged", async () => {
diff --git a/src/@types/PushRules.ts b/src/@types/PushRules.ts
index 7cdfeee2e23..56a93df9fb3 100644
--- a/src/@types/PushRules.ts
+++ b/src/@types/PushRules.ts
@@ -48,9 +48,9 @@ export enum ConditionOperator {
 
 export type PushRuleAction = Tweaks | PushRuleActionName;
 
-export type MemberCountCondition
-    <N extends number, Op extends ConditionOperator = ConditionOperator.ExactEquals>
-    = `${Op}${N}` | (Op extends ConditionOperator.ExactEquals ? `${N}` : never);
+export type MemberCountCondition<N extends number, Op extends ConditionOperator = ConditionOperator.ExactEquals> =
+    | `${Op}${N}`
+    | (Op extends ConditionOperator.ExactEquals ? `${N}` : never);
 
 export type AnyMemberCountCondition = MemberCountCondition<number, ConditionOperator>;
 
@@ -103,7 +103,8 @@ export interface ICallStartedPrefixCondition extends IPushRuleCondition<Conditio
 
 // XXX: custom conditions are possible but always fail, and break the typescript discriminated union so ignore them here
 // IPushRuleCondition<Exclude<string, ConditionKind>> unfortunately does not resolve this at the time of writing.
-export type PushRuleCondition = IEventMatchCondition
+export type PushRuleCondition =
+    | IEventMatchCondition
     | IContainsDisplayNameCondition
     | IRoomMemberCountCondition
     | ISenderNotificationPermissionCondition
@@ -157,21 +158,21 @@ export interface IPushRules {
 }
 
 export interface IPusher {
-    app_display_name: string;
-    app_id: string;
-    data: {
+    "app_display_name": string;
+    "app_id": string;
+    "data": {
         format?: string;
         url?: string; // TODO: Required if kind==http
         brand?: string; // TODO: For email notifications only? Unspecced field
     };
-    device_display_name: string;
-    kind: "http" | string;
-    lang: string;
-    profile_tag?: string;
-    pushkey: string;
-    enabled?: boolean | null;
+    "device_display_name": string;
+    "kind": "http" | string;
+    "lang": string;
+    "profile_tag"?: string;
+    "pushkey": string;
+    "enabled"?: boolean | null;
     "org.matrix.msc3881.enabled"?: boolean | null;
-    device_id?: string | null;
+    "device_id"?: string | null;
     "org.matrix.msc3881.device_id"?: string | null;
 }
 
diff --git a/src/@types/beacon.ts b/src/@types/beacon.ts
index ea8a9c8eb8f..4f2b257a767 100644
--- a/src/@types/beacon.ts
+++ b/src/@types/beacon.ts
@@ -102,8 +102,7 @@ export type MBeaconInfoContent = {
 /**
  * m.beacon_info.* event content
  */
-export type MBeaconInfoEventContent = &
-    MBeaconInfoContent &
+export type MBeaconInfoEventContent = MBeaconInfoContent &
     // creation timestamp of the beacon on the client
     MTimestampEvent &
     // the type of asset being tracked as per MSC3488
@@ -130,15 +129,13 @@ export type MBeaconInfoEventContent = &
  *   }
  * }
  * ```
-*/
+ */
 
 /**
  * Content of an m.beacon event
  */
-export type MBeaconEventContent = &
-    MLocationEvent &
+export type MBeaconEventContent = MLocationEvent &
     // timestamp when location was taken
     MTimestampEvent &
     // relates to a beacon_info event
     RELATES_TO_RELATIONSHIP<typeof REFERENCE_RELATION>;
-
diff --git a/src/@types/event.ts b/src/@types/event.ts
index d8bb4cc3081..230cb05039d 100644
--- a/src/@types/event.ts
+++ b/src/@types/event.ts
@@ -189,7 +189,8 @@ export const UNSTABLE_MSC2716_MARKER = new UnstableValue("m.room.marker", "org.m
  */
 export const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(
     "io.element.functional_members",
-    "io.element.functional_members");
+    "io.element.functional_members",
+);
 
 /**
  * A type of message that affects visibility of a message,
@@ -197,27 +198,21 @@ export const UNSTABLE_ELEMENT_FUNCTIONAL_USERS = new UnstableValue(
  *
  * @experimental
  */
-export const EVENT_VISIBILITY_CHANGE_TYPE = new UnstableValue(
-    "m.visibility",
-    "org.matrix.msc3531.visibility");
+export const EVENT_VISIBILITY_CHANGE_TYPE = new UnstableValue("m.visibility", "org.matrix.msc3531.visibility");
 
 /**
  * https://github.com/matrix-org/matrix-doc/pull/3881
  *
  * @experimental
  */
-export const PUSHER_ENABLED = new UnstableValue(
-    "enabled",
-    "org.matrix.msc3881.enabled");
+export const PUSHER_ENABLED = new UnstableValue("enabled", "org.matrix.msc3881.enabled");
 
 /**
-     * https://github.com/matrix-org/matrix-doc/pull/3881
-     *
-     * @experimental
-     */
-export const PUSHER_DEVICE_ID = new UnstableValue(
-    "device_id",
-    "org.matrix.msc3881.device_id");
+ * https://github.com/matrix-org/matrix-doc/pull/3881
+ *
+ * @experimental
+ */
+export const PUSHER_DEVICE_ID = new UnstableValue("device_id", "org.matrix.msc3881.device_id");
 
 /**
  * https://github.com/matrix-org/matrix-doc/pull/3890
@@ -226,7 +221,8 @@ export const PUSHER_DEVICE_ID = new UnstableValue(
  */
 export const LOCAL_NOTIFICATION_SETTINGS_PREFIX = new UnstableValue(
     "m.local_notification_settings",
-    "org.matrix.msc3890.local_notification_settings");
+    "org.matrix.msc3890.local_notification_settings",
+);
 
 export interface IEncryptedFile {
     url: string;
@@ -239,6 +235,6 @@ export interface IEncryptedFile {
         ext: boolean;
     };
     iv: string;
-    hashes: {[alg: string]: string};
+    hashes: { [alg: string]: string };
     v: string;
 }
diff --git a/src/@types/global.d.ts b/src/@types/global.d.ts
index 6b512434902..749eb7f417b 100644
--- a/src/@types/global.d.ts
+++ b/src/@types/global.d.ts
@@ -51,18 +51,22 @@ declare global {
     }
 
     interface DesktopCapturerConstraints {
-        audio: boolean | {
-            mandatory: {
-                chromeMediaSource: string;
-                chromeMediaSourceId: string;
-            };
-        };
-        video: boolean | {
-            mandatory: {
-                chromeMediaSource: string;
-                chromeMediaSourceId: string;
-            };
-        };
+        audio:
+            | boolean
+            | {
+                  mandatory: {
+                      chromeMediaSource: string;
+                      chromeMediaSourceId: string;
+                  };
+              };
+        video:
+            | boolean
+            | {
+                  mandatory: {
+                      chromeMediaSource: string;
+                      chromeMediaSourceId: string;
+                  };
+              };
     }
 
     interface DummyInterfaceWeShouldntBeUsingThis {}
diff --git a/src/@types/location.ts b/src/@types/location.ts
index 9fc37d349e7..023557b7788 100644
--- a/src/@types/location.ts
+++ b/src/@types/location.ts
@@ -38,8 +38,7 @@ export const M_TIMESTAMP = new UnstableValue("m.ts", "org.matrix.msc3488.ts");
  */
 export type MTimestampEvent = EitherAnd<{ [M_TIMESTAMP.name]: number }, { [M_TIMESTAMP.altName]: number }>;
 
-export const M_LOCATION = new UnstableValue(
-    "m.location", "org.matrix.msc3488.location");
+export const M_LOCATION = new UnstableValue("m.location", "org.matrix.msc3488.location");
 
 export type MLocationContent = {
     uri: string;
@@ -76,12 +75,8 @@ export type MTextEvent = EitherAnd<{ [TEXT_NODE_TYPE.name]: string }, { [TEXT_NO
 type OptionalTimestampEvent = MTimestampEvent | undefined;
 /**
  * The content for an m.location event
-*/
-export type MLocationEventContent = &
-    MLocationEvent &
-    MAssetEvent &
-    MTextEvent &
-    OptionalTimestampEvent;
+ */
+export type MLocationEventContent = MLocationEvent & MAssetEvent & MTextEvent & OptionalTimestampEvent;
 
 export type LegacyLocationEventContent = {
     body: string;
diff --git a/src/@types/partials.ts b/src/@types/partials.ts
index bf27eab0e53..49f92f32759 100644
--- a/src/@types/partials.ts
+++ b/src/@types/partials.ts
@@ -17,7 +17,8 @@ limitations under the License.
 export interface IImageInfo {
     size?: number;
     mimetype?: string;
-    thumbnail_info?: { // eslint-disable-line camelcase
+    thumbnail_info?: {
+        // eslint-disable-line camelcase
         w?: number;
         h?: number;
         size?: number;
diff --git a/src/@types/read_receipts.ts b/src/@types/read_receipts.ts
index ea832926072..34f1c67fad7 100644
--- a/src/@types/read_receipts.ts
+++ b/src/@types/read_receipts.ts
@@ -38,7 +38,7 @@ export interface CachedReceipt {
     data: Receipt;
 }
 
-export type ReceiptCache = {[eventId: string]: CachedReceipt[]};
+export type ReceiptCache = { [eventId: string]: CachedReceipt[] };
 
 export interface ReceiptContent {
     [eventId: string]: {
diff --git a/src/@types/sync.ts b/src/@types/sync.ts
index 036c542bafa..d9a2a6f564d 100644
--- a/src/@types/sync.ts
+++ b/src/@types/sync.ts
@@ -23,4 +23,5 @@ import { ServerControlledNamespacedValue } from "../NamespacedValue";
  */
 export const UNREAD_THREAD_NOTIFICATIONS = new ServerControlledNamespacedValue(
     "unread_thread_notifications",
-    "org.matrix.msc3773.unread_thread_notifications");
+    "org.matrix.msc3773.unread_thread_notifications",
+);
diff --git a/src/@types/uia.ts b/src/@types/uia.ts
index a976083a65d..e6114200982 100644
--- a/src/@types/uia.ts
+++ b/src/@types/uia.ts
@@ -20,7 +20,7 @@ import { IAuthData } from "../interactive-auth";
  * Helper type to represent HTTP request body for a UIA enabled endpoint
  */
 export type UIARequest<T> = T & {
-  auth?: IAuthData;
+    auth?: IAuthData;
 };
 
 /**
diff --git a/src/NamespacedValue.ts b/src/NamespacedValue.ts
index dc028bec4ca..a1a7e5d2bbd 100644
--- a/src/NamespacedValue.ts
+++ b/src/NamespacedValue.ts
@@ -82,8 +82,7 @@ export class NamespacedValue<S extends string, U extends string> {
     }
 }
 
-export class ServerControlledNamespacedValue<S extends string, U extends string>
-    extends NamespacedValue<S, U> {
+export class ServerControlledNamespacedValue<S extends string, U extends string> extends NamespacedValue<S, U> {
     private preferUnstable = false;
 
     public setPreferUnstable(preferUnstable: boolean): void {
diff --git a/src/ReEmitter.ts b/src/ReEmitter.ts
index 2fa6eface1e..565e8ea702c 100644
--- a/src/ReEmitter.ts
+++ b/src/ReEmitter.ts
@@ -49,7 +49,7 @@ export class ReEmitter {
                 // later by a different part of the code where 'emit' throwing because the app hasn't
                 // added an error handler isn't terribly helpful. (A better fix in retrospect may
                 // have been to just avoid using the event name 'error', but backwards compat...)
-                if (eventName === 'error' && this.target.listenerCount('error') === 0) return;
+                if (eventName === "error" && this.target.listenerCount("error") === 0) return;
                 this.target.emit(eventName, ...args, source);
             };
             source.on(eventName, forSource);
@@ -70,10 +70,7 @@ export class ReEmitter {
     }
 }
 
-export class TypedReEmitter<
-    Events extends string,
-    Arguments extends ListenerMap<Events>,
-> extends ReEmitter {
+export class TypedReEmitter<Events extends string, Arguments extends ListenerMap<Events>> extends ReEmitter {
     public constructor(target: TypedEventEmitter<Events, Arguments>) {
         super(target);
     }
diff --git a/src/ToDeviceMessageQueue.ts b/src/ToDeviceMessageQueue.ts
index bf881395b2e..e78c46ba200 100644
--- a/src/ToDeviceMessageQueue.ts
+++ b/src/ToDeviceMessageQueue.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { ToDeviceMessageId } from './@types/event';
+import { ToDeviceMessageId } from "./@types/event";
 import { logger } from "./logger";
 import { MatrixError, MatrixClient } from "./matrix";
 import { IndexedToDeviceBatch, ToDeviceBatch, ToDeviceBatchWithTxnId, ToDevicePayload } from "./models/ToDeviceMessage";
@@ -32,8 +32,7 @@ export class ToDeviceMessageQueue {
     private retryTimeout: ReturnType<typeof setTimeout> | null = null;
     private retryAttempts = 0;
 
-    public constructor(private client: MatrixClient) {
-    }
+    public constructor(private client: MatrixClient) {}
 
     public start(): void {
         this.running = true;
@@ -59,7 +58,8 @@ export class ToDeviceMessageQueue {
                 (msg) => `${msg.userId}/${msg.deviceId} (msgid ${msg.payload[ToDeviceMessageId]})`,
             );
             logger.info(
-                `Enqueuing batch of to-device messages. type=${batch.eventType} txnid=${batchWithTxnId.txnId}`, msgmap,
+                `Enqueuing batch of to-device messages. type=${batch.eventType} txnid=${batchWithTxnId.txnId}`,
+                msgmap,
             );
         }
 
diff --git a/src/autodiscovery.ts b/src/autodiscovery.ts
index 35728d1e21d..aa839550f9e 100644
--- a/src/autodiscovery.ts
+++ b/src/autodiscovery.ts
@@ -16,7 +16,7 @@ limitations under the License.
 */
 
 import { IClientWellKnown, IWellKnownConfig } from "./client";
-import { logger } from './logger';
+import { logger } from "./logger";
 import { MatrixError, Method, timeoutSignal } from "./http-api";
 
 // Dev note: Auto discovery is part of the spec.
@@ -162,9 +162,7 @@ export class AutoDiscovery {
 
         // Step 2: Make sure the homeserver URL is valid *looking*. We'll make
         // sure it points to a homeserver in Step 3.
-        const hsUrl = this.sanitizeWellKnownUrl(
-            wellknown["m.homeserver"]["base_url"],
-        );
+        const hsUrl = this.sanitizeWellKnownUrl(wellknown["m.homeserver"]["base_url"]);
         if (!hsUrl) {
             logger.error("Invalid base_url for m.homeserver");
             clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HS_BASE_URL;
@@ -172,9 +170,7 @@ export class AutoDiscovery {
         }
 
         // Step 3: Make sure the homeserver URL points to a homeserver.
-        const hsVersions = await this.fetchWellKnownObject(
-            `${hsUrl}/_matrix/client/versions`,
-        );
+        const hsVersions = await this.fetchWellKnownObject(`${hsUrl}/_matrix/client/versions`);
         if (!hsVersions || !hsVersions.raw?.["versions"]) {
             logger.error("Invalid /versions response");
             clientConfig["m.homeserver"].error = AutoDiscovery.ERROR_INVALID_HOMESERVER;
@@ -212,20 +208,16 @@ export class AutoDiscovery {
             isUrl = this.sanitizeWellKnownUrl(wellknown["m.identity_server"]["base_url"]);
             if (!isUrl) {
                 logger.error("Invalid base_url for m.identity_server");
-                failingClientConfig["m.identity_server"].error =
-                    AutoDiscovery.ERROR_INVALID_IS_BASE_URL;
+                failingClientConfig["m.identity_server"].error = AutoDiscovery.ERROR_INVALID_IS_BASE_URL;
                 return Promise.resolve(failingClientConfig);
             }
 
             // Step 5b: Verify there is an identity server listening on the provided
             // URL.
-            const isResponse = await this.fetchWellKnownObject(
-                `${isUrl}/_matrix/identity/api/v1`,
-            );
+            const isResponse = await this.fetchWellKnownObject(`${isUrl}/_matrix/identity/api/v1`);
             if (!isResponse?.raw || isResponse.action !== AutoDiscoveryAction.SUCCESS) {
                 logger.error("Invalid /api/v1 response");
-                failingClientConfig["m.identity_server"].error =
-                    AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;
+                failingClientConfig["m.identity_server"].error = AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;
 
                 // Supply the base_url to the caller because they may be ignoring
                 // liveliness errors, like this one.
@@ -281,7 +273,7 @@ export class AutoDiscovery {
      * failure, not when discovery fails.
      */
     public static async findClientConfig(domain: string): Promise<ClientConfig> {
-        if (!domain || typeof(domain) !== "string" || domain.length === 0) {
+        if (!domain || typeof domain !== "string" || domain.length === 0) {
             throw new Error("'domain' must be a string of non-zero length");
         }
 
@@ -316,9 +308,7 @@ export class AutoDiscovery {
 
         // Step 1: Actually request the .well-known JSON file and make sure it
         // at least has a homeserver definition.
-        const wellknown = await this.fetchWellKnownObject(
-            `https://${domain}/.well-known/matrix/client`,
-        );
+        const wellknown = await this.fetchWellKnownObject(`https://${domain}/.well-known/matrix/client`);
         if (!wellknown || wellknown.action !== AutoDiscoveryAction.SUCCESS) {
             logger.error("No response or error when parsing .well-known");
             if (wellknown.reason) logger.error(wellknown.reason);
@@ -349,13 +339,11 @@ export class AutoDiscovery {
      * be an empty object.
      */
     public static async getRawClientConfig(domain?: string): Promise<IClientWellKnown> {
-        if (!domain || typeof(domain) !== "string" || domain.length === 0) {
+        if (!domain || typeof domain !== "string" || domain.length === 0) {
             throw new Error("'domain' must be a string of non-zero length");
         }
 
-        const response = await this.fetchWellKnownObject(
-            `https://${domain}/.well-known/matrix/client`,
-        );
+        const response = await this.fetchWellKnownObject(`https://${domain}/.well-known/matrix/client`);
         if (!response) return {};
         return response.raw || {};
     }
@@ -474,9 +462,10 @@ export class AutoDiscovery {
                 error,
                 raw: {},
                 action: AutoDiscoveryAction.FAIL_PROMPT,
-                reason: (error as MatrixError)?.name === "SyntaxError"
-                    ? AutoDiscovery.ERROR_INVALID_JSON
-                    : AutoDiscovery.ERROR_INVALID,
+                reason:
+                    (error as MatrixError)?.name === "SyntaxError"
+                        ? AutoDiscovery.ERROR_INVALID_JSON
+                        : AutoDiscovery.ERROR_INVALID,
             };
         }
     }
diff --git a/src/client.ts b/src/client.ts
index ce44d32fd66..68df4595d17 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -33,10 +33,10 @@ import {
 import { StubStore } from "./store/stub";
 import { CallEvent, CallEventHandlerMap, createNewMatrixCall, MatrixCall, supportsMatrixCall } from "./webrtc/call";
 import { Filter, IFilterDefinition, IRoomEventFilter } from "./filter";
-import { CallEventHandlerEvent, CallEventHandler, CallEventHandlerEventHandlerMap } from './webrtc/callEventHandler';
-import { GroupCallEventHandlerEvent, GroupCallEventHandlerEventHandlerMap } from './webrtc/groupCallEventHandler';
-import * as utils from './utils';
-import { replaceParam, QueryDict, sleep } from './utils';
+import { CallEventHandlerEvent, CallEventHandler, CallEventHandlerEventHandlerMap } from "./webrtc/callEventHandler";
+import { GroupCallEventHandlerEvent, GroupCallEventHandlerEventHandlerMap } from "./webrtc/groupCallEventHandler";
+import * as utils from "./utils";
+import { replaceParam, QueryDict, sleep } from "./utils";
 import { Direction, EventTimeline } from "./models/event-timeline";
 import { IActionsObject, PushProcessor } from "./pushprocessor";
 import { AutoDiscovery, AutoDiscoveryAction } from "./autodiscovery";
@@ -44,10 +44,10 @@ import * as olmlib from "./crypto/olmlib";
 import { decodeBase64, encodeBase64 } from "./crypto/olmlib";
 import { IExportedDevice as IExportedOlmDevice } from "./crypto/OlmDevice";
 import { IOlmDevice } from "./crypto/algorithms/megolm";
-import { TypedReEmitter } from './ReEmitter';
-import { IRoomEncryption, RoomList } from './crypto/RoomList';
-import { logger } from './logger';
-import { SERVICE_TYPES } from './service-types';
+import { TypedReEmitter } from "./ReEmitter";
+import { IRoomEncryption, RoomList } from "./crypto/RoomList";
+import { logger } from "./logger";
+import { SERVICE_TYPES } from "./service-types";
 import {
     HttpApiEvent,
     HttpApiEventHandlerMap,
@@ -78,10 +78,10 @@ import {
     isCryptoAvailable,
     VerificationMethod,
     IRoomKeyRequestBody,
-} from './crypto';
+} from "./crypto";
 import { DeviceInfo, IDevice } from "./crypto/deviceinfo";
-import { decodeRecoveryKey } from './crypto/recoverykey';
-import { keyFromAuthData } from './crypto/key_passphrase';
+import { decodeRecoveryKey } from "./crypto/recoverykey";
+import { keyFromAuthData } from "./crypto/key_passphrase";
 import { User, UserEvent, UserEventHandlerMap } from "./models/user";
 import { getHttpUriForMxc } from "./content-repo";
 import { SearchResult } from "./models/search-result";
@@ -185,12 +185,7 @@ import {
 } from "./@types/PushRules";
 import { IThreepid } from "./@types/threepids";
 import { CryptoStore, OutgoingRoomKeyRequest } from "./crypto/store/base";
-import {
-    GroupCall,
-    IGroupCallDataChannelOptions,
-    GroupCallIntent,
-    GroupCallType,
-} from "./webrtc/groupCall";
+import { GroupCall, IGroupCallDataChannelOptions, GroupCallIntent, GroupCallType } from "./webrtc/groupCall";
 import { MediaHandler } from "./webrtc/mediaHandler";
 import { GroupCallEventHandler } from "./webrtc/groupCallEventHandler";
 import { LoginTokenPostResponse, ILoginFlowsResponse, IRefreshTokenResponse, SSOAction } from "./@types/auth";
@@ -237,7 +232,8 @@ interface IExportedDevice {
 }
 
 export interface IKeysUploadResponse {
-    one_time_key_counts: { // eslint-disable-line camelcase
+    one_time_key_counts: {
+        // eslint-disable-line camelcase
         [algorithm: string]: number;
     };
 }
@@ -454,7 +450,7 @@ export interface IStartClientOpts {
     /**
      * @experimental
      */
-     slidingSync?: SlidingSync;
+    slidingSync?: SlidingSync;
 }
 
 export interface IStoredClientOpts extends IStartClientOpts {
@@ -520,10 +516,16 @@ export interface ISignedKey {
 
 export type KeySignatures = Record<string, Record<string, ICrossSigningKey | ISignedKey>>;
 export interface IUploadKeySignaturesResponse {
-    failures: Record<string, Record<string, {
-        errcode: string;
-        error: string;
-    }>>;
+    failures: Record<
+        string,
+        Record<
+            string,
+            {
+                errcode: string;
+                error: string;
+            }
+        >
+    >;
 }
 
 export interface IPreviewUrlResponse {
@@ -557,10 +559,7 @@ export interface IServerVersions {
     unstable_features: Record<string, boolean>;
 }
 
-export const M_AUTHENTICATION = new UnstableValue(
-    "m.authentication",
-    "org.matrix.msc2965.authentication",
-);
+export const M_AUTHENTICATION = new UnstableValue("m.authentication", "org.matrix.msc2965.authentication");
 
 export interface IClientWellKnown {
     [key: string]: any;
@@ -578,7 +577,8 @@ export interface IWellKnownConfig {
     base_url?: string | null;
 }
 
-export interface IDelegatedAuthConfig { // MSC2965
+export interface IDelegatedAuthConfig {
+    // MSC2965
     /** The OIDC Provider/issuer the client should use */
     issuer: string;
     /** The optional URL of the web UI where the user can manage their account */
@@ -639,8 +639,8 @@ export interface IRequestMsisdnTokenResponse extends IRequestTokenResponse {
 }
 
 export interface IUploadKeysRequest {
-    device_keys?: Required<IDeviceKeys>;
-    one_time_keys?: Record<string, IOneTimeKey>;
+    "device_keys"?: Required<IDeviceKeys>;
+    "one_time_keys"?: Record<string, IOneTimeKey>;
     "org.matrix.msc2732.fallback_keys"?: Record<string, IOneTimeKey>;
 }
 
@@ -732,12 +732,12 @@ interface IUserDirectoryResponse {
 }
 
 export interface IMyDevice {
-    device_id: string;
-    display_name?: string;
-    last_seen_ip?: string;
-    last_seen_ts?: number;
+    "device_id": string;
+    "display_name"?: string;
+    "last_seen_ip"?: string;
+    "last_seen_ts"?: number;
     // UNSTABLE_MSC3852_LAST_SEEN_UA
-    last_seen_user_agent?: string;
+    "last_seen_user_agent"?: string;
     "org.matrix.msc3852.last_seen_user_agent"?: string;
 }
 
@@ -861,7 +861,8 @@ export enum ClientEvent {
     TurnServersError = "turnServers.error",
 }
 
-type RoomEvents = RoomEvent.Name
+type RoomEvents =
+    | RoomEvent.Name
     | RoomEvent.Redaction
     | RoomEvent.RedactionCancelled
     | RoomEvent.Receipt
@@ -873,14 +874,15 @@ type RoomEvents = RoomEvent.Name
     | RoomEvent.Timeline
     | RoomEvent.TimelineReset;
 
-type RoomStateEvents = RoomStateEvent.Events
+type RoomStateEvents =
+    | RoomStateEvent.Events
     | RoomStateEvent.Members
     | RoomStateEvent.NewMember
     | RoomStateEvent.Update
-    | RoomStateEvent.Marker
-    ;
+    | RoomStateEvent.Marker;
 
-type CryptoEvents = CryptoEvent.KeySignatureUploadFailure
+type CryptoEvents =
+    | CryptoEvent.KeySignatureUploadFailure
     | CryptoEvent.KeyBackupStatus
     | CryptoEvent.KeyBackupFailed
     | CryptoEvent.KeyBackupSessionsRemaining
@@ -896,18 +898,21 @@ type CryptoEvents = CryptoEvent.KeySignatureUploadFailure
 
 type MatrixEventEvents = MatrixEventEvent.Decrypted | MatrixEventEvent.Replaced | MatrixEventEvent.VisibilityChange;
 
-type RoomMemberEvents = RoomMemberEvent.Name
+type RoomMemberEvents =
+    | RoomMemberEvent.Name
     | RoomMemberEvent.Typing
     | RoomMemberEvent.PowerLevel
     | RoomMemberEvent.Membership;
 
-type UserEvents = UserEvent.AvatarUrl
+type UserEvents =
+    | UserEvent.AvatarUrl
     | UserEvent.DisplayName
     | UserEvent.Presence
     | UserEvent.CurrentlyActive
     | UserEvent.LastPresenceTs;
 
-export type EmittedEvents = ClientEvent
+export type EmittedEvents =
+    | ClientEvent
     | RoomEvents
     | RoomStateEvents
     | CryptoEvents
@@ -1107,17 +1112,17 @@ export type ClientEventHandlerMap = {
     [ClientEvent.ReceivedVoipEvent]: (event: MatrixEvent) => void;
     [ClientEvent.TurnServers]: (servers: ITurnServer[]) => void;
     [ClientEvent.TurnServersError]: (error: Error, fatal: boolean) => void;
-} & RoomEventHandlerMap
-    & RoomStateEventHandlerMap
-    & CryptoEventHandlerMap
-    & MatrixEventHandlerMap
-    & RoomMemberEventHandlerMap
-    & UserEventHandlerMap
-    & CallEventHandlerEventHandlerMap
-    & GroupCallEventHandlerEventHandlerMap
-    & CallEventHandlerMap
-    & HttpApiEventHandlerMap
-    & BeaconEventHandlerMap;
+} & RoomEventHandlerMap &
+    RoomStateEventHandlerMap &
+    CryptoEventHandlerMap &
+    MatrixEventHandlerMap &
+    RoomMemberEventHandlerMap &
+    UserEventHandlerMap &
+    CallEventHandlerEventHandlerMap &
+    GroupCallEventHandlerEventHandlerMap &
+    CallEventHandlerMap &
+    HttpApiEventHandlerMap &
+    BeaconEventHandlerMap;
 
 const SSO_ACTION_PARAM = new UnstableValue("action", "org.matrix.msc3824.action");
 
@@ -1127,7 +1132,7 @@ const SSO_ACTION_PARAM = new UnstableValue("action", "org.matrix.msc3824.action"
  * as it specifies 'sensible' defaults for these modules.
  */
 export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHandlerMap> {
-    public static readonly RESTORE_BACKUP_ERROR_BAD_KEY = 'RESTORE_BACKUP_ERROR_BAD_KEY';
+    public static readonly RESTORE_BACKUP_ERROR_BAD_KEY = "RESTORE_BACKUP_ERROR_BAD_KEY";
 
     public reEmitter = new TypedReEmitter<EmittedEvents, ClientEventHandlerMap>(this);
     public olmVersion: [number, number, number] | null = null; // populated after initCrypto
@@ -1158,7 +1163,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     protected canSupportVoip = false;
     protected peekSync: SyncApi | null = null;
     protected isGuestAccount = false;
-    protected ongoingScrollbacks: {[roomId: string]: {promise?: Promise<Room>, errorTs?: number}} = {};
+    protected ongoingScrollbacks: { [roomId: string]: { promise?: Promise<Room>; errorTs?: number } } = {};
     protected notifTimelineSet: EventTimelineSet | null = null;
     protected cryptoStore?: CryptoStore;
     protected verificationMethods?: VerificationMethod[];
@@ -1236,16 +1241,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (opts.deviceToImport) {
             if (this.deviceId) {
                 logger.warn(
-                    'not importing device because device ID is provided to ' +
-                    'constructor independently of exported data',
+                    "not importing device because device ID is provided to " +
+                        "constructor independently of exported data",
                 );
             } else if (this.credentials.userId) {
                 logger.warn(
-                    'not importing device because user ID is provided to ' +
-                    'constructor independently of exported data',
+                    "not importing device because user ID is provided to " +
+                        "constructor independently of exported data",
                 );
             } else if (!opts.deviceToImport.deviceId) {
-                logger.warn('not importing device because no device ID in exported data');
+                logger.warn("not importing device because no device ID in exported data");
             } else {
                 this.deviceId = opts.deviceToImport.deviceId;
                 this.credentials.userId = opts.deviceToImport.userId;
@@ -1319,16 +1324,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             if (room && this.isRoomEncrypted(room.roomId)) {
                 // Figure out if we've read something or if it's just informational
                 const content = event.getContent();
-                const isSelf = Object.keys(content).filter(eid => {
-                    for (const [key, value] of Object.entries(content[eid])) {
-                        if (!utils.isSupportedReceiptType(key)) continue;
-                        if (!value) continue;
+                const isSelf =
+                    Object.keys(content).filter((eid) => {
+                        for (const [key, value] of Object.entries(content[eid])) {
+                            if (!utils.isSupportedReceiptType(key)) continue;
+                            if (!value) continue;
 
-                        if (Object.keys(value).includes(this.getUserId()!)) return true;
-                    }
+                            if (Object.keys(value).includes(this.getUserId()!)) return true;
+                        }
 
-                    return false;
-                }).length > 0;
+                        return false;
+                    }).length > 0;
 
                 if (!isSelf) return;
 
@@ -1453,7 +1459,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         if (!this.clientRunning) return; // already stopped
 
-        logger.log('stopping MatrixClient');
+        logger.log("stopping MatrixClient");
 
         this.clientRunning = false;
 
@@ -1513,13 +1519,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 return;
             }
             logger.log("unpickling dehydrated device");
-            const key = await this.cryptoCallbacks.getDehydrationKey(
-                deviceData,
-                (k) => {
-                    // copy the key so that it doesn't get clobbered
-                    account.unpickle(new Uint8Array(k), deviceData.account);
-                },
-            );
+            const key = await this.cryptoCallbacks.getDehydrationKey(deviceData, (k) => {
+                // copy the key so that it doesn't get clobbered
+                account.unpickle(new Uint8Array(k), deviceData.account);
+            });
             account.unpickle(key, deviceData.account);
             logger.log("unpickled device");
 
@@ -1566,7 +1569,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             return await this.http.authedRequest<IDehydratedDevice>(
                 Method.Get,
                 "/dehydrated_device",
-                undefined, undefined,
+                undefined,
+                undefined,
                 {
                     prefix: "/_matrix/client/unstable/org.matrix.msc2697.v2",
                 },
@@ -1594,7 +1598,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         deviceDisplayName?: string,
     ): Promise<void> {
         if (!this.crypto) {
-            logger.warn('not dehydrating device if crypto is not enabled');
+            logger.warn("not dehydrating device if crypto is not enabled");
             return;
         }
         return this.crypto.dehydrationManager.setKeyAndQueueDehydration(key, keyInfo, deviceDisplayName);
@@ -1615,7 +1619,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         deviceDisplayName?: string,
     ): Promise<string | undefined> {
         if (!this.crypto) {
-            logger.warn('not dehydrating device if crypto is not enabled');
+            logger.warn("not dehydrating device if crypto is not enabled");
             return;
         }
         await this.crypto.dehydrationManager.setKey(key, keyInfo, deviceDisplayName);
@@ -1624,7 +1628,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
     public async exportDevice(): Promise<IExportedDevice | undefined> {
         if (!this.crypto) {
-            logger.warn('not exporting device if crypto is not enabled');
+            logger.warn("not exporting device if crypto is not enabled");
             return;
         }
         return {
@@ -1672,7 +1676,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public getDomain(): string | null {
         if (this.credentials && this.credentials.userId) {
-            return this.credentials.userId.replace(/^.*?:/, '');
+            return this.credentials.userId.replace(/^.*?:/, "");
         }
         return null;
     }
@@ -1930,27 +1934,28 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         type Response = {
             capabilities?: ICapabilities;
         };
-        return this.http.authedRequest<Response>(Method.Get, "/capabilities").catch((e: Error): Response => {
-            // We swallow errors because we need a default object anyhow
-            logger.error(e);
-            return {};
-        }).then((r = {}) => {
-            const capabilities = r["capabilities"] || {};
-
-            // If the capabilities missed the cache, cache it for a shorter amount
-            // of time to try and refresh them later.
-            const cacheMs = Object.keys(capabilities).length
-                ? CAPABILITIES_CACHE_MS
-                : 60000 + (Math.random() * 5000);
-
-            this.cachedCapabilities = {
-                capabilities,
-                expiration: now + cacheMs,
-            };
+        return this.http
+            .authedRequest<Response>(Method.Get, "/capabilities")
+            .catch((e: Error): Response => {
+                // We swallow errors because we need a default object anyhow
+                logger.error(e);
+                return {};
+            })
+            .then((r = {}) => {
+                const capabilities = r["capabilities"] || {};
 
-            logger.log("Caching capabilities: ", capabilities);
-            return capabilities;
-        });
+                // If the capabilities missed the cache, cache it for a shorter amount
+                // of time to try and refresh them later.
+                const cacheMs = Object.keys(capabilities).length ? CAPABILITIES_CACHE_MS : 60000 + Math.random() * 5000;
+
+                this.cachedCapabilities = {
+                    capabilities,
+                    expiration: now + cacheMs,
+                };
+
+                logger.log("Caching capabilities: ", capabilities);
+                return capabilities;
+            });
     }
 
     /**
@@ -1966,7 +1971,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (!isCryptoAvailable()) {
             throw new Error(
                 `End-to-end encryption not supported in this js-sdk build: did ` +
-                `you remember to load the olm library?`,
+                    `you remember to load the olm library?`,
             );
         }
 
@@ -1991,13 +1996,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (userId === null) {
             throw new Error(
                 `Cannot enable encryption on MatrixClient with unknown userId: ` +
-                `ensure userId is passed in createClient().`,
+                    `ensure userId is passed in createClient().`,
             );
         }
         if (this.deviceId === null) {
             throw new Error(
                 `Cannot enable encryption on MatrixClient with unknown deviceId: ` +
-                `ensure deviceId is passed in createClient().`,
+                    `ensure deviceId is passed in createClient().`,
             );
         }
 
@@ -2087,10 +2092,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *
      * @returns A promise which resolves to a map userId-\>deviceId-\>{@link DeviceInfo}
      */
-    public downloadKeys(
-        userIds: string[],
-        forceDownload?: boolean,
-    ): Promise<Record<string, Record<string, IDevice>>> {
+    public downloadKeys(userIds: string[], forceDownload?: boolean): Promise<Record<string, Record<string, IDevice>>> {
         if (!this.crypto) {
             return Promise.reject(new Error("End-to-end encryption disabled"));
         }
@@ -2654,7 +2656,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         algorithm: string,
         opts: IAddSecretStorageKeyOpts,
         keyName?: string,
-    ): Promise<{keyId: string, keyInfo: ISecretStorageKeyInfo}> {
+    ): Promise<{ keyId: string; keyInfo: ISecretStorageKeyInfo }> {
         if (!this.crypto) {
             throw new Error("End-to-end encryption disabled");
         }
@@ -2835,12 +2837,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             algorithm: wireContent.algorithm,
             room_id: event.getRoomId()!,
         };
-        if (
-            !requestBody.session_id
-            || !requestBody.sender_key
-            || !requestBody.algorithm
-            || !requestBody.room_id
-        ) return Promise.resolve(null);
+        if (!requestBody.session_id || !requestBody.sender_key || !requestBody.algorithm || !requestBody.room_id)
+            return Promise.resolve(null);
         return this.crypto.cryptoStore.getOutgoingRoomKeyRequest(requestBody);
     }
 
@@ -2911,10 +2909,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *     userDeviceMap, and returns the `{ contentMap, deviceInfoByDeviceId }`
      *     of the successfully sent messages.
      */
-    public encryptAndSendToDevices(
-        userDeviceInfoArr: IOlmDevice<DeviceInfo>[],
-        payload: object,
-    ): Promise<void> {
+    public encryptAndSendToDevices(userDeviceInfoArr: IOlmDevice<DeviceInfo>[], payload: object): Promise<void> {
         if (!this.crypto) {
             throw new Error("End-to-End encryption disabled");
         }
@@ -2989,11 +2984,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         let res: IKeyBackupInfo;
         try {
             res = await this.http.authedRequest<IKeyBackupInfo>(
-                Method.Get, "/room_keys/version", undefined, undefined,
+                Method.Get,
+                "/room_keys/version",
+                undefined,
+                undefined,
                 { prefix: ClientPrefix.V3 },
             );
         } catch (e) {
-            if ((<MatrixError>e).errcode === 'M_NOT_FOUND') {
+            if ((<MatrixError>e).errcode === "M_NOT_FOUND") {
                 return null;
             } else {
                 throw e;
@@ -3136,10 +3134,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             await this.crypto.crossSigningInfo.signObject(data.auth_data, "master");
         }
 
-        const res = await this.http.authedRequest<IKeyBackupInfo>(
-            Method.Post, "/room_keys/version", undefined, data,
-            { prefix: ClientPrefix.V3 },
-        );
+        const res = await this.http.authedRequest<IKeyBackupInfo>(Method.Post, "/room_keys/version", undefined, data, {
+            prefix: ClientPrefix.V3,
+        });
 
         // We could assume everything's okay and enable directly, but this ensures
         // we run the same signature verification that will be used for future
@@ -3168,10 +3165,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             $version: version,
         });
 
-        await this.http.authedRequest(
-            Method.Delete, path, undefined, undefined,
-            { prefix: ClientPrefix.V3 },
-        );
+        await this.http.authedRequest(Method.Delete, path, undefined, undefined, { prefix: ClientPrefix.V3 });
     }
 
     private makeKeyBackupPath(roomId: undefined, sessionId: undefined, version?: string): IKeyBackupPath;
@@ -3233,10 +3227,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         const path = this.makeKeyBackupPath(roomId!, sessionId!, version);
-        await this.http.authedRequest(
-            Method.Put, path.path, path.queryData, data,
-            { prefix: ClientPrefix.V3 },
-        );
+        await this.http.authedRequest(Method.Put, path.path, path.queryData, data, { prefix: ClientPrefix.V3 });
     }
 
     /**
@@ -3501,7 +3492,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         const path = this.makeKeyBackupPath(targetRoomId!, targetSessionId!, backupInfo.version);
 
-        const algorithm = await BackupManager.makeAlgorithm(backupInfo, async () => { return privKey; });
+        const algorithm = await BackupManager.makeAlgorithm(backupInfo, async () => {
+            return privKey;
+        });
 
         const untrusted = algorithm.untrusted;
 
@@ -3509,16 +3502,18 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             // If the pubkey computed from the private data we've been given
             // doesn't match the one in the auth_data, the user has entered
             // a different recovery key / the wrong passphrase.
-            if (!await algorithm.keyMatches(privKey)) {
+            if (!(await algorithm.keyMatches(privKey))) {
                 return Promise.reject(new MatrixError({ errcode: MatrixClient.RESTORE_BACKUP_ERROR_BAD_KEY }));
             }
 
             // Cache the key, if possible.
             // This is async.
-            this.crypto.storeSessionBackupPrivateKey(privKey)
+            this.crypto
+                .storeSessionBackupPrivateKey(privKey)
                 .catch((e) => {
                     logger.warn("Error caching session backup key:", e);
-                }).then(cacheCompleteCallback);
+                })
+                .then(cacheCompleteCallback);
 
             if (progressCallback) {
                 progressCallback({
@@ -3527,7 +3522,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             }
 
             const res = await this.http.authedRequest<IRoomsKeysResponse | IRoomKeysResponse | IKeyBackupSession>(
-                Method.Get, path.path, path.queryData, undefined,
+                Method.Get,
+                path.path,
+                path.queryData,
+                undefined,
                 { prefix: ClientPrefix.V3 },
             );
 
@@ -3587,10 +3585,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         const path = this.makeKeyBackupPath(roomId!, sessionId!, version);
-        await this.http.authedRequest(
-            Method.Delete, path.path, path.queryData, undefined,
-            { prefix: ClientPrefix.V3 },
-        );
+        await this.http.authedRequest(Method.Delete, path.path, path.queryData, undefined, { prefix: ClientPrefix.V3 });
     }
 
     /**
@@ -3632,11 +3627,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves with an object containing the config.
      */
     public getMediaConfig(): Promise<IMediaConfig> {
-        return this.http.authedRequest(
-            Method.Get, "/config", undefined, undefined, {
-                prefix: MediaPrefix.R0,
-            },
-        );
+        return this.http.authedRequest(Method.Get, "/config", undefined, undefined, {
+            prefix: MediaPrefix.R0,
+        });
     }
 
     /**
@@ -3674,18 +3667,18 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         const replacedRooms = new Set();
         for (const r of allRooms) {
-            const createEvent = r.currentState.getStateEvents(EventType.RoomCreate, '');
+            const createEvent = r.currentState.getStateEvents(EventType.RoomCreate, "");
             // invites are included in this list and we don't know their create events yet
             if (createEvent) {
-                const predecessor = createEvent.getContent()['predecessor'];
-                if (predecessor && predecessor['room_id']) {
-                    replacedRooms.add(predecessor['room_id']);
+                const predecessor = createEvent.getContent()["predecessor"];
+                if (predecessor && predecessor["room_id"]) {
+                    replacedRooms.add(predecessor["room_id"]);
                 }
             }
         }
 
         return allRooms.filter((r) => {
-            const tombstone = r.currentState.getStateEvents(EventType.RoomTombstone, '');
+            const tombstone = r.currentState.getStateEvents(EventType.RoomTombstone, "");
             if (tombstone && replacedRooms.has(r.roomId)) {
                 return false;
             }
@@ -3746,7 +3739,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: The contents of the given account data event.
      * @returns Rejects: with an error response.
      */
-    public async getAccountDataFromServer<T extends {[k: string]: any}>(eventType: string): Promise<T | null> {
+    public async getAccountDataFromServer<T extends { [k: string]: any }>(eventType: string): Promise<T | null> {
         if (this.isInitialSyncComplete()) {
             const event = this.store.getAccountData(eventType);
             if (!event) {
@@ -3763,7 +3756,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         try {
             return await this.http.authedRequest(Method.Get, path);
         } catch (e) {
-            if ((<MatrixError>e).data?.errcode === 'M_NOT_FOUND') {
+            if ((<MatrixError>e).data?.errcode === "M_NOT_FOUND") {
                 return null;
             }
             throw e;
@@ -3910,11 +3903,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: TODO
      * @returns Rejects: with an error response.
      */
-    public setRoomTopic(
-        roomId: string,
-        topic: string,
-        htmlTopic?: string,
-    ): Promise<ISendEventResponse> {
+    public setRoomTopic(roomId: string, topic: string, htmlTopic?: string): Promise<ISendEventResponse> {
         const content = ContentHelpers.makeTopicContent(topic, htmlTopic);
         return this.sendStateEvent(roomId, EventType.RoomTopic, content);
     }
@@ -3966,11 +3955,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to an empty object `{}`
      * @returns Rejects: with an error response.
      */
-    public setRoomAccountData(
-        roomId: string,
-        eventType: string,
-        content: Record<string, any>,
-    ): Promise<{}> {
+    public setRoomAccountData(roomId: string, eventType: string, content: Record<string, any>): Promise<{}> {
         const path = utils.encodeUri("/user/$userId/rooms/$roomId/account_data/$type", {
             $userId: this.credentials.userId!,
             $roomId: roomId,
@@ -4037,12 +4022,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return this.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, this.getUserId()!);
     }
 
-    public sendEvent(
-        roomId: string,
-        eventType: string,
-        content: IContent,
-        txnId?: string,
-    ): Promise<ISendEventResponse>;
+    public sendEvent(roomId: string, eventType: string, content: IContent, txnId?: string): Promise<ISendEventResponse>;
     public sendEvent(
         roomId: string,
         threadId: string | null,
@@ -4079,17 +4059,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             const isReply = !!content!["m.relates_to"]?.["m.in_reply_to"];
             content!["m.relates_to"] = {
                 ...content!["m.relates_to"],
-                "rel_type": THREAD_RELATION_TYPE.name,
-                "event_id": threadId,
+                rel_type: THREAD_RELATION_TYPE.name,
+                event_id: threadId,
                 // Set is_falling_back to true unless this is actually intended to be a reply
-                "is_falling_back": !isReply,
+                is_falling_back: !isReply,
             };
             const thread = this.getRoom(roomId)?.getThread(threadId);
             if (thread && !isReply) {
                 content!["m.relates_to"]["m.in_reply_to"] = {
-                    "event_id": thread.lastReply((ev: MatrixEvent) => {
-                        return ev.isRelation(THREAD_RELATION_TYPE.name) && !ev.status;
-                    })?.getId() ?? threadId,
+                    event_id:
+                        thread
+                            .lastReply((ev: MatrixEvent) => {
+                                return ev.isRelation(THREAD_RELATION_TYPE.name) && !ev.status;
+                            })
+                            ?.getId() ?? threadId,
                 };
             }
         }
@@ -4115,13 +4098,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // We always construct a MatrixEvent when sending because the store and scheduler use them.
         // We'll extract the params back out if it turns out the client has no scheduler or store.
-        const localEvent = new MatrixEvent(Object.assign(eventObject, {
-            event_id: "~" + roomId + ":" + txnId,
-            user_id: this.credentials.userId,
-            sender: this.credentials.userId,
-            room_id: roomId,
-            origin_server_ts: new Date().getTime(),
-        }));
+        const localEvent = new MatrixEvent(
+            Object.assign(eventObject, {
+                event_id: "~" + roomId + ":" + txnId,
+                user_id: this.credentials.userId,
+                sender: this.credentials.userId,
+                room_id: roomId,
+                origin_server_ts: new Date().getTime(),
+            }),
+        );
 
         const room = this.getRoom(roomId);
         const thread = threadId ? room?.getThread(threadId) : undefined;
@@ -4130,13 +4115,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         // set up re-emitter for this new event - this is normally the job of EventMapper but we don't use it here
-        this.reEmitter.reEmit(localEvent, [
-            MatrixEventEvent.Replaced,
-            MatrixEventEvent.VisibilityChange,
-        ]);
-        room?.reEmitter.reEmit(localEvent, [
-            MatrixEventEvent.BeforeRedaction,
-        ]);
+        this.reEmitter.reEmit(localEvent, [MatrixEventEvent.Replaced, MatrixEventEvent.VisibilityChange]);
+        room?.reEmitter.reEmit(localEvent, [MatrixEventEvent.BeforeRedaction]);
 
         // if this is a relation or redaction of an event
         // that hasn't been sent yet (e.g. with a local id starting with a ~)
@@ -4144,7 +4124,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // this event does get sent, we have the correct event_id
         const targetId = localEvent.getAssociatedId();
         if (targetId?.startsWith("~")) {
-            const target = room?.getPendingEvents().find(e => e.getId() === targetId);
+            const target = room?.getPendingEvents().find((e) => e.getId() === targetId);
             target?.once(MatrixEventEvent.LocalEventIdReplaced, () => {
                 localEvent.updateAssociatedId(target.getId()!);
             });
@@ -4178,63 +4158,66 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // Add an extra Promise.resolve() to turn synchronous exceptions into promise rejections,
         // so that we can handle synchronous and asynchronous exceptions with the
         // same code path.
-        return Promise.resolve().then(() => {
-            const encryptionPromise = this.encryptEventIfNeeded(event, room ?? undefined);
-            if (!encryptionPromise) return null; // doesn't need encryption
-
-            this.pendingEventEncryption.set(event.getId()!, encryptionPromise);
-            this.updatePendingEventStatus(room, event, EventStatus.ENCRYPTING);
-            return encryptionPromise.then(() => {
-                if (!this.pendingEventEncryption.has(event.getId()!)) {
-                    // cancelled via MatrixClient::cancelPendingEvent
-                    cancelled = true;
-                    return;
-                }
-                this.updatePendingEventStatus(room, event, EventStatus.SENDING);
-            });
-        }).then(() => {
-            if (cancelled) return {} as ISendEventResponse;
-            let promise: Promise<ISendEventResponse> | null = null;
-            if (this.scheduler) {
-                // if this returns a promise then the scheduler has control now and will
-                // resolve/reject when it is done. Internally, the scheduler will invoke
-                // processFn which is set to this._sendEventHttpRequest so the same code
-                // path is executed regardless.
-                promise = this.scheduler.queueEvent(event);
-                if (promise && this.scheduler.getQueueForEvent(event)!.length > 1) {
-                    // event is processed FIFO so if the length is 2 or more we know
-                    // this event is stuck behind an earlier event.
-                    this.updatePendingEventStatus(room, event, EventStatus.QUEUED);
+        return Promise.resolve()
+            .then(() => {
+                const encryptionPromise = this.encryptEventIfNeeded(event, room ?? undefined);
+                if (!encryptionPromise) return null; // doesn't need encryption
+
+                this.pendingEventEncryption.set(event.getId()!, encryptionPromise);
+                this.updatePendingEventStatus(room, event, EventStatus.ENCRYPTING);
+                return encryptionPromise.then(() => {
+                    if (!this.pendingEventEncryption.has(event.getId()!)) {
+                        // cancelled via MatrixClient::cancelPendingEvent
+                        cancelled = true;
+                        return;
+                    }
+                    this.updatePendingEventStatus(room, event, EventStatus.SENDING);
+                });
+            })
+            .then(() => {
+                if (cancelled) return {} as ISendEventResponse;
+                let promise: Promise<ISendEventResponse> | null = null;
+                if (this.scheduler) {
+                    // if this returns a promise then the scheduler has control now and will
+                    // resolve/reject when it is done. Internally, the scheduler will invoke
+                    // processFn which is set to this._sendEventHttpRequest so the same code
+                    // path is executed regardless.
+                    promise = this.scheduler.queueEvent(event);
+                    if (promise && this.scheduler.getQueueForEvent(event)!.length > 1) {
+                        // event is processed FIFO so if the length is 2 or more we know
+                        // this event is stuck behind an earlier event.
+                        this.updatePendingEventStatus(room, event, EventStatus.QUEUED);
+                    }
                 }
-            }
 
-            if (!promise) {
-                promise = this.sendEventHttpRequest(event);
-                if (room) {
-                    promise = promise.then(res => {
-                        room.updatePendingEvent(event, EventStatus.SENT, res['event_id']);
-                        return res;
-                    });
+                if (!promise) {
+                    promise = this.sendEventHttpRequest(event);
+                    if (room) {
+                        promise = promise.then((res) => {
+                            room.updatePendingEvent(event, EventStatus.SENT, res["event_id"]);
+                            return res;
+                        });
+                    }
                 }
-            }
 
-            return promise;
-        }).catch(err => {
-            logger.error("Error sending event", err.stack || err);
-            try {
-                // set the error on the event before we update the status:
-                // updating the status emits the event, so the state should be
-                // consistent at that point.
-                event.error = err;
-                this.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
-            } catch (e) {
-                logger.error("Exception in error handler!", (<Error>e).stack || err);
-            }
-            if (err instanceof MatrixError) {
-                err.event = event;
-            }
-            throw err;
-        });
+                return promise;
+            })
+            .catch((err) => {
+                logger.error("Error sending event", err.stack || err);
+                try {
+                    // set the error on the event before we update the status:
+                    // updating the status emits the event, so the state should be
+                    // consistent at that point.
+                    event.error = err;
+                    this.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
+                } catch (e) {
+                    logger.error("Exception in error handler!", (<Error>e).stack || err);
+                }
+                if (err instanceof MatrixError) {
+                    err.event = event;
+                }
+                throw err;
+            });
     }
 
     private encryptEventIfNeeded(event: MatrixEvent, room?: Room): Promise<void> | null {
@@ -4278,8 +4261,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         if (!this.crypto) {
             throw new Error(
-                "This room is configured to use encryption, but your client does " +
-                "not support encryption.",
+                "This room is configured to use encryption, but your client does " + "not support encryption.",
             );
         }
 
@@ -4341,12 +4323,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             path = utils.encodeUri("/rooms/$roomId/send/$eventType/$txnId", pathParams);
         }
 
-        return this.http.authedRequest<ISendEventResponse>(
-            Method.Put, path, undefined, event.getWireContent(),
-        ).then((res) => {
-            logger.log(`Event sent to ${event.getRoomId()} with event id ${res.event_id}`);
-            return res;
-        });
+        return this.http
+            .authedRequest<ISendEventResponse>(Method.Put, path, undefined, event.getWireContent())
+            .then((res) => {
+                logger.log(`Event sent to ${event.getRoomId()} with event id ${res.event_id}`);
+                return res;
+            });
     }
 
     /**
@@ -4382,11 +4364,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             threadId = null;
         }
         const reason = opts?.reason;
-        return this.sendCompleteEvent(roomId, threadId, {
-            type: EventType.RoomRedaction,
-            content: { reason },
-            redacts: eventId,
-        }, txnId as string);
+        return this.sendCompleteEvent(
+            roomId,
+            threadId,
+            {
+                type: EventType.RoomRedaction,
+                content: { reason },
+                redacts: eventId,
+            },
+            txnId as string,
+        );
     }
 
     /**
@@ -4394,11 +4381,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to an ISendEventResponse object
      * @returns Rejects: with an error response.
      */
-    public sendMessage(
-        roomId: string,
-        content: IContent,
-        txnId?: string,
-    ): Promise<ISendEventResponse>;
+    public sendMessage(roomId: string, content: IContent, txnId?: string): Promise<ISendEventResponse>;
     public sendMessage(
         roomId: string,
         threadId: string | null,
@@ -4424,18 +4407,18 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const makeContentExtensible = (content: IContent = {}, recurse = true): IPartialEvent<object> | undefined => {
             let newEvent: IPartialEvent<IContent> | undefined;
 
-            if (content['msgtype'] === MsgType.Text) {
-                newEvent = MessageEvent.from(content['body'], content['formatted_body']).serialize();
-            } else if (content['msgtype'] === MsgType.Emote) {
-                newEvent = EmoteEvent.from(content['body'], content['formatted_body']).serialize();
-            } else if (content['msgtype'] === MsgType.Notice) {
-                newEvent = NoticeEvent.from(content['body'], content['formatted_body']).serialize();
+            if (content["msgtype"] === MsgType.Text) {
+                newEvent = MessageEvent.from(content["body"], content["formatted_body"]).serialize();
+            } else if (content["msgtype"] === MsgType.Emote) {
+                newEvent = EmoteEvent.from(content["body"], content["formatted_body"]).serialize();
+            } else if (content["msgtype"] === MsgType.Notice) {
+                newEvent = NoticeEvent.from(content["body"], content["formatted_body"]).serialize();
             }
 
-            if (newEvent && content['m.new_content'] && recurse) {
-                const newContent = makeContentExtensible(content['m.new_content'], false);
+            if (newEvent && content["m.new_content"] && recurse) {
+                const newContent = makeContentExtensible(content["m.new_content"], false);
                 if (newContent) {
-                    newEvent.content['m.new_content'] = newContent.content;
+                    newEvent.content["m.new_content"] = newContent.content;
                 }
             }
 
@@ -4456,13 +4439,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             sendContent = result.content;
         }
 
-        return this.sendEvent(
-            roomId,
-            threadId as string | null,
-            eventType,
-            sendContent,
-            txnId,
-        );
+        return this.sendEvent(roomId, threadId as string | null, eventType, sendContent, txnId);
     }
 
     /**
@@ -4470,11 +4447,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns
      * @returns Rejects: with an error response.
      */
-    public sendTextMessage(
-        roomId: string,
-        body: string,
-        txnId?: string,
-    ): Promise<ISendEventResponse>;
+    public sendTextMessage(roomId: string, body: string, txnId?: string): Promise<ISendEventResponse>;
     public sendTextMessage(
         roomId: string,
         threadId: string | null,
@@ -4501,11 +4474,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to a ISendEventResponse object
      * @returns Rejects: with an error response.
      */
-    public sendNotice(
-        roomId: string,
-        body: string,
-        txnId?: string,
-    ): Promise<ISendEventResponse>;
+    public sendNotice(roomId: string, body: string, txnId?: string): Promise<ISendEventResponse>;
     public sendNotice(
         roomId: string,
         threadId: string | null,
@@ -4532,11 +4501,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to a ISendEventResponse object
      * @returns Rejects: with an error response.
      */
-    public sendEmoteMessage(
-        roomId: string,
-        body: string,
-        txnId?: string,
-    ): Promise<ISendEventResponse>;
+    public sendEmoteMessage(roomId: string, body: string, txnId?: string): Promise<ISendEventResponse>;
     public sendEmoteMessage(
         roomId: string,
         threadId: string | null,
@@ -4562,12 +4527,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to a ISendEventResponse object
      * @returns Rejects: with an error response.
      */
-    public sendImageMessage(
-        roomId: string,
-        url: string,
-        info?: IImageInfo,
-        text?: string,
-    ): Promise<ISendEventResponse>;
+    public sendImageMessage(roomId: string, url: string, info?: IImageInfo, text?: string): Promise<ISendEventResponse>;
     public sendImageMessage(
         roomId: string,
         threadId: string | null,
@@ -4583,7 +4543,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         text = "Image",
     ): Promise<ISendEventResponse> {
         if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
-            text = info as string || "Image";
+            text = (info as string) || "Image";
             info = url as IImageInfo;
             url = threadId as string;
             threadId = null;
@@ -4622,7 +4582,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         text = "Sticker",
     ): Promise<ISendEventResponse> {
         if (!threadId?.startsWith(EVENT_ID_PREFIX) && threadId !== null) {
-            text = info as string || "Sticker";
+            text = (info as string) || "Sticker";
             info = url as IImageInfo;
             url = threadId as string;
             threadId = null;
@@ -4640,11 +4600,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to a ISendEventResponse object
      * @returns Rejects: with an error response.
      */
-    public sendHtmlMessage(
-        roomId: string,
-        body: string,
-        htmlBody: string,
-    ): Promise<ISendEventResponse>;
+    public sendHtmlMessage(roomId: string, body: string, htmlBody: string): Promise<ISendEventResponse>;
     public sendHtmlMessage(
         roomId: string,
         threadId: string | null,
@@ -4670,11 +4626,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to a ISendEventResponse object
      * @returns Rejects: with an error response.
      */
-    public sendHtmlNotice(
-        roomId: string,
-        body: string,
-        htmlBody: string,
-    ): Promise<ISendEventResponse>;
+    public sendHtmlNotice(roomId: string, body: string, htmlBody: string): Promise<ISendEventResponse>;
     public sendHtmlNotice(
         roomId: string,
         threadId: string | null,
@@ -4700,11 +4652,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to a ISendEventResponse object
      * @returns Rejects: with an error response.
      */
-    public sendHtmlEmote(
-        roomId: string,
-        body: string,
-        htmlBody: string,
-    ): Promise<ISendEventResponse>;
+    public sendHtmlEmote(roomId: string, body: string, htmlBody: string): Promise<ISendEventResponse>;
     public sendHtmlEmote(
         roomId: string,
         threadId: string | null,
@@ -4736,12 +4684,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to an empty object `{}`
      * @returns Rejects: with an error response.
      */
-    public async sendReceipt(
-        event: MatrixEvent,
-        receiptType: ReceiptType,
-        body: any,
-        unthreaded = false,
-    ): Promise<{}> {
+    public async sendReceipt(event: MatrixEvent, receiptType: ReceiptType, body: any, unthreaded = false): Promise<{}> {
         if (this.isGuest()) {
             return Promise.resolve({}); // guests cannot send receipts so don't bother.
         }
@@ -4757,9 +4700,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             const isThread = !!event.threadRootId;
             body = {
                 ...body,
-                thread_id: isThread
-                    ? event.threadRootId
-                    : MAIN_ROOM_TIMELINE,
+                thread_id: isThread ? event.threadRootId : MAIN_ROOM_TIMELINE,
             };
         }
 
@@ -4873,12 +4814,18 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             return cachedPreview;
         }
 
-        const resp = this.http.authedRequest<IPreviewUrlResponse>(Method.Get, "/preview_url", {
-            url,
-            ts: ts.toString(),
-        }, undefined, {
-            prefix: MediaPrefix.R0,
-        });
+        const resp = this.http.authedRequest<IPreviewUrlResponse>(
+            Method.Get,
+            "/preview_url",
+            {
+                url,
+                ts: ts.toString(),
+            },
+            undefined,
+            {
+                prefix: MediaPrefix.R0,
+            },
+        );
         // TODO: Expire the URL preview cache sometimes
         this.urlPreviewCache[key] = resp;
         return resp;
@@ -4929,16 +4876,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // Work backwards first, looking at create events.
         let createEvent = currentRoom.currentState.getStateEvents(EventType.RoomCreate, "");
         while (createEvent) {
-            const predecessor = createEvent.getContent()['predecessor'];
-            if (predecessor && predecessor['room_id']) {
-                const refRoom = this.getRoom(predecessor['room_id']);
+            const predecessor = createEvent.getContent()["predecessor"];
+            if (predecessor && predecessor["room_id"]) {
+                const refRoom = this.getRoom(predecessor["room_id"]);
                 if (!refRoom) break; // end of the chain
 
                 if (verifyLinks) {
                     const tombstone = refRoom.currentState.getStateEvents(EventType.RoomTombstone, "");
 
-                    if (!tombstone
-                        || tombstone.getContent()['replacement_room'] !== refRoom.roomId) {
+                    if (!tombstone || tombstone.getContent()["replacement_room"] !== refRoom.roomId) {
                         break;
                     }
                 }
@@ -4955,16 +4901,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // Work forwards next, looking at tombstone events
         let tombstoneEvent = currentRoom.currentState.getStateEvents(EventType.RoomTombstone, "");
         while (tombstoneEvent) {
-            const refRoom = this.getRoom(tombstoneEvent.getContent()['replacement_room']);
+            const refRoom = this.getRoom(tombstoneEvent.getContent()["replacement_room"]);
             if (!refRoom) break; // end of the chain
             if (refRoom.roomId === currentRoom.roomId) break; // Tombstone is referencing it's own room
 
             if (verifyLinks) {
                 createEvent = refRoom.currentState.getStateEvents(EventType.RoomCreate, "");
-                if (!createEvent || !createEvent.getContent()['predecessor']) break;
+                if (!createEvent || !createEvent.getContent()["predecessor"]) break;
 
-                const predecessor = createEvent.getContent()['predecessor'];
-                if (predecessor['room_id'] !== currentRoom.roomId) break;
+                const predecessor = createEvent.getContent()["predecessor"];
+                if (predecessor["room_id"] !== currentRoom.roomId) break;
             }
 
             // Push to the end because we're looking forwards
@@ -5013,17 +4959,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Rejects: with an error response.
      */
     public async inviteByThreePid(roomId: string, medium: string, address: string): Promise<{}> {
-        const path = utils.encodeUri(
-            "/rooms/$roomId/invite",
-            { $roomId: roomId },
-        );
+        const path = utils.encodeUri("/rooms/$roomId/invite", { $roomId: roomId });
 
         const identityServerUrl = this.getIdentityServerUrl(true);
         if (!identityServerUrl) {
-            return Promise.reject(new MatrixError({
-                error: "No supplied identity server URL",
-                errcode: "ORG.MATRIX.JSSDK_MISSING_PARAM",
-            }));
+            return Promise.reject(
+                new MatrixError({
+                    error: "No supplied identity server URL",
+                    errcode: "ORG.MATRIX.JSSDK_MISSING_PARAM",
+                }),
+            );
         }
         const params: Record<string, string> = {
             id_server: identityServerUrl,
@@ -5031,13 +4976,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             address: address,
         };
 
-        if (
-            this.identityServer?.getAccessToken &&
-            await this.doesServerAcceptIdentityAccessToken()
-        ) {
+        if (this.identityServer?.getAccessToken && (await this.doesServerAcceptIdentityAccessToken())) {
             const identityAccessToken = await this.identityServer.getAccessToken();
             if (identityAccessToken) {
-                params['id_access_token'] = identityAccessToken;
+                params["id_access_token"] = identityAccessToken;
             }
         }
 
@@ -5084,12 +5026,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const promises: Promise<any>[] = [];
 
         const doLeave = (roomId: string): Promise<void> => {
-            return this.leave(roomId).then(() => {
-                delete populationResults[roomId];
-            }).catch((err) => {
-                // suppress error
-                populationResults[roomId] = err;
-            });
+            return this.leave(roomId)
+                .then(() => {
+                    delete populationResults[roomId];
+                })
+                .catch((err) => {
+                    // suppress error
+                    populationResults[roomId] = err;
+                });
         };
 
         for (const room of eligibleToLeave) {
@@ -5166,17 +5110,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         userId: string | undefined,
         membership: string,
         reason?: string,
-    ): Promise<{}> { // API returns an empty object
+    ): Promise<{}> {
+        // API returns an empty object
         const path = utils.encodeUri("/rooms/$room_id/$membership", {
             $room_id: roomId,
             $membership: membership,
         });
-        return this.http.authedRequest(
-            Method.Post, path, undefined, {
-                user_id: userId,  // may be undefined e.g. on leave
-                reason: reason,
-            },
-        );
+        return this.http.authedRequest(Method.Post, path, undefined, {
+            user_id: userId, // may be undefined e.g. on leave
+            reason: reason,
+        });
     }
 
     /**
@@ -5337,39 +5280,42 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const promise = new Promise<Room>((resolve, reject) => {
             // wait for a time before doing this request
             // (which may be 0 in order not to special case the code paths)
-            sleep(timeToWaitMs).then(() => {
-                return this.createMessagesRequest(
-                    room.roomId,
-                    room.oldState.paginationToken,
-                    limit,
-                    Direction.Backward,
-                );
-            }).then((res: IMessagesResponse) => {
-                const matrixEvents = res.chunk.map(this.getEventMapper());
-                if (res.state) {
-                    const stateEvents = res.state.map(this.getEventMapper());
-                    room.currentState.setUnknownStateEvents(stateEvents);
-                }
+            sleep(timeToWaitMs)
+                .then(() => {
+                    return this.createMessagesRequest(
+                        room.roomId,
+                        room.oldState.paginationToken,
+                        limit,
+                        Direction.Backward,
+                    );
+                })
+                .then((res: IMessagesResponse) => {
+                    const matrixEvents = res.chunk.map(this.getEventMapper());
+                    if (res.state) {
+                        const stateEvents = res.state.map(this.getEventMapper());
+                        room.currentState.setUnknownStateEvents(stateEvents);
+                    }
 
-                const [timelineEvents, threadedEvents] = room.partitionThreadedEvents(matrixEvents);
+                    const [timelineEvents, threadedEvents] = room.partitionThreadedEvents(matrixEvents);
 
-                this.processBeaconEvents(room, timelineEvents);
-                room.addEventsToTimeline(timelineEvents, true, room.getLiveTimeline());
-                this.processThreadEvents(room, threadedEvents, true);
+                    this.processBeaconEvents(room, timelineEvents);
+                    room.addEventsToTimeline(timelineEvents, true, room.getLiveTimeline());
+                    this.processThreadEvents(room, threadedEvents, true);
 
-                room.oldState.paginationToken = res.end ?? null;
-                if (res.chunk.length === 0) {
-                    room.oldState.paginationToken = null;
-                }
-                this.store.storeEvents(room, matrixEvents, res.end ?? null, true);
-                delete this.ongoingScrollbacks[room.roomId];
-                resolve(room);
-            }).catch((err) => {
-                this.ongoingScrollbacks[room.roomId] = {
-                    errorTs: Date.now(),
-                };
-                reject(err);
-            });
+                    room.oldState.paginationToken = res.end ?? null;
+                    if (res.chunk.length === 0) {
+                        room.oldState.paginationToken = null;
+                    }
+                    this.store.storeEvents(room, matrixEvents, res.end ?? null, true);
+                    delete this.ongoingScrollbacks[room.roomId];
+                    resolve(room);
+                })
+                .catch((err) => {
+                    this.ongoingScrollbacks[room.roomId] = {
+                        errorTs: Date.now(),
+                    };
+                    reject(err);
+                });
         });
 
         info = { promise };
@@ -5399,8 +5345,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public async getEventTimeline(timelineSet: EventTimelineSet, eventId: string): Promise<Optional<EventTimeline>> {
         // don't allow any timeline support unless it's been enabled.
         if (!this.timelineSupport) {
-            throw new Error("timeline support is disabled. Set the 'timelineSupport'" +
-                " parameter to true when creating MatrixClient to enable it.");
+            throw new Error(
+                "timeline support is disabled. Set the 'timelineSupport'" +
+                    " parameter to true when creating MatrixClient to enable it.",
+            );
         }
 
         if (!timelineSet?.room) {
@@ -5415,12 +5363,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             return this.getThreadTimeline(timelineSet, eventId);
         }
 
-        const path = utils.encodeUri(
-            "/rooms/$roomId/context/$eventId", {
-                $roomId: timelineSet.room.roomId,
-                $eventId: eventId,
-            },
-        );
+        const path = utils.encodeUri("/rooms/$roomId/context/$eventId", {
+            $roomId: timelineSet.room.roomId,
+            $eventId: eventId,
+        });
 
         let params: Record<string, string | string[]> | undefined = undefined;
         if (this.clientOpts?.lazyLoadMembers) {
@@ -5472,9 +5418,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
         // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
         // anywhere, if it was later redacted, so we just return the timeline we first thought of.
-        return timelineSet.getTimelineForEvent(eventId)
-            ?? timelineSet.room.findThreadForEvent(event)?.liveTimeline // for Threads degraded support
-            ?? timeline;
+        return (
+            timelineSet.getTimelineForEvent(eventId) ??
+            timelineSet.room.findThreadForEvent(event)?.liveTimeline ?? // for Threads degraded support
+            timeline
+        );
     }
 
     public async getThreadTimeline(timelineSet: EventTimelineSet, eventId: string): Promise<EventTimeline | undefined> {
@@ -5490,12 +5438,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             throw new Error("could not get thread timeline: not a thread timeline");
         }
 
-        const path = utils.encodeUri(
-            "/rooms/$roomId/context/$eventId", {
-                $roomId: timelineSet.room.roomId,
-                $eventId: eventId,
-            },
-        );
+        const path = utils.encodeUri("/rooms/$roomId/context/$eventId", {
+            $roomId: timelineSet.room.roomId,
+            $eventId: eventId,
+        });
 
         const params: Record<string, string | string[]> = {
             limit: "0",
@@ -5567,8 +5513,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
                 // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
                 // anywhere, if it was later redacted, so we just return the timeline we first thought of.
-                return timelineSet.getTimelineForEvent(eventId)
-                    ?? timeline;
+                return timelineSet.getTimelineForEvent(eventId) ?? timeline;
             } else {
                 // Where the event is a thread reply (not a root) and running in MSC-enabled mode the Thread timeline only
                 // functions contiguously, so we have to jump through some hoops to get our target event in it.
@@ -5640,8 +5585,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public async getLatestTimeline(timelineSet: EventTimelineSet): Promise<Optional<EventTimeline>> {
         // don't allow any timeline support unless it's been enabled.
         if (!this.timelineSupport) {
-            throw new Error("timeline support is disabled. Set the 'timelineSupport'" +
-                " parameter to true when creating MatrixClient to enable it.");
+            throw new Error(
+                "timeline support is disabled. Set the 'timelineSupport'" +
+                    " parameter to true when creating MatrixClient to enable it.",
+            );
         }
 
         if (!timelineSet.room) {
@@ -5669,14 +5616,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             );
             event = res.chunk?.[0];
         } else {
-            const messagesPath = utils.encodeUri(
-                "/rooms/$roomId/messages", {
-                    $roomId: timelineSet.room.roomId,
-                },
-            );
+            const messagesPath = utils.encodeUri("/rooms/$roomId/messages", {
+                $roomId: timelineSet.room.roomId,
+            });
 
             const params: Record<string, string | string[]> = {
-                dir: 'b',
+                dir: "b",
             };
             if (this.clientOpts?.lazyLoadMembers) {
                 params.filter = JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER);
@@ -5789,13 +5734,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         const opts = {
-            prefix: Thread.hasServerSideListSupport === FeatureSupport.Stable
-                ? "/_matrix/client/v1"
-                : "/_matrix/client/unstable/org.matrix.msc3856",
+            prefix:
+                Thread.hasServerSideListSupport === FeatureSupport.Stable
+                    ? "/_matrix/client/v1"
+                    : "/_matrix/client/unstable/org.matrix.msc3856",
         };
 
-        return this.http.authedRequest<IThreadedMessagesResponse>(Method.Get, path, params, undefined, opts)
-            .then(res => ({
+        return this.http
+            .authedRequest<IThreadedMessagesResponse>(Method.Get, path, params, undefined, opts)
+            .then((res) => ({
                 ...res,
                 chunk: res.chunk?.reverse(),
                 start: res.prev_batch,
@@ -5812,7 +5759,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *    events and we reached either end of the timeline; else true.
      */
     public paginateEventTimeline(eventTimeline: EventTimeline, opts: IPaginateOpts): Promise<boolean> {
-        const isNotifTimeline = (eventTimeline.getTimelineSet() === this.notifTimelineSet);
+        const isNotifTimeline = eventTimeline.getTimelineSet() === this.notifTimelineSet;
         const room = this.getRoom(eventTimeline.getRoomId()!);
         const threadListType = eventTimeline.getTimelineSet().threadListType;
         const thread = eventTimeline.getTimelineSet().thread;
@@ -5846,45 +5793,44 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             path = "/notifications";
             params = {
                 limit: (opts.limit ?? 30).toString(),
-                only: 'highlight',
+                only: "highlight",
             };
 
             if (token && token !== "end") {
                 params.from = token;
             }
 
-            promise = this.http.authedRequest<INotificationsResponse>(
-                Method.Get, path, params,
-            ).then(async (res) => {
-                const token = res.next_token;
-                const matrixEvents: MatrixEvent[] = [];
-
-                for (let i = 0; i < res.notifications.length; i++) {
-                    const notification = res.notifications[i];
-                    const event = this.getEventMapper()(notification.event);
-                    event.setPushActions(
-                        PushProcessor.actionListToActionsObject(notification.actions),
-                    );
-                    event.event.room_id = notification.room_id; // XXX: gutwrenching
-                    matrixEvents[i] = event;
-                }
+            promise = this.http
+                .authedRequest<INotificationsResponse>(Method.Get, path, params)
+                .then(async (res) => {
+                    const token = res.next_token;
+                    const matrixEvents: MatrixEvent[] = [];
+
+                    for (let i = 0; i < res.notifications.length; i++) {
+                        const notification = res.notifications[i];
+                        const event = this.getEventMapper()(notification.event);
+                        event.setPushActions(PushProcessor.actionListToActionsObject(notification.actions));
+                        event.event.room_id = notification.room_id; // XXX: gutwrenching
+                        matrixEvents[i] = event;
+                    }
 
-                // No need to partition events for threads here, everything lives
-                // in the notification timeline set
-                const timelineSet = eventTimeline.getTimelineSet();
-                timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
-                this.processBeaconEvents(timelineSet.room, matrixEvents);
-
-                // if we've hit the end of the timeline, we need to stop trying to
-                // paginate. We need to keep the 'forwards' token though, to make sure
-                // we can recover from gappy syncs.
-                if (backwards && !res.next_token) {
-                    eventTimeline.setPaginationToken(null, dir);
-                }
-                return Boolean(res.next_token);
-            }).finally(() => {
-                eventTimeline.paginationRequests[dir] = null;
-            });
+                    // No need to partition events for threads here, everything lives
+                    // in the notification timeline set
+                    const timelineSet = eventTimeline.getTimelineSet();
+                    timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
+                    this.processBeaconEvents(timelineSet.room, matrixEvents);
+
+                    // if we've hit the end of the timeline, we need to stop trying to
+                    // paginate. We need to keep the 'forwards' token though, to make sure
+                    // we can recover from gappy syncs.
+                    if (backwards && !res.next_token) {
+                        eventTimeline.setPaginationToken(null, dir);
+                    }
+                    return Boolean(res.next_token);
+                })
+                .finally(() => {
+                    eventTimeline.paginationRequests[dir] = null;
+                });
             eventTimeline.paginationRequests[dir] = promise;
         } else if (threadListType !== null) {
             if (!room) {
@@ -5902,30 +5848,32 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 dir,
                 threadListType,
                 eventTimeline.getFilter(),
-            ).then((res) => {
-                if (res.state) {
-                    const roomState = eventTimeline.getState(dir)!;
-                    const stateEvents = res.state.map(this.getEventMapper());
-                    roomState.setUnknownStateEvents(stateEvents);
-                }
-                const token = res.end;
-                const matrixEvents = res.chunk.map(this.getEventMapper());
-
-                const timelineSet = eventTimeline.getTimelineSet();
-                timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
-                this.processBeaconEvents(room, matrixEvents);
-                this.processThreadRoots(room, matrixEvents, backwards);
-
-                // if we've hit the end of the timeline, we need to stop trying to
-                // paginate. We need to keep the 'forwards' token though, to make sure
-                // we can recover from gappy syncs.
-                if (backwards && res.end == res.start) {
-                    eventTimeline.setPaginationToken(null, dir);
-                }
-                return res.end !== res.start;
-            }).finally(() => {
-                eventTimeline.paginationRequests[dir] = null;
-            });
+            )
+                .then((res) => {
+                    if (res.state) {
+                        const roomState = eventTimeline.getState(dir)!;
+                        const stateEvents = res.state.map(this.getEventMapper());
+                        roomState.setUnknownStateEvents(stateEvents);
+                    }
+                    const token = res.end;
+                    const matrixEvents = res.chunk.map(this.getEventMapper());
+
+                    const timelineSet = eventTimeline.getTimelineSet();
+                    timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
+                    this.processBeaconEvents(room, matrixEvents);
+                    this.processThreadRoots(room, matrixEvents, backwards);
+
+                    // if we've hit the end of the timeline, we need to stop trying to
+                    // paginate. We need to keep the 'forwards' token though, to make sure
+                    // we can recover from gappy syncs.
+                    if (backwards && res.end == res.start) {
+                        eventTimeline.setPaginationToken(null, dir);
+                    }
+                    return res.end !== res.start;
+                })
+                .finally(() => {
+                    eventTimeline.paginationRequests[dir] = null;
+                });
             eventTimeline.paginationRequests[dir] = promise;
         } else if (thread) {
             const room = this.getRoom(eventTimeline.getRoomId() ?? undefined);
@@ -5933,45 +5881,45 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 throw new Error("Unknown room " + eventTimeline.getRoomId());
             }
 
-            promise = this.fetchRelations(
-                eventTimeline.getRoomId() ?? "",
-                thread.id,
-                THREAD_RELATION_TYPE.name,
-                null,
-                { dir, limit: opts.limit, from: token ?? undefined },
-            ).then(async (res) => {
-                const mapper = this.getEventMapper();
-                const matrixEvents = res.chunk.map(mapper);
-
-                // Process latest events first
-                for (const event of matrixEvents.slice().reverse()) {
-                    await thread?.processEvent(event);
-                    const sender = event.getSender()!;
-                    if (!backwards || thread?.getEventReadUpTo(sender) === null) {
-                        room.addLocalEchoReceipt(sender, event, ReceiptType.Read);
+            promise = this.fetchRelations(eventTimeline.getRoomId() ?? "", thread.id, THREAD_RELATION_TYPE.name, null, {
+                dir,
+                limit: opts.limit,
+                from: token ?? undefined,
+            })
+                .then(async (res) => {
+                    const mapper = this.getEventMapper();
+                    const matrixEvents = res.chunk.map(mapper);
+
+                    // Process latest events first
+                    for (const event of matrixEvents.slice().reverse()) {
+                        await thread?.processEvent(event);
+                        const sender = event.getSender()!;
+                        if (!backwards || thread?.getEventReadUpTo(sender) === null) {
+                            room.addLocalEchoReceipt(sender, event, ReceiptType.Read);
+                        }
                     }
-                }
 
-                const newToken = res.next_batch;
+                    const newToken = res.next_batch;
 
-                const timelineSet = eventTimeline.getTimelineSet();
-                timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, newToken ?? null);
-                if (!newToken && backwards) {
-                    const originalEvent = await this.fetchRoomEvent(eventTimeline.getRoomId() ?? "", thread.id);
-                    timelineSet.addEventsToTimeline([mapper(originalEvent)], true, eventTimeline, null);
-                }
-                this.processBeaconEvents(timelineSet.room, matrixEvents);
+                    const timelineSet = eventTimeline.getTimelineSet();
+                    timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, newToken ?? null);
+                    if (!newToken && backwards) {
+                        const originalEvent = await this.fetchRoomEvent(eventTimeline.getRoomId() ?? "", thread.id);
+                        timelineSet.addEventsToTimeline([mapper(originalEvent)], true, eventTimeline, null);
+                    }
+                    this.processBeaconEvents(timelineSet.room, matrixEvents);
 
-                // if we've hit the end of the timeline, we need to stop trying to
-                // paginate. We need to keep the 'forwards' token though, to make sure
-                // we can recover from gappy syncs.
-                if (backwards && !newToken) {
-                    eventTimeline.setPaginationToken(null, dir);
-                }
-                return Boolean(newToken);
-            }).finally(() => {
-                eventTimeline.paginationRequests[dir] = null;
-            });
+                    // if we've hit the end of the timeline, we need to stop trying to
+                    // paginate. We need to keep the 'forwards' token though, to make sure
+                    // we can recover from gappy syncs.
+                    if (backwards && !newToken) {
+                        eventTimeline.setPaginationToken(null, dir);
+                    }
+                    return Boolean(newToken);
+                })
+                .finally(() => {
+                    eventTimeline.paginationRequests[dir] = null;
+                });
             eventTimeline.paginationRequests[dir] = promise;
         } else {
             if (!room) {
@@ -5984,35 +5932,39 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 opts.limit,
                 dir,
                 eventTimeline.getFilter(),
-            ).then((res) => {
-                if (res.state) {
-                    const roomState = eventTimeline.getState(dir)!;
-                    const stateEvents = res.state.map(this.getEventMapper());
-                    roomState.setUnknownStateEvents(stateEvents);
-                }
-                const token = res.end;
-                const matrixEvents = res.chunk.map(this.getEventMapper());
-
-                const timelineSet = eventTimeline.getTimelineSet();
-                const [timelineEvents] = room.partitionThreadedEvents(matrixEvents);
-                timelineSet.addEventsToTimeline(timelineEvents, backwards, eventTimeline, token);
-                this.processBeaconEvents(room, timelineEvents);
-                this.processThreadRoots(room,
-                    timelineEvents.filter(it => it.isRelation(THREAD_RELATION_TYPE.name)),
-                    false);
-
-                const atEnd = res.end === undefined || res.end === res.start;
-
-                // if we've hit the end of the timeline, we need to stop trying to
-                // paginate. We need to keep the 'forwards' token though, to make sure
-                // we can recover from gappy syncs.
-                if (backwards && atEnd) {
-                    eventTimeline.setPaginationToken(null, dir);
-                }
-                return !atEnd;
-            }).finally(() => {
-                eventTimeline.paginationRequests[dir] = null;
-            });
+            )
+                .then((res) => {
+                    if (res.state) {
+                        const roomState = eventTimeline.getState(dir)!;
+                        const stateEvents = res.state.map(this.getEventMapper());
+                        roomState.setUnknownStateEvents(stateEvents);
+                    }
+                    const token = res.end;
+                    const matrixEvents = res.chunk.map(this.getEventMapper());
+
+                    const timelineSet = eventTimeline.getTimelineSet();
+                    const [timelineEvents] = room.partitionThreadedEvents(matrixEvents);
+                    timelineSet.addEventsToTimeline(timelineEvents, backwards, eventTimeline, token);
+                    this.processBeaconEvents(room, timelineEvents);
+                    this.processThreadRoots(
+                        room,
+                        timelineEvents.filter((it) => it.isRelation(THREAD_RELATION_TYPE.name)),
+                        false,
+                    );
+
+                    const atEnd = res.end === undefined || res.end === res.start;
+
+                    // if we've hit the end of the timeline, we need to stop trying to
+                    // paginate. We need to keep the 'forwards' token though, to make sure
+                    // we can recover from gappy syncs.
+                    if (backwards && atEnd) {
+                        eventTimeline.setPaginationToken(null, dir);
+                    }
+                    return !atEnd;
+                })
+                .finally(() => {
+                    eventTimeline.paginationRequests[dir] = null;
+                });
             eventTimeline.paginationRequests[dir] = promise;
         }
 
@@ -6038,7 +5990,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // know about /notifications, so we have no choice but to start paginating
         // from the current point in time.  This may well overlap with historical
         // notifs which are then inserted into the timeline by /sync responses.
-        this.notifTimelineSet.resetLiveTimeline('end');
+        this.notifTimelineSet.resetLiveTimeline("end");
 
         // we could try to paginate a single event at this point in order to get
         // a more valid pagination token, but it just ends up with an out of order
@@ -6083,15 +6035,25 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Rejects: with an error response.
      */
     public setGuestAccess(roomId: string, opts: IGuestAccessOpts): Promise<void> {
-        const writePromise = this.sendStateEvent(roomId, EventType.RoomGuestAccess, {
-            guest_access: opts.allowJoin ? "can_join" : "forbidden",
-        }, "");
+        const writePromise = this.sendStateEvent(
+            roomId,
+            EventType.RoomGuestAccess,
+            {
+                guest_access: opts.allowJoin ? "can_join" : "forbidden",
+            },
+            "",
+        );
 
         let readPromise: Promise<any> = Promise.resolve<any>(undefined);
         if (opts.allowRead) {
-            readPromise = this.sendStateEvent(roomId, EventType.RoomHistoryVisibility, {
-                history_visibility: "world_readable",
-            }, "");
+            readPromise = this.sendStateEvent(
+                roomId,
+                EventType.RoomHistoryVisibility,
+                {
+                    history_visibility: "world_readable",
+                },
+                "",
+            );
         }
 
         return Promise.all([readPromise, writePromise]).then(); // .then() to hide results for contract
@@ -6117,15 +6079,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink?: string,
     ): Promise<IRequestTokenResponse> {
-        return this.requestTokenFromEndpoint(
-            "/register/email/requestToken",
-            {
-                email: email,
-                client_secret: clientSecret,
-                send_attempt: sendAttempt,
-                next_link: nextLink,
-            },
-        );
+        return this.requestTokenFromEndpoint("/register/email/requestToken", {
+            email: email,
+            client_secret: clientSecret,
+            send_attempt: sendAttempt,
+            next_link: nextLink,
+        });
     }
 
     /**
@@ -6149,16 +6108,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink?: string,
     ): Promise<IRequestMsisdnTokenResponse> {
-        return this.requestTokenFromEndpoint(
-            "/register/msisdn/requestToken",
-            {
-                country: phoneCountry,
-                phone_number: phoneNumber,
-                client_secret: clientSecret,
-                send_attempt: sendAttempt,
-                next_link: nextLink,
-            },
-        );
+        return this.requestTokenFromEndpoint("/register/msisdn/requestToken", {
+            country: phoneCountry,
+            phone_number: phoneNumber,
+            client_secret: clientSecret,
+            send_attempt: sendAttempt,
+            next_link: nextLink,
+        });
     }
 
     /**
@@ -6184,15 +6140,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink?: string,
     ): Promise<IRequestTokenResponse> {
-        return this.requestTokenFromEndpoint(
-            "/account/3pid/email/requestToken",
-            {
-                email: email,
-                client_secret: clientSecret,
-                send_attempt: sendAttempt,
-                next_link: nextLink,
-            },
-        );
+        return this.requestTokenFromEndpoint("/account/3pid/email/requestToken", {
+            email: email,
+            client_secret: clientSecret,
+            send_attempt: sendAttempt,
+            next_link: nextLink,
+        });
     }
 
     /**
@@ -6216,16 +6169,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink?: string,
     ): Promise<IRequestMsisdnTokenResponse> {
-        return this.requestTokenFromEndpoint(
-            "/account/3pid/msisdn/requestToken",
-            {
-                country: phoneCountry,
-                phone_number: phoneNumber,
-                client_secret: clientSecret,
-                send_attempt: sendAttempt,
-                next_link: nextLink,
-            },
-        );
+        return this.requestTokenFromEndpoint("/account/3pid/msisdn/requestToken", {
+            country: phoneCountry,
+            phone_number: phoneNumber,
+            client_secret: clientSecret,
+            send_attempt: sendAttempt,
+            next_link: nextLink,
+        });
     }
 
     /**
@@ -6252,15 +6202,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink?: string,
     ): Promise<IRequestTokenResponse> {
-        return this.requestTokenFromEndpoint(
-            "/account/password/email/requestToken",
-            {
-                email: email,
-                client_secret: clientSecret,
-                send_attempt: sendAttempt,
-                next_link: nextLink,
-            },
-        );
+        return this.requestTokenFromEndpoint("/account/password/email/requestToken", {
+            email: email,
+            client_secret: clientSecret,
+            send_attempt: sendAttempt,
+            next_link: nextLink,
+        });
     }
 
     /**
@@ -6283,16 +6230,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink: string,
     ): Promise<IRequestMsisdnTokenResponse> {
-        return this.requestTokenFromEndpoint(
-            "/account/password/msisdn/requestToken",
-            {
-                country: phoneCountry,
-                phone_number: phoneNumber,
-                client_secret: clientSecret,
-                send_attempt: sendAttempt,
-                next_link: nextLink,
-            },
-        );
+        return this.requestTokenFromEndpoint("/account/password/msisdn/requestToken", {
+            country: phoneCountry,
+            phone_number: phoneNumber,
+            client_secret: clientSecret,
+            send_attempt: sendAttempt,
+            next_link: nextLink,
+        });
     }
 
     /**
@@ -6311,11 +6255,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // If the HS supports separate add and bind, then requestToken endpoints
         // don't need an IS as they are all validated by the HS directly.
-        if (!await this.doesServerSupportSeparateAddAndBind() && this.idBaseUrl) {
+        if (!(await this.doesServerSupportSeparateAddAndBind()) && this.idBaseUrl) {
             const idServerUrl = new URL(this.idBaseUrl);
             postParams.id_server = idServerUrl.host;
 
-            if (this.identityServer?.getAccessToken && await this.doesServerAcceptIdentityAccessToken()) {
+            if (this.identityServer?.getAccessToken && (await this.doesServerAcceptIdentityAccessToken())) {
                 const identityAccessToken = await this.identityServer.getAccessToken();
                 if (identityAccessToken) {
                     postParams.id_access_token = identityAccessToken;
@@ -6336,11 +6280,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // There can be only room-kind push rule per room
         // and its id is the room id.
         if (this.pushRules) {
-            return this.pushRules[scope]?.room?.find(rule => rule.rule_id === roomId);
+            return this.pushRules[scope]?.room?.find((rule) => rule.rule_id === roomId);
         } else {
-            throw new Error(
-                "SyncApi.sync() must be done before accessing to push rules.",
-            );
+            throw new Error("SyncApi.sync() must be done before accessing to push rules.");
         }
     }
 
@@ -6377,17 +6319,21 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                 // Remove the existing one before setting the mute push rule
                 // This is a workaround to SYN-590 (Push rule update fails)
                 const deferred = utils.defer();
-                this.deletePushRule(scope, PushRuleKind.RoomSpecific, roomPushRule.rule_id).then(() => {
-                    this.addPushRule(scope, PushRuleKind.RoomSpecific, roomId, {
-                        actions: [PushRuleActionName.DontNotify],
-                    }).then(() => {
-                        deferred.resolve();
-                    }).catch((err) => {
+                this.deletePushRule(scope, PushRuleKind.RoomSpecific, roomPushRule.rule_id)
+                    .then(() => {
+                        this.addPushRule(scope, PushRuleKind.RoomSpecific, roomId, {
+                            actions: [PushRuleActionName.DontNotify],
+                        })
+                            .then(() => {
+                                deferred.resolve();
+                            })
+                            .catch((err) => {
+                                deferred.reject(err);
+                            });
+                    })
+                    .catch((err) => {
                         deferred.reject(err);
                     });
-                }).catch((err) => {
-                    deferred.reject(err);
-                });
 
                 promise = deferred.promise;
             }
@@ -6396,23 +6342,29 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         if (promise) {
             return new Promise<void>((resolve, reject) => {
                 // Update this.pushRules when the operation completes
-                promise!.then(() => {
-                    this.getPushRules().then((result) => {
-                        this.pushRules = result;
-                        resolve();
-                    }).catch((err) => {
-                        reject(err);
-                    });
-                }).catch((err: Error) => {
-                    // Update it even if the previous operation fails. This can help the
-                    // app to recover when push settings has been modified from another client
-                    this.getPushRules().then((result) => {
-                        this.pushRules = result;
-                        reject(err);
-                    }).catch((err2) => {
-                        reject(err);
+                promise!
+                    .then(() => {
+                        this.getPushRules()
+                            .then((result) => {
+                                this.pushRules = result;
+                                resolve();
+                            })
+                            .catch((err) => {
+                                reject(err);
+                            });
+                    })
+                    .catch((err: Error) => {
+                        // Update it even if the previous operation fails. This can help the
+                        // app to recover when push settings has been modified from another client
+                        this.getPushRules()
+                            .then((result) => {
+                                this.pushRules = result;
+                                reject(err);
+                            })
+                            .catch((err2) => {
+                                reject(err);
+                            });
                     });
-                });
             });
         }
     }
@@ -6422,7 +6374,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             search_term: opts.query,
         };
 
-        if ('keys' in opts) {
+        if ("keys" in opts) {
             roomEvents.keys = opts.keys;
         }
 
@@ -6474,7 +6426,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             highlights: [],
         };
 
-        return this.search({ body: body }).then(res => this.processRoomEventsSearch(searchResults, res));
+        return this.search({ body: body }).then((res) => this.processRoomEventsSearch(searchResults, res));
     }
 
     /**
@@ -6503,7 +6455,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         };
 
         const promise = this.search(searchOpts, searchResults.abortSignal)
-            .then(res => this.processRoomEventsSearch(searchResults, res))
+            .then((res) => this.processRoomEventsSearch(searchResults, res))
             .finally(() => {
                 searchResults.pendingRequest = undefined;
             });
@@ -6572,12 +6524,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         this.syncLeftRoomsPromise = syncApi.syncLeftRooms();
 
         // cleanup locks
-        this.syncLeftRoomsPromise.then(() => {
-            logger.log("Marking success of sync left room request");
-            this.syncedLeftRooms = true; // flip the bit on success
-        }).finally(() => {
-            this.syncLeftRoomsPromise = undefined; // cleanup ongoing request state
-        });
+        this.syncLeftRoomsPromise
+            .then(() => {
+                logger.log("Marking success of sync left room request");
+                this.syncedLeftRooms = true; // flip the bit on success
+            })
+            .finally(() => {
+                this.syncLeftRoomsPromise = undefined; // cleanup ongoing request state
+            });
 
         return this.syncLeftRoomsPromise;
     }
@@ -6592,13 +6546,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const path = utils.encodeUri("/user/$userId/filter", {
             $userId: this.credentials.userId!,
         });
-        return this.http.authedRequest<IFilterResponse>(Method.Post, path, undefined, content)
-            .then((response) => {
-                // persist the filter
-                const filter = Filter.fromJson(this.credentials.userId, response.filter_id, content);
-                this.store.storeFilter(filter);
-                return filter;
-            });
+        return this.http.authedRequest<IFilterResponse>(Method.Post, path, undefined, content).then((response) => {
+            // persist the filter
+            const filter = Filter.fromJson(this.credentials.userId, response.filter_id, content);
+            this.store.storeFilter(filter);
+            return filter;
+        });
     }
 
     /**
@@ -6758,7 +6711,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                     };
                     this.turnServers = [servers];
                     // The TTL is in seconds but we work in ms
-                    this.turnServersExpiry = Date.now() + (res.ttl * 1000);
+                    this.turnServersExpiry = Date.now() + res.ttl * 1000;
                     credentialsGood = true;
                     this.emit(ClientEvent.TurnServers, this.turnServers);
                 }
@@ -6809,13 +6762,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns true if the user appears to be a Synapse administrator.
      */
     public isSynapseAdministrator(): Promise<boolean> {
-        const path = utils.encodeUri(
-            "/_synapse/admin/v1/users/$userId/admin",
-            { $userId: this.getUserId()! },
-        );
-        return this.http.authedRequest<{ admin: boolean }>(
-            Method.Get, path, undefined, undefined, { prefix: '' },
-        ).then(r => r.admin); // pull out the specific boolean we want
+        const path = utils.encodeUri("/_synapse/admin/v1/users/$userId/admin", { $userId: this.getUserId()! });
+        return this.http
+            .authedRequest<{ admin: boolean }>(Method.Get, path, undefined, undefined, { prefix: "" })
+            .then((r) => r.admin); // pull out the specific boolean we want
     }
 
     /**
@@ -6826,11 +6776,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns the whois response - see Synapse docs for information.
      */
     public whoisSynapseUser(userId: string): Promise<ISynapseAdminWhoisResponse> {
-        const path = utils.encodeUri(
-            "/_synapse/admin/v1/whois/$userId",
-            { $userId: userId },
-        );
-        return this.http.authedRequest(Method.Get, path, undefined, undefined, { prefix: '' });
+        const path = utils.encodeUri("/_synapse/admin/v1/whois/$userId", { $userId: userId });
+        return this.http.authedRequest(Method.Get, path, undefined, undefined, { prefix: "" });
     }
 
     /**
@@ -6840,11 +6787,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns the deactivate response - see Synapse docs for information.
      */
     public deactivateSynapseUser(userId: string): Promise<ISynapseAdminDeactivateResponse> {
-        const path = utils.encodeUri(
-            "/_synapse/admin/v1/deactivate/$userId",
-            { $userId: userId },
-        );
-        return this.http.authedRequest(Method.Post, path, undefined, undefined, { prefix: '' });
+        const path = utils.encodeUri("/_synapse/admin/v1/deactivate/$userId", { $userId: userId });
+        return this.http.authedRequest(Method.Post, path, undefined, undefined, { prefix: "" });
     }
 
     private async fetchClientWellKnown(): Promise<void> {
@@ -6873,7 +6817,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param opts - the complete set of client options
      * @returns for store operation
      */
-    public storeClientOptions(): Promise<void> { // XXX: Intended private, used in code
+    public storeClientOptions(): Promise<void> {
+        // XXX: Intended private, used in code
         const primTypes = ["boolean", "string", "number"];
         const serializableOpts = Object.entries(this.clientOpts!)
             .filter(([key, value]) => {
@@ -6892,23 +6837,23 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves to a set of rooms
      * @returns Rejects: with an error response.
      */
-    public async _unstable_getSharedRooms(userId: string): Promise<string[]> { // eslint-disable-line
+    public async _unstable_getSharedRooms(userId: string): Promise<string[]> {
+        // eslint-disable-line
         const sharedRoomsSupport = await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666");
         const mutualRoomsSupport = await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666.mutual_rooms");
 
         if (!sharedRoomsSupport && !mutualRoomsSupport) {
-            throw Error('Server does not support mutual_rooms API');
+            throw Error("Server does not support mutual_rooms API");
         }
 
         const path = utils.encodeUri(
-            `/uk.half-shot.msc2666/user/${mutualRoomsSupport ? 'mutual_rooms' : 'shared_rooms'}/$userId`,
+            `/uk.half-shot.msc2666/user/${mutualRoomsSupport ? "mutual_rooms" : "shared_rooms"}/$userId`,
             { $userId: userId },
         );
 
-        const res = await this.http.authedRequest<{ joined: string[] }>(
-            Method.Get, path, undefined, undefined,
-            { prefix: ClientPrefix.Unstable },
-        );
+        const res = await this.http.authedRequest<{ joined: string[] }>(Method.Get, path, undefined, undefined, {
+            prefix: ClientPrefix.Unstable,
+        });
         return res.joined;
     }
 
@@ -6922,19 +6867,22 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             return this.serverVersionsPromise;
         }
 
-        this.serverVersionsPromise = this.http.request<IServerVersions>(
-            Method.Get, "/_matrix/client/versions",
-            undefined, // queryParams
-            undefined, // data
-            {
-                prefix: '',
-            },
-        ).catch(e => {
-            // Need to unset this if it fails, otherwise we'll never retry
-            this.serverVersionsPromise = undefined;
-            // but rethrow the exception to anything that was waiting
-            throw e;
-        });
+        this.serverVersionsPromise = this.http
+            .request<IServerVersions>(
+                Method.Get,
+                "/_matrix/client/versions",
+                undefined, // queryParams
+                undefined, // data
+                {
+                    prefix: "",
+                },
+            )
+            .catch((e) => {
+                // Need to unset this if it fails, otherwise we'll never retry
+                this.serverVersionsPromise = undefined;
+                // but rethrow the exception to anything that was waiting
+                throw e;
+            });
 
         const serverVersions = await this.serverVersionsPromise;
         this.canSupport = await buildFeatureSupportMap(serverVersions);
@@ -6967,8 +6915,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const versions = response["versions"];
         const unstableFeatures = response["unstable_features"];
 
-        return (versions && versions.includes("r0.5.0"))
-            || (unstableFeatures && unstableFeatures["m.lazy_load_members"]);
+        return (
+            (versions && versions.includes("r0.5.0")) || (unstableFeatures && unstableFeatures["m.lazy_load_members"])
+        );
     }
 
     /**
@@ -7008,8 +6957,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         const versions = response["versions"];
         const unstableFeatures = response["unstable_features"];
-        return (versions && versions.includes("r0.6.0"))
-            || (unstableFeatures && unstableFeatures["m.id_access_token"]);
+        return (versions && versions.includes("r0.6.0")) || (unstableFeatures && unstableFeatures["m.id_access_token"]);
     }
 
     /**
@@ -7075,18 +7023,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
 
         try {
-            const [
-                threadUnstable, threadStable,
-                listUnstable, listStable,
-                fwdPaginationUnstable, fwdPaginationStable,
-            ] = await Promise.all([
-                this.doesServerSupportUnstableFeature("org.matrix.msc3440"),
-                this.doesServerSupportUnstableFeature("org.matrix.msc3440.stable"),
-                this.doesServerSupportUnstableFeature("org.matrix.msc3856"),
-                this.doesServerSupportUnstableFeature("org.matrix.msc3856.stable"),
-                this.doesServerSupportUnstableFeature("org.matrix.msc3715"),
-                this.doesServerSupportUnstableFeature("org.matrix.msc3715.stable"),
-            ]);
+            const [threadUnstable, threadStable, listUnstable, listStable, fwdPaginationUnstable, fwdPaginationStable] =
+                await Promise.all([
+                    this.doesServerSupportUnstableFeature("org.matrix.msc3440"),
+                    this.doesServerSupportUnstableFeature("org.matrix.msc3440.stable"),
+                    this.doesServerSupportUnstableFeature("org.matrix.msc3856"),
+                    this.doesServerSupportUnstableFeature("org.matrix.msc3856.stable"),
+                    this.doesServerSupportUnstableFeature("org.matrix.msc3715"),
+                    this.doesServerSupportUnstableFeature("org.matrix.msc3715.stable"),
+                ]);
 
             return {
                 threads: determineFeatureSupport(threadStable, threadUnstable),
@@ -7174,14 +7119,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         if (fetchedEventType === EventType.RoomMessageEncrypted) {
             const allEvents = originalEvent ? events.concat(originalEvent) : events;
-            await Promise.all(allEvents.map(e => this.decryptEventIfNeeded(e)));
+            await Promise.all(allEvents.map((e) => this.decryptEventIfNeeded(e)));
             if (eventType !== null) {
-                events = events.filter(e => e.getType() === eventType);
+                events = events.filter((e) => e.getType() === eventType);
             }
         }
 
         if (originalEvent && relationType === RelationType.Replace) {
-            events = events.filter(e => e.getSender() === originalEvent.getSender());
+            events = events.filter((e) => e.getSender() === originalEvent.getSender());
         }
         return {
             originalEvent: originalEvent ?? null,
@@ -7233,7 +7178,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             case SERVICE_TYPES.IM:
                 return this.http.getUrl("/terms", undefined, "/_matrix/integrations/v1", baseUrl);
             default:
-                throw new Error('Unsupported service type');
+                throw new Error("Unsupported service type");
         }
     }
 
@@ -7295,7 +7240,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns a new, unique, transaction id
      */
     public makeTxnId(): string {
-        return "m" + new Date().getTime() + "." + (this.txnCtr++);
+        return "m" + new Date().getTime() + "." + this.txnCtr++;
     }
 
     /**
@@ -7305,16 +7250,17 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to boolean of whether the username is available.
      */
     public isUsernameAvailable(username: string): Promise<boolean> {
-        return this.http.authedRequest<{ available: true }>(
-            Method.Get, '/register/available', { username },
-        ).then((response) => {
-            return response.available;
-        }).catch(response => {
-            if (response.errcode === "M_USER_IN_USE") {
-                return false;
-            }
-            return Promise.reject(response);
-        });
+        return this.http
+            .authedRequest<{ available: true }>(Method.Get, "/register/available", { username })
+            .then((response) => {
+                return response.available;
+            })
+            .catch((response) => {
+                if (response.errcode === "M_USER_IN_USE") {
+                    return false;
+                }
+                return Promise.reject(response);
+            });
     }
 
     /**
@@ -7328,8 +7274,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         username: string,
         password: string,
         sessionId: string | null,
-        auth: { session?: string, type: string },
-        bindThreepids?: boolean | null | { email?: boolean, msisdn?: boolean },
+        auth: { session?: string; type: string },
+        bindThreepids?: boolean | null | { email?: boolean; msisdn?: boolean },
         guestAccessToken?: string,
         inhibitLogin?: boolean,
     ): Promise<IAuthData> {
@@ -7399,7 +7345,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *                   `{ user_id, device_id, access_token, home_server }`
      * @returns Rejects: with an error response.
      */
-    public registerGuest({ body }: { body?: any } = {}): Promise<any> { // TODO: Types
+    public registerGuest({ body }: { body?: any } = {}): Promise<any> {
+        // TODO: Types
         return this.registerRequest(body || {}, "guest");
     }
 
@@ -7454,7 +7401,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: TODO
      * @returns Rejects: with an error response.
      */
-    public login(loginType: string, data: any): Promise<any> { // TODO: Types
+    public login(loginType: string, data: any): Promise<any> {
+        // TODO: Types
         const loginData = {
             type: loginType,
         };
@@ -7462,25 +7410,28 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         // merge data into loginData
         Object.assign(loginData, data);
 
-        return this.http.authedRequest<{
-            access_token?: string;
-            user_id?: string;
-        }>(Method.Post, "/login", undefined, loginData).then(response => {
-            if (response.access_token && response.user_id) {
-                this.http.opts.accessToken = response.access_token;
-                this.credentials = {
-                    userId: response.user_id,
-                };
-            }
-            return response;
-        });
+        return this.http
+            .authedRequest<{
+                access_token?: string;
+                user_id?: string;
+            }>(Method.Post, "/login", undefined, loginData)
+            .then((response) => {
+                if (response.access_token && response.user_id) {
+                    this.http.opts.accessToken = response.access_token;
+                    this.credentials = {
+                        userId: response.user_id,
+                    };
+                }
+                return response;
+            });
     }
 
     /**
      * @returns Promise which resolves: TODO
      * @returns Rejects: with an error response.
      */
-    public loginWithPassword(user: string, password: string): Promise<any> { // TODO: Types
+    public loginWithPassword(user: string, password: string): Promise<any> {
+        // TODO: Types
         return this.login("m.login.password", {
             user: user,
             password: password,
@@ -7492,7 +7443,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: TODO
      * @returns Rejects: with an error response.
      */
-    public loginWithSAML2(relayState: string): Promise<any> { // TODO: Types
+    public loginWithSAML2(relayState: string): Promise<any> {
+        // TODO: Types
         return this.login("m.login.saml2", {
             relay_state: relayState,
         });
@@ -7516,12 +7468,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param action - the SSO flow to indicate to the IdP, optional.
      * @returns The HS URL to hit to begin the SSO login process.
      */
-    public getSsoLoginUrl(
-        redirectUrl: string,
-        loginType = "sso",
-        idpId?: string,
-        action?: SSOAction,
-    ): string {
+    public getSsoLoginUrl(redirectUrl: string, loginType = "sso", idpId?: string, action?: SSOAction): string {
         let url = "/login/" + loginType + "/redirect";
         if (idpId) {
             url += "/" + idpId;
@@ -7540,7 +7487,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: TODO
      * @returns Rejects: with an error response.
      */
-    public loginWithToken(token: string): Promise<any> { // TODO: Types
+    public loginWithToken(token: string): Promise<any> {
+        // TODO: Types
         return this.login("m.login.token", {
             token: token,
         });
@@ -7558,12 +7506,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public async logout(stopClient = false): Promise<{}> {
         if (this.crypto?.backupManager?.getKeyBackupEnabled()) {
             try {
-                while (await this.crypto.backupManager.backupPendingKeys(200) > 0);
+                while ((await this.crypto.backupManager.backupPendingKeys(200)) > 0);
             } catch (err) {
-                logger.error(
-                    "Key backup request failed when logging out. Some keys may be missing from backup",
-                    err,
-                );
+                logger.error("Key backup request failed when logging out. Some keys may be missing from backup", err);
             }
         }
 
@@ -7572,7 +7517,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             this.http.abort();
         }
 
-        return this.http.authedRequest(Method.Post, '/logout');
+        return this.http.authedRequest(Method.Post, "/logout");
     }
 
     /**
@@ -7596,7 +7541,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             body.erase = erase;
         }
 
-        return this.http.authedRequest(Method.Post, '/account/deactivate', undefined, body);
+        return this.http.authedRequest(Method.Post, "/account/deactivate", undefined, body);
     }
 
     /**
@@ -7632,9 +7577,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             $loginType: loginType,
         });
 
-        return this.http.getUrl(path, {
-            session: authSessionId,
-        }, ClientPrefix.R0).href;
+        return this.http.getUrl(
+            path,
+            {
+                session: authSessionId,
+            },
+            ClientPrefix.R0,
+        ).href;
     }
 
     /**
@@ -7643,16 +7592,16 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: `{room_id: {string}}`
      * @returns Rejects: with an error response.
      */
-    public async createRoom(options: ICreateRoomOpts): Promise<{ room_id: string }> { // eslint-disable-line camelcase
+    public async createRoom(options: ICreateRoomOpts): Promise<{ room_id: string }> {
+        // eslint-disable-line camelcase
         // some valid options include: room_alias_name, visibility, invite
 
         // inject the id_access_token if inviting 3rd party addresses
-        const invitesNeedingToken = (options.invite_3pid || [])
-            .filter(i => !i.id_access_token);
+        const invitesNeedingToken = (options.invite_3pid || []).filter((i) => !i.id_access_token);
         if (
             invitesNeedingToken.length > 0 &&
             this.identityServer?.getAccessToken &&
-            await this.doesServerAcceptIdentityAccessToken()
+            (await this.doesServerAcceptIdentityAccessToken())
         ) {
             const identityAccessToken = await this.identityServer.getAccessToken();
             if (identityAccessToken) {
@@ -7672,7 +7621,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param relationType - the rel_type of the relations requested
      * @param eventType - the event type of the relations requested
      * @param opts - options with optional values for the request.
-    * @returns the response, with chunk, prev_batch and, next_batch.
+     * @returns the response, with chunk, prev_batch and, next_batch.
      */
     public fetchRelations(
         roomId: string,
@@ -7699,18 +7648,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             eventType = null;
         }
 
-        const path = utils.encodeUri(
-            templatedUrl + "?" + queryString, {
-                $roomId: roomId,
-                $eventId: eventId,
-                $relationType: relationType!,
-                $eventType: eventType!,
-            });
-        return this.http.authedRequest(
-            Method.Get, path, undefined, undefined, {
-                prefix: ClientPrefix.V1,
-            },
-        );
+        const path = utils.encodeUri(templatedUrl + "?" + queryString, {
+            $roomId: roomId,
+            $eventId: eventId,
+            $relationType: relationType!,
+            $eventType: eventType!,
+        });
+        return this.http.authedRequest(Method.Get, path, undefined, undefined, {
+            prefix: ClientPrefix.V1,
+        });
     }
 
     /**
@@ -7729,12 +7675,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Rejects: with an error response.
      */
     public fetchRoomEvent(roomId: string, eventId: string): Promise<Partial<IEvent>> {
-        const path = utils.encodeUri(
-            "/rooms/$roomId/event/$eventId", {
-                $roomId: roomId,
-                $eventId: eventId,
-            },
-        );
+        const path = utils.encodeUri("/rooms/$roomId/event/$eventId", {
+            $roomId: roomId,
+            $eventId: eventId,
+        });
         return this.http.authedRequest(Method.Get, path);
     }
 
@@ -7764,8 +7708,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         const queryString = utils.encodeParams(queryParams);
 
-        const path = utils.encodeUri("/rooms/$roomId/members?" + queryString,
-            { $roomId: roomId });
+        const path = utils.encodeUri("/rooms/$roomId/members?" + queryString, { $roomId: roomId });
         return this.http.authedRequest(Method.Get, path);
     }
 
@@ -7775,10 +7718,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: Object with key 'replacement_room'
      * @returns Rejects: with an error response.
      */
-    public upgradeRoom(
-        roomId: string,
-        newVersion: string,
-    ): Promise<{ replacement_room: string }> { // eslint-disable-line camelcase
+    public upgradeRoom(roomId: string, newVersion: string): Promise<{ replacement_room: string }> {
+        // eslint-disable-line camelcase
         const path = utils.encodeUri("/rooms/$roomId/upgrade", { $roomId: roomId });
         return this.http.authedRequest(Method.Post, path, undefined, { new_version: newVersion });
     }
@@ -7788,11 +7729,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: TODO
      * @returns Rejects: with an error response.
      */
-    public getStateEvent(
-        roomId: string,
-        eventType: string,
-        stateKey: string,
-    ): Promise<Record<string, any>> {
+    public getStateEvent(roomId: string, eventType: string, stateKey: string): Promise<Record<string, any>> {
         const pathParams = {
             $roomId: roomId,
             $eventType: eventType,
@@ -7834,9 +7771,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Rejects: with an error response.
      */
     public roomInitialSync(roomId: string, limit: number): Promise<IRoomInitialSyncResponse> {
-        const path = utils.encodeUri("/rooms/$roomId/initialSync",
-            { $roomId: roomId },
-        );
+        const path = utils.encodeUri("/rooms/$roomId/initialSync", { $roomId: roomId });
 
         return this.http.authedRequest(Method.Get, path, { limit: limit?.toString() ?? "30" });
     }
@@ -7871,8 +7806,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         };
 
         if (
-            (await this.doesServerSupportUnstableFeature("org.matrix.msc2285.stable"))
-            || (await this.isVersionSupported("v1.4"))
+            (await this.doesServerSupportUnstableFeature("org.matrix.msc2285.stable")) ||
+            (await this.isVersionSupported("v1.4"))
         ) {
             content[ReceiptType.ReadPrivate] = rpEventId;
         }
@@ -7913,9 +7848,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: IPublicRoomsResponse
      * @returns Rejects: with an error response.
      */
-    public publicRooms(
-        { server, limit, since, ...options }: IRoomDirectoryOptions = {},
-    ): Promise<IPublicRoomsResponse> {
+    public publicRooms({
+        server,
+        limit,
+        since,
+        ...options
+    }: IRoomDirectoryOptions = {}): Promise<IPublicRoomsResponse> {
         const queryParams: QueryDict = { server, limit, since };
         if (Object.keys(options).length === 0) {
             return this.http.authedRequest(Method.Get, "/publicRooms", queryParams);
@@ -7974,9 +7912,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: Object with room_id and servers.
      * @returns Rejects: with an error response.
      */
-    public getRoomIdForAlias(
-        alias: string,
-    ): Promise<{ room_id: string, servers: string[] }> { // eslint-disable-line camelcase
+    public getRoomIdForAlias(alias: string): Promise<{ room_id: string; servers: string[] }> {
+        // eslint-disable-line camelcase
         // TODO: deprecate this or resolveRoomAlias
         const path = utils.encodeUri("/directory/room/$alias", {
             $alias: alias,
@@ -7989,7 +7926,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Rejects: with an error response.
      */
     // eslint-disable-next-line camelcase
-    public resolveRoomAlias(roomAlias: string): Promise<{ room_id: string, servers: string[] }> {
+    public resolveRoomAlias(roomAlias: string): Promise<{ room_id: string; servers: string[] }> {
         // TODO: deprecate this or getRoomIdForAlias
         const path = utils.encodeUri("/directory/room/$alias", { $alias: roomAlias });
         return this.http.request(Method.Get, path);
@@ -8037,12 +7974,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         networkId: string,
         roomId: string,
         visibility: "public" | "private",
-    ): Promise<any> { // TODO: Types
+    ): Promise<any> {
+        // TODO: Types
         const path = utils.encodeUri("/directory/list/appservice/$networkId/$roomId", {
             $networkId: networkId,
             $roomId: roomId,
         });
-        return this.http.authedRequest(Method.Put, path, undefined, { "visibility": visibility });
+        return this.http.authedRequest(Method.Put, path, undefined, { visibility: visibility });
     }
 
     /**
@@ -8052,7 +7990,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *                 apply a limit if unspecified.
      * @returns Promise which resolves: an array of results.
      */
-    public searchUserDirectory({ term, limit }: { term: string, limit?: number }): Promise<IUserDirectoryResponse> {
+    public searchUserDirectory({ term, limit }: { term: string; limit?: number }): Promise<IUserDirectoryResponse> {
         const body: any = {
             search_term: term,
         };
@@ -8112,12 +8050,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         userId: string,
         info?: string,
         // eslint-disable-next-line camelcase
-    ): Promise<{ avatar_url?: string, displayname?: string }> {
-        const path = info ?
-            utils.encodeUri("/profile/$userId/$info",
-                { $userId: userId, $info: info }) :
-            utils.encodeUri("/profile/$userId",
-                { $userId: userId });
+    ): Promise<{ avatar_url?: string; displayname?: string }> {
+        const path = info
+            ? utils.encodeUri("/profile/$userId/$info", { $userId: userId, $info: info })
+            : utils.encodeUri("/profile/$userId", { $userId: userId });
         return this.http.authedRequest(Method.Get, path);
     }
 
@@ -8139,11 +8075,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: on success
      * @returns Rejects: with an error response.
      */
-    public addThreePid(creds: any, bind: boolean): Promise<any> { // TODO: Types
+    public addThreePid(creds: any, bind: boolean): Promise<any> {
+        // TODO: Types
         const path = "/account/3pid";
         const data = {
-            'threePidCreds': creds,
-            'bind': bind,
+            threePidCreds: creds,
+            bind: bind,
         };
         return this.http.authedRequest(Method.Post, path, undefined, data);
     }
@@ -8162,7 +8099,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public async addThreePidOnly(data: IAddThreePidOnlyBody): Promise<{}> {
         const path = "/account/3pid/add";
-        const prefix = await this.isVersionSupported("r0.6.0") ? ClientPrefix.R0 : ClientPrefix.Unstable;
+        const prefix = (await this.isVersionSupported("r0.6.0")) ? ClientPrefix.R0 : ClientPrefix.Unstable;
         return this.http.authedRequest(Method.Post, path, undefined, data, { prefix });
     }
 
@@ -8182,7 +8119,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public async bindThreePid(data: IBindThreePidBody): Promise<{}> {
         const path = "/account/3pid/bind";
-        const prefix = await this.isVersionSupported("r0.6.0") ? ClientPrefix.R0 : ClientPrefix.Unstable;
+        const prefix = (await this.isVersionSupported("r0.6.0")) ? ClientPrefix.R0 : ClientPrefix.Unstable;
         return this.http.authedRequest(Method.Post, path, undefined, data, { prefix });
     }
 
@@ -8208,7 +8145,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             address,
             id_server: this.getIdentityServerUrl(true),
         };
-        const prefix = await this.isVersionSupported("r0.6.0") ? ClientPrefix.R0 : ClientPrefix.Unstable;
+        const prefix = (await this.isVersionSupported("r0.6.0")) ? ClientPrefix.R0 : ClientPrefix.Unstable;
         return this.http.authedRequest(Method.Post, path, undefined, data, { prefix });
     }
 
@@ -8236,16 +8173,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: to an empty object `{}`
      * @returns Rejects: with an error response.
      */
-    public setPassword(
-        authDict: IAuthDict,
-        newPassword: string,
-        logoutDevices?: boolean,
-    ): Promise<{}> {
+    public setPassword(authDict: IAuthDict, newPassword: string, logoutDevices?: boolean): Promise<{}> {
         const path = "/account/password";
         const data = {
-            'auth': authDict,
-            'new_password': newPassword,
-            'logout_devices': logoutDevices,
+            auth: authDict,
+            new_password: newPassword,
+            logout_devices: logoutDevices,
         };
 
         return this.http.authedRequest<{}>(Method.Post, path, undefined, data);
@@ -8342,8 +8275,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // Migration path for clients that connect to a homeserver that does not support
         // MSC3881 yet, see https://github.com/matrix-org/matrix-spec-proposals/blob/kerry/remote-push-toggle/proposals/3881-remote-push-notification-toggling.md#migration
-        if (!await this.doesServerSupportUnstableFeature("org.matrix.msc3881")) {
-            response.pushers = response.pushers.map(pusher => {
+        if (!(await this.doesServerSupportUnstableFeature("org.matrix.msc3881"))) {
+            response.pushers = response.pushers.map((pusher) => {
                 if (!pusher.hasOwnProperty(PUSHER_ENABLED.name)) {
                     pusher[PUSHER_ENABLED.name] = true;
                 }
@@ -8412,11 +8345,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: an empty object `{}`
      * @returns Rejects: with an error response.
      */
-    public deletePushRule(
-        scope: string,
-        kind: PushRuleKind,
-        ruleId: Exclude<string, RuleId>,
-    ): Promise<{}> {
+    public deletePushRule(scope: string, kind: PushRuleKind, ruleId: Exclude<string, RuleId>): Promise<{}> {
         // NB. Scope not uri encoded because devices need the '/'
         const path = utils.encodeUri("/pushrules/" + scope + "/$kind/$ruleId", {
             $kind: kind,
@@ -8440,7 +8369,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             $kind: kind,
             $ruleId: ruleId,
         });
-        return this.http.authedRequest(Method.Put, path, undefined, { "enabled": enabled });
+        return this.http.authedRequest(Method.Put, path, undefined, { enabled: enabled });
     }
 
     /**
@@ -8458,7 +8387,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             $kind: kind,
             $ruleId: ruleId,
         });
-        return this.http.authedRequest(Method.Put, path, undefined, { "actions": actions });
+        return this.http.authedRequest(Method.Put, path, undefined, { actions: actions });
     }
 
     /**
@@ -8470,7 +8399,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Rejects: with an error response.
      */
     public search(
-        { body, next_batch: nextBatch }: { body: ISearchRequestBody, next_batch?: string },
+        { body, next_batch: nextBatch }: { body: ISearchRequestBody; next_batch?: string },
         abortSignal?: AbortSignal,
     ): Promise<ISearchResponse> {
         const queryParams: any = {};
@@ -8491,20 +8420,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: result object. Rejects: with
      *     an error response ({@link MatrixError}).
      */
-    public uploadKeysRequest(
-        content: IUploadKeysRequest,
-        opts?: void,
-    ): Promise<IKeysUploadResponse> {
+    public uploadKeysRequest(content: IUploadKeysRequest, opts?: void): Promise<IKeysUploadResponse> {
         return this.http.authedRequest(Method.Post, "/keys/upload", undefined, content);
     }
 
     public uploadKeySignatures(content: KeySignatures): Promise<IUploadKeySignaturesResponse> {
-        return this.http.authedRequest(
-            Method.Post, '/keys/signatures/upload', undefined,
-            content, {
-                prefix: ClientPrefix.V3,
-            },
-        );
+        return this.http.authedRequest(Method.Post, "/keys/signatures/upload", undefined, content, {
+            prefix: ClientPrefix.V3,
+        });
     }
 
     /**
@@ -8577,7 +8500,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: result object. Rejects: with
      *     an error response ({@link MatrixError}).
      */
-    public getKeyChanges(oldToken: string, newToken: string): Promise<{ changed: string[], left: string[] }> {
+    public getKeyChanges(oldToken: string, newToken: string): Promise<{ changed: string[]; left: string[] }> {
         const qps = {
             from: oldToken,
             to: newToken,
@@ -8586,14 +8509,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return this.http.authedRequest(Method.Get, "/keys/changes", qps);
     }
 
-    public uploadDeviceSigningKeys(auth?: IAuthData, keys?: CrossSigningKeys): Promise<{}> { // API returns empty object
+    public uploadDeviceSigningKeys(auth?: IAuthData, keys?: CrossSigningKeys): Promise<{}> {
+        // API returns empty object
         const data = Object.assign({}, keys);
         if (auth) Object.assign(data, { auth });
-        return this.http.authedRequest(
-            Method.Post, "/keys/device_signing/upload", undefined, data, {
-                prefix: ClientPrefix.Unstable,
-            },
-        );
+        return this.http.authedRequest(Method.Post, "/keys/device_signing/upload", undefined, data, {
+            prefix: ClientPrefix.Unstable,
+        });
     }
 
     /**
@@ -8649,7 +8571,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink: string,
         identityAccessToken?: string,
-    ): Promise<any> { // TODO: Types
+    ): Promise<any> {
+        // TODO: Types
         const params = {
             client_secret: clientSecret,
             email: email,
@@ -8658,8 +8581,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         };
 
         return this.http.idServerRequest(
-            Method.Post, "/validate/email/requestToken",
-            params, IdentityPrefix.V2, identityAccessToken,
+            Method.Post,
+            "/validate/email/requestToken",
+            params,
+            IdentityPrefix.V2,
+            identityAccessToken,
         );
     }
 
@@ -8696,7 +8622,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sendAttempt: number,
         nextLink: string,
         identityAccessToken?: string,
-    ): Promise<any> { // TODO: Types
+    ): Promise<any> {
+        // TODO: Types
         const params = {
             client_secret: clientSecret,
             country: phoneCountry,
@@ -8706,8 +8633,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         };
 
         return this.http.idServerRequest(
-            Method.Post, "/validate/msisdn/requestToken",
-            params, IdentityPrefix.V2, identityAccessToken,
+            Method.Post,
+            "/validate/msisdn/requestToken",
+            params,
+            IdentityPrefix.V2,
+            identityAccessToken,
         );
     }
 
@@ -8735,7 +8665,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         clientSecret: string,
         msisdnToken: string,
         identityAccessToken: string,
-    ): Promise<any> { // TODO: Types
+    ): Promise<any> {
+        // TODO: Types
         const params = {
             sid: sid,
             client_secret: clientSecret,
@@ -8743,8 +8674,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         };
 
         return this.http.idServerRequest(
-            Method.Post, "/validate/msisdn/submitToken",
-            params, IdentityPrefix.V2, identityAccessToken,
+            Method.Post,
+            "/validate/msisdn/submitToken",
+            params,
+            IdentityPrefix.V2,
+            identityAccessToken,
         );
     }
 
@@ -8771,7 +8705,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         sid: string,
         clientSecret: string,
         msisdnToken: string,
-    ): Promise<any> { // TODO: Types
+    ): Promise<any> {
+        // TODO: Types
         const params = {
             sid: sid,
             client_secret: clientSecret,
@@ -8786,7 +8721,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param identityAccessToken - The access token for the identity server.
      * @returns The hashing information for the identity server.
      */
-    public getIdentityHashDetails(identityAccessToken: string): Promise<any> { // TODO: Types
+    public getIdentityHashDetails(identityAccessToken: string): Promise<any> {
+        // TODO: Types
         return this.http.idServerRequest(
             Method.Get,
             "/hash_details",
@@ -8809,7 +8745,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public async identityHashedLookup(
         addressPairs: [string, string][],
         identityAccessToken: string,
-    ): Promise<{ address: string, mxid: string }[]> {
+    ): Promise<{ address: string; mxid: string }[]> {
         const params: Record<string, string | string[]> = {
             // addresses: ["email@example.org", "10005550000"],
             // algorithm: "sha256",
@@ -8818,11 +8754,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // Get hash information first before trying to do a lookup
         const hashes = await this.getIdentityHashDetails(identityAccessToken);
-        if (!hashes || !hashes['lookup_pepper'] || !hashes['algorithms']) {
+        if (!hashes || !hashes["lookup_pepper"] || !hashes["algorithms"]) {
             throw new Error("Unsupported identity server: bad response");
         }
 
-        params['pepper'] = hashes['lookup_pepper'];
+        params["pepper"] = hashes["lookup_pepper"];
 
         const localMapping: Record<string, string> = {
             // hashed identifier => plain text address
@@ -8830,22 +8766,24 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         };
 
         // When picking an algorithm, we pick the hashed over no hashes
-        if (hashes['algorithms'].includes('sha256')) {
+        if (hashes["algorithms"].includes("sha256")) {
             // Abuse the olm hashing
             const olmutil = new global.Olm.Utility();
-            params["addresses"] = addressPairs.map(p => {
+            params["addresses"] = addressPairs.map((p) => {
                 const addr = p[0].toLowerCase(); // lowercase to get consistent hashes
                 const med = p[1].toLowerCase();
-                const hashed = olmutil.sha256(`${addr} ${med} ${params['pepper']}`)
-                    .replace(/\+/g, '-').replace(/\//g, '_'); // URL-safe base64
+                const hashed = olmutil
+                    .sha256(`${addr} ${med} ${params["pepper"]}`)
+                    .replace(/\+/g, "-")
+                    .replace(/\//g, "_"); // URL-safe base64
                 // Map the hash to a known (case-sensitive) address. We use the case
                 // sensitive version because the caller might be expecting that.
                 localMapping[hashed] = p[0];
                 return hashed;
             });
             params["algorithm"] = "sha256";
-        } else if (hashes['algorithms'].includes('none')) {
-            params["addresses"] = addressPairs.map(p => {
+        } else if (hashes["algorithms"].includes("none")) {
+            params["addresses"] = addressPairs.map((p) => {
                 const addr = p[0].toLowerCase(); // lowercase to get consistent hashes
                 const med = p[1].toLowerCase();
                 const unhashed = `${addr} ${med}`;
@@ -8863,11 +8801,11 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             mappings: { [address: string]: string };
         }>(Method.Post, "/lookup", params, IdentityPrefix.V2, identityAccessToken);
 
-        if (!response?.['mappings']) return []; // no results
+        if (!response?.["mappings"]) return []; // no results
 
-        const foundAddresses: { address: string, mxid: string }[] = [];
-        for (const hashed of Object.keys(response['mappings'])) {
-            const mxid = response['mappings'][hashed];
+        const foundAddresses: { address: string; mxid: string }[] = [];
+        for (const hashed of Object.keys(response["mappings"])) {
+            const mxid = response["mappings"][hashed];
             const plainAddress = localMapping[hashed];
             if (!plainAddress) {
                 throw new Error("Identity server returned more results than expected");
@@ -8892,16 +8830,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *                                 exists
      * @returns Rejects: with an error response.
      */
-    public async lookupThreePid(
-        medium: string,
-        address: string,
-        identityAccessToken: string,
-    ): Promise<any> { // TODO: Types
+    public async lookupThreePid(medium: string, address: string, identityAccessToken: string): Promise<any> {
+        // TODO: Types
         // Note: we're using the V2 API by calling this function, but our
         // function contract requires a V1 response. We therefore have to
         // convert it manually.
         const response = await this.identityHashedLookup([[address, medium]], identityAccessToken);
-        const result = response.find(p => p.address === address);
+        const result = response.find((p) => p.address === address);
         if (!result) {
             return {};
         }
@@ -8932,18 +8867,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: Lookup results from IS.
      * @returns Rejects: with an error response.
      */
-    public async bulkLookupThreePids(query: [string, string][], identityAccessToken: string): Promise<any> { // TODO: Types
+    public async bulkLookupThreePids(query: [string, string][], identityAccessToken: string): Promise<any> {
+        // TODO: Types
         // Note: we're using the V2 API by calling this function, but our
         // function contract requires a V1 response. We therefore have to
         // convert it manually.
         const response = await this.identityHashedLookup(
             // We have to reverse the query order to get [address, medium] pairs
-            query.map(p => [p[1], p[0]]), identityAccessToken,
+            query.map((p) => [p[1], p[0]]),
+            identityAccessToken,
         );
 
         const v1results: [medium: string, address: string, mxid: string][] = [];
         for (const mapping of response) {
-            const originalQuery = query.find(p => p[1] === mapping.address);
+            const originalQuery = query.find((p) => p[1] === mapping.address);
             if (!originalQuery) {
                 throw new Error("Identity sever returned unexpected results");
             }
@@ -8969,11 +8906,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves: an object with account info.
      * @returns Rejects: with an error response.
      */
-    public getIdentityAccount(identityAccessToken: string): Promise<any> { // TODO: Types
-        return this.http.idServerRequest(
-            Method.Get, "/account",
-            undefined, IdentityPrefix.V2, identityAccessToken,
-        );
+    public getIdentityAccount(identityAccessToken: string): Promise<any> {
+        // TODO: Types
+        return this.http.idServerRequest(Method.Get, "/account", undefined, IdentityPrefix.V2, identityAccessToken);
     }
 
     /**
@@ -9028,15 +8963,15 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves to the result object
      */
     public getThirdpartyProtocols(): Promise<{ [protocol: string]: IProtocol }> {
-        return this.http.authedRequest<Record<string, IProtocol>>(
-            Method.Get, "/thirdparty/protocols",
-        ).then((response) => {
-            // sanity check
-            if (!response || typeof (response) !== 'object') {
-                throw new Error(`/thirdparty/protocols did not return an object: ${response}`);
-            }
-            return response;
-        });
+        return this.http
+            .authedRequest<Record<string, IProtocol>>(Method.Get, "/thirdparty/protocols")
+            .then((response) => {
+                // sanity check
+                if (!response || typeof response !== "object") {
+                    throw new Error(`/thirdparty/protocols did not return an object: ${response}`);
+                }
+                return response;
+            });
     }
 
     /**
@@ -9066,7 +9001,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *                        response to getThirdpartyProtocols()
      * @returns Promise which resolves to the result object
      */
-    public getThirdpartyUser(protocol: string, params: any): Promise<IThirdPartyUser[]> { // TODO: Types
+    public getThirdpartyUser(protocol: string, params: any): Promise<IThirdPartyUser[]> {
+        // TODO: Types
         const path = utils.encodeUri("/thirdparty/user/$protocol", {
             $protocol: protocol,
         });
@@ -9074,7 +9010,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return this.http.authedRequest(Method.Get, path, params);
     }
 
-    public getTerms(serviceType: SERVICE_TYPES, baseUrl: string): Promise<any> { // TODO: Types
+    public getTerms(serviceType: SERVICE_TYPES, baseUrl: string): Promise<any> {
+        // TODO: Types
         const url = this.termsUrlForService(serviceType, baseUrl);
         return this.http.requestOtherUrl(Method.Get, url);
     }
@@ -9089,9 +9026,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         const headers = {
             Authorization: "Bearer " + accessToken,
         };
-        return this.http.requestOtherUrl(Method.Post, url, {
-            user_accepts: termsUrls,
-        }, { headers });
+        return this.http.requestOtherUrl(
+            Method.Post,
+            url,
+            {
+                user_accepts: termsUrls,
+            },
+            { headers },
+        );
     }
 
     /**
@@ -9139,18 +9081,20 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             limit: limit?.toString(),
         };
 
-        return this.http.authedRequest<IRoomHierarchy>(Method.Get, path, queryParams, undefined, {
-            prefix: ClientPrefix.V1,
-        }).catch(e => {
-            if (e.errcode === "M_UNRECOGNIZED") {
-                // fall back to the prefixed hierarchy API.
-                return this.http.authedRequest<IRoomHierarchy>(Method.Get, path, queryParams, undefined, {
-                    prefix: "/_matrix/client/unstable/org.matrix.msc2946",
-                });
-            }
+        return this.http
+            .authedRequest<IRoomHierarchy>(Method.Get, path, queryParams, undefined, {
+                prefix: ClientPrefix.V1,
+            })
+            .catch((e) => {
+                if (e.errcode === "M_UNRECOGNIZED") {
+                    // fall back to the prefixed hierarchy API.
+                    return this.http.authedRequest<IRoomHierarchy>(Method.Get, path, queryParams, undefined, {
+                        prefix: "/_matrix/client/unstable/org.matrix.msc2946",
+                    });
+                }
 
-            throw e;
-        });
+                throw e;
+            });
     }
 
     /**
@@ -9205,12 +9149,13 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public unstableGetFileTreeSpace(roomId: string): MSC3089TreeSpace | null {
         const room = this.getRoom(roomId);
-        if (room?.getMyMembership() !== 'join') return null;
+        if (room?.getMyMembership() !== "join") return null;
 
         const createEvent = room.currentState.getStateEvents(EventType.RoomCreate, "");
         const purposeEvent = room.currentState.getStateEvents(
             UNSTABLE_MSC3088_PURPOSE.name,
-            UNSTABLE_MSC3089_TREE_SUBTYPE.name);
+            UNSTABLE_MSC3089_TREE_SUBTYPE.name,
+        );
 
         if (!createEvent) throw new Error("Expected single room create event");
 
@@ -9244,18 +9189,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         }
         const clientTimeout = req.clientTimeout;
         delete req.clientTimeout;
-        return this.http.authedRequest<MSC3575SlidingSyncResponse>(
-            Method.Post,
-            "/sync",
-            qps,
-            req,
-            {
-                prefix: "/_matrix/client/unstable/org.matrix.msc3575",
-                baseUrl: proxyBaseUrl,
-                localTimeoutMs: clientTimeout,
-                abortSignal,
-            },
-        );
+        return this.http.authedRequest<MSC3575SlidingSyncResponse>(Method.Post, "/sync", qps, req, {
+            prefix: "/_matrix/client/unstable/org.matrix.msc3575",
+            baseUrl: proxyBaseUrl,
+            localTimeoutMs: clientTimeout,
+            abortSignal,
+        });
     }
 
     /**
@@ -9292,10 +9231,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         room.processThreadRoots(threadedEvents, toStartOfTimeline);
     }
 
-    public processBeaconEvents(
-        room?: Room,
-        events?: MatrixEvent[],
-    ): void {
+    public processBeaconEvents(room?: Room, events?: MatrixEvent[]): void {
         if (!events?.length) return;
         if (!room) return;
 
@@ -9305,7 +9241,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     /**
      * Fetches the user_id of the configured access token.
      */
-    public async whoami(): Promise<{ user_id: string }> { // eslint-disable-line camelcase
+    public async whoami(): Promise<{ user_id: string }> {
+        // eslint-disable-line camelcase
         return this.http.authedRequest(Method.Get, "/account/whoami");
     }
 
@@ -9315,11 +9252,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      *    origin_server_ts of the closest event to the timestamp in the given
      *    direction
      */
-    public timestampToEvent(
-        roomId: string,
-        timestamp: number,
-        dir: Direction,
-    ): Promise<ITimestampToEventResponse> {
+    public timestampToEvent(roomId: string, timestamp: number, dir: Direction): Promise<ITimestampToEventResponse> {
         const path = utils.encodeUri("/rooms/$roomId/timestamp_to_event", {
             $roomId: roomId,
         });
@@ -9373,27 +9306,20 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
             if (!newHighlight && oldHighlight) newCount--;
 
             if (isThreadEvent) {
-                room.setThreadUnreadNotificationCount(
-                    event.threadRootId,
-                    NotificationCountType.Highlight,
-                    newCount,
-                );
+                room.setThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Highlight, newCount);
             } else {
                 room.setUnreadNotificationCount(NotificationCountType.Highlight, newCount);
             }
 
             // Fix 'Mentions Only' rooms from not having the right badge count
-            const totalCount = (isThreadEvent
-                ? room.getThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Total)
-                : room.getRoomUnreadNotificationCount(NotificationCountType.Total)) ?? 0;
+            const totalCount =
+                (isThreadEvent
+                    ? room.getThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Total)
+                    : room.getRoomUnreadNotificationCount(NotificationCountType.Total)) ?? 0;
 
             if (totalCount < newCount) {
                 if (isThreadEvent) {
-                    room.setThreadUnreadNotificationCount(
-                        event.threadRootId,
-                        NotificationCountType.Total,
-                        newCount,
-                    );
+                    room.setThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Total, newCount);
                 } else {
                     room.setUnreadNotificationCount(NotificationCountType.Total, newCount);
                 }
diff --git a/src/content-helpers.ts b/src/content-helpers.ts
index b66f0d10235..03bacbb9f4a 100644
--- a/src/content-helpers.ts
+++ b/src/content-helpers.ts
@@ -123,16 +123,10 @@ export const getTextForLocationEvent = (
     description?: string | null,
 ): string => {
     const date = `at ${new Date(timestamp!).toISOString()}`;
-    const assetName = assetType === LocationAssetType.Self ? 'User' : undefined;
+    const assetName = assetType === LocationAssetType.Self ? "User" : undefined;
     const quotedDescription = description ? `"${description}"` : undefined;
 
-    return [
-        assetName,
-        'Location',
-        quotedDescription,
-        uri,
-        date,
-    ].filter(Boolean).join(' ');
+    return [assetName, "Location", quotedDescription, uri, date].filter(Boolean).join(" ");
 };
 
 /**
@@ -152,8 +146,8 @@ export const makeLocationContent = (
     description?: string | null,
     assetType?: LocationAssetType,
 ): LegacyLocationEventContent & MLocationEventContent => {
-    const defaultedText = text ??
-        getTextForLocationEvent(uri, assetType || LocationAssetType.Self, timestamp, description);
+    const defaultedText =
+        text ?? getTextForLocationEvent(uri, assetType || LocationAssetType.Self, timestamp, description);
     const timestampEvent = timestamp ? { [M_TIMESTAMP.name]: timestamp } : {};
     return {
         msgtype: MsgType.Location,
@@ -192,10 +186,7 @@ export const parseLocationEvent = (wireEventContent: LocationEventWireContent):
 /**
  * Topic event helpers
  */
-export type MakeTopicContent = (
-    topic: string,
-    htmlTopic?: string,
-) => MRoomTopicEventContent;
+export type MakeTopicContent = (topic: string, htmlTopic?: string) => MRoomTopicEventContent;
 
 export const makeTopicContent: MakeTopicContent = (topic, htmlTopic) => {
     const renderings = [{ body: topic, mimetype: "text/plain" }];
@@ -212,8 +203,8 @@ export type TopicState = {
 
 export const parseTopicContent = (content: MRoomTopicEventContent): TopicState => {
     const mtopic = M_TOPIC.findIn<MTopicContent>(content);
-    const text = mtopic?.find(r => !isProvided(r.mimetype) || r.mimetype === "text/plain")?.body ?? content.topic;
-    const html = mtopic?.find(r => r.mimetype === "text/html")?.body;
+    const text = mtopic?.find((r) => !isProvided(r.mimetype) || r.mimetype === "text/plain")?.body ?? content.topic;
+    const html = mtopic?.find((r) => r.mimetype === "text/html")?.body;
     return { text, html };
 };
 
@@ -225,16 +216,10 @@ export type MakeBeaconInfoContent = (
     isLive?: boolean,
     description?: string,
     assetType?: LocationAssetType,
-    timestamp?: number
+    timestamp?: number,
 ) => MBeaconInfoEventContent;
 
-export const makeBeaconInfoContent: MakeBeaconInfoContent = (
-    timeout,
-    isLive,
-    description,
-    assetType,
-    timestamp,
-) => ({
+export const makeBeaconInfoContent: MakeBeaconInfoContent = (timeout, isLive, description, assetType, timestamp) => ({
     description,
     timeout,
     live: isLive,
@@ -272,12 +257,7 @@ export type MakeBeaconContent = (
     description?: string,
 ) => MBeaconEventContent;
 
-export const makeBeaconContent: MakeBeaconContent = (
-    uri,
-    timestamp,
-    beaconInfoEventId,
-    description,
-) => ({
+export const makeBeaconContent: MakeBeaconContent = (uri, timestamp, beaconInfoEventId, description) => ({
     [M_LOCATION.name]: {
         description,
         uri,
diff --git a/src/content-repo.ts b/src/content-repo.ts
index 9b6f6d37217..257541296bb 100644
--- a/src/content-repo.ts
+++ b/src/content-repo.ts
@@ -39,13 +39,13 @@ export function getHttpUriForMxc(
     allowDirectLinks = false,
 ): string {
     if (typeof mxc !== "string" || !mxc) {
-        return '';
+        return "";
     }
     if (mxc.indexOf("mxc://") !== 0) {
         if (allowDirectLinks) {
             return mxc;
         } else {
-            return '';
+            return "";
         }
     }
     let serverAndMediaId = mxc.slice(6); // strips mxc://
@@ -74,6 +74,6 @@ export function getHttpUriForMxc(
         serverAndMediaId = serverAndMediaId.slice(0, fragmentOffset);
     }
 
-    const urlParams = (Object.keys(params).length === 0 ? "" : ("?" + utils.encodeParams(params)));
+    const urlParams = Object.keys(params).length === 0 ? "" : "?" + utils.encodeParams(params);
     return baseUrl + prefix + serverAndMediaId + urlParams + fragment;
 }
diff --git a/src/crypto/CrossSigning.ts b/src/crypto/CrossSigning.ts
index 1ac9e214479..c9454621995 100644
--- a/src/crypto/CrossSigning.ts
+++ b/src/crypto/CrossSigning.ts
@@ -20,10 +20,10 @@ limitations under the License.
 
 import { PkSigning } from "@matrix-org/olm";
 
-import { decodeBase64, encodeBase64, IObject, pkSign, pkVerify } from './olmlib';
-import { logger } from '../logger';
-import { IndexedDBCryptoStore } from '../crypto/store/indexeddb-crypto-store';
-import { decryptAES, encryptAES } from './aes';
+import { decodeBase64, encodeBase64, IObject, pkSign, pkVerify } from "./olmlib";
+import { logger } from "../logger";
+import { IndexedDBCryptoStore } from "../crypto/store/indexeddb-crypto-store";
+import { decryptAES, encryptAES } from "./aes";
 import { DeviceInfo } from "./deviceinfo";
 import { SecretStorage } from "./SecretStorage";
 import { ICrossSigningKey, ISignedKey, MatrixClient } from "../client";
@@ -146,15 +146,11 @@ export class CrossSigningInfo {
 
         /* No keysource even returned a key */
         if (!privkey) {
-            throw new Error(
-                "getCrossSigningKey callback for " + type + " returned falsey",
-            );
+            throw new Error("getCrossSigningKey callback for " + type + " returned falsey");
         }
 
         /* We got some keys from the keysource, but none of them were valid */
-        throw new Error(
-            "Key type " + type + " from getCrossSigningKey callback did not match",
-        );
+        throw new Error("Key type " + type + " from getCrossSigningKey callback did not match");
     }
 
     /**
@@ -171,7 +167,7 @@ export class CrossSigningInfo {
         secretStorage: SecretStorage<MatrixClient | undefined>,
     ): Promise<Record<string, object> | null> {
         // check what SSSS keys have encrypted the master key (if any)
-        const stored = await secretStorage.isStored("m.cross_signing.master") || {};
+        const stored = (await secretStorage.isStored("m.cross_signing.master")) || {};
         // then check which of those SSSS keys have also encrypted the SSK and USK
         function intersect(s: Record<string, ISecretStorageKeyInfo>): void {
             for (const k of Object.keys(stored)) {
@@ -181,7 +177,7 @@ export class CrossSigningInfo {
             }
         }
         for (const type of ["self_signing", "user_signing"]) {
-            intersect(await secretStorage.isStored(`m.cross_signing.${type}`) || {});
+            intersect((await secretStorage.isStored(`m.cross_signing.${type}`)) || {});
         }
         return Object.keys(stored).length ? stored : null;
     }
@@ -233,7 +229,7 @@ export class CrossSigningInfo {
         if (!cacheCallbacks) return false;
         const types = type ? [type] : ["master", "self_signing", "user_signing"];
         for (const t of types) {
-            if (!await cacheCallbacks.getCrossSigningKeyCache?.(t)) {
+            if (!(await cacheCallbacks.getCrossSigningKeyCache?.(t))) {
                 return false;
             }
         }
@@ -287,17 +283,9 @@ export class CrossSigningInfo {
         }
 
         // If we're resetting the master key, we reset all keys
-        if (
-            level === undefined ||
-            level & CrossSigningLevel.MASTER ||
-            !this.keys.master
-        ) {
-            level = (
-                CrossSigningLevel.MASTER |
-                CrossSigningLevel.USER_SIGNING |
-                CrossSigningLevel.SELF_SIGNING
-            );
-        } else if (level === 0 as CrossSigningLevel) {
+        if (level === undefined || level & CrossSigningLevel.MASTER || !this.keys.master) {
+            level = CrossSigningLevel.MASTER | CrossSigningLevel.USER_SIGNING | CrossSigningLevel.SELF_SIGNING;
+        } else if (level === (0 as CrossSigningLevel)) {
             return;
         }
 
@@ -313,9 +301,9 @@ export class CrossSigningInfo {
                 masterPub = masterSigning.init_with_seed(privateKeys.master);
                 keys.master = {
                     user_id: this.userId,
-                    usage: ['master'],
+                    usage: ["master"],
                     keys: {
-                        ['ed25519:' + masterPub]: masterPub,
+                        ["ed25519:" + masterPub]: masterPub,
                     },
                 };
             } else {
@@ -329,9 +317,9 @@ export class CrossSigningInfo {
                     const sskPub = sskSigning.init_with_seed(privateKeys.self_signing);
                     keys.self_signing = {
                         user_id: this.userId,
-                        usage: ['self_signing'],
+                        usage: ["self_signing"],
                         keys: {
-                            ['ed25519:' + sskPub]: sskPub,
+                            ["ed25519:" + sskPub]: sskPub,
                         },
                     };
                     pkSign(keys.self_signing, masterSigning, this.userId, masterPub);
@@ -347,9 +335,9 @@ export class CrossSigningInfo {
                     const uskPub = uskSigning.init_with_seed(privateKeys.user_signing);
                     keys.user_signing = {
                         user_id: this.userId,
-                        usage: ['user_signing'],
+                        usage: ["user_signing"],
                         keys: {
-                            ['ed25519:' + uskPub]: uskPub,
+                            ["ed25519:" + uskPub]: uskPub,
                         },
                     };
                     pkSign(keys.user_signing, masterSigning, this.userId, masterPub);
@@ -378,8 +366,7 @@ export class CrossSigningInfo {
         const signingKeys: Record<string, ICrossSigningKey> = {};
         if (keys.master) {
             if (keys.master.user_id !== this.userId) {
-                const error = "Mismatched user ID " + keys.master.user_id +
-                      " in master key from " + this.userId;
+                const error = "Mismatched user ID " + keys.master.user_id + " in master key from " + this.userId;
                 logger.error(error);
                 throw new Error(error);
             }
@@ -401,8 +388,7 @@ export class CrossSigningInfo {
         // verify signatures
         if (keys.user_signing) {
             if (keys.user_signing.user_id !== this.userId) {
-                const error = "Mismatched user ID " + keys.master.user_id +
-                      " in user_signing key from " + this.userId;
+                const error = "Mismatched user ID " + keys.master.user_id + " in user_signing key from " + this.userId;
                 logger.error(error);
                 throw new Error(error);
             }
@@ -416,8 +402,7 @@ export class CrossSigningInfo {
         }
         if (keys.self_signing) {
             if (keys.self_signing.user_id !== this.userId) {
-                const error = "Mismatched user ID " + keys.master.user_id +
-                      " in self_signing key from " + this.userId;
+                const error = "Mismatched user ID " + keys.master.user_id + " in self_signing key from " + this.userId;
                 logger.error(error);
                 throw new Error(error);
             }
@@ -455,9 +440,7 @@ export class CrossSigningInfo {
 
     public async signObject<T extends object>(data: T, type: string): Promise<T & { signatures: ISignatures }> {
         if (!this.keys[type]) {
-            throw new Error(
-                "Attempted to sign with " + type + " key but no such key present",
-            );
+            throw new Error("Attempted to sign with " + type + " key but no such key present");
         }
         const [pubkey, signing] = await this.getCrossSigningKey(type);
         try {
@@ -478,9 +461,7 @@ export class CrossSigningInfo {
 
     public async signDevice(userId: string, device: DeviceInfo): Promise<ISignedKey | undefined> {
         if (userId !== this.userId) {
-            throw new Error(
-                `Trying to sign ${userId}'s device; can only sign our own device`,
-            );
+            throw new Error(`Trying to sign ${userId}'s device; can only sign our own device`);
         }
         if (!this.keys.self_signing) {
             logger.info("No self signing key: not signing device");
@@ -492,7 +473,8 @@ export class CrossSigningInfo {
                 keys: device.keys,
                 device_id: device.deviceId,
                 user_id: userId,
-            }, "self_signing",
+            },
+            "self_signing",
         );
     }
 
@@ -506,10 +488,12 @@ export class CrossSigningInfo {
     public checkUserTrust(userCrossSigning: CrossSigningInfo): UserTrustLevel {
         // if we're checking our own key, then it's trusted if the master key
         // and self-signing key match
-        if (this.userId === userCrossSigning.userId
-            && this.getId() && this.getId() === userCrossSigning.getId()
-            && this.getId("self_signing")
-            && this.getId("self_signing") === userCrossSigning.getId("self_signing")
+        if (
+            this.userId === userCrossSigning.userId &&
+            this.getId() &&
+            this.getId() === userCrossSigning.getId() &&
+            this.getId("self_signing") &&
+            this.getId("self_signing") === userCrossSigning.getId("self_signing")
         ) {
             return new UserTrustLevel(true, true, this.firstUse);
         }
@@ -522,18 +506,14 @@ export class CrossSigningInfo {
 
         let userTrusted: boolean;
         const userMaster = userCrossSigning.keys.master;
-        const uskId = this.getId('user_signing')!;
+        const uskId = this.getId("user_signing")!;
         try {
             pkVerify(userMaster, uskId, this.userId);
             userTrusted = true;
         } catch (e) {
             userTrusted = false;
         }
-        return new UserTrustLevel(
-            userTrusted,
-            userCrossSigning.crossSigningVerifiedBefore,
-            userCrossSigning.firstUse,
-        );
+        return new UserTrustLevel(userTrusted, userCrossSigning.crossSigningVerifiedBefore, userCrossSigning.firstUse);
     }
 
     /**
@@ -558,9 +538,7 @@ export class CrossSigningInfo {
         if (!userSSK) {
             // if the user has no self-signing key then we cannot make any
             // trust assertions about this device from cross-signing
-            return new DeviceTrustLevel(
-                false, false, localTrust, trustCrossSignedDevices,
-            );
+            return new DeviceTrustLevel(false, false, localTrust, trustCrossSignedDevices);
         }
 
         const deviceObj = deviceToObject(device, userCrossSigning.userId);
@@ -675,9 +653,7 @@ export class DeviceTrustLevel {
      * @returns true if this device is verified via any means
      */
     public isVerified(): boolean {
-        return Boolean(this.isLocallyVerified() || (
-            this.trustCrossSignedDevices && this.isCrossSigningVerified()
-        ));
+        return Boolean(this.isLocallyVerified() || (this.trustCrossSignedDevices && this.isCrossSigningVerified()));
     }
 
     /**
@@ -705,18 +681,14 @@ export class DeviceTrustLevel {
 
 export function createCryptoStoreCacheCallbacks(store: CryptoStore, olmDevice: OlmDevice): ICacheCallbacks {
     return {
-        getCrossSigningKeyCache: async function(
+        getCrossSigningKeyCache: async function (
             type: keyof SecretStorePrivateKeys,
             _expectedPublicKey: string,
         ): Promise<Uint8Array> {
             const key = await new Promise<any>((resolve) => {
-                return store.doTxn(
-                    'readonly',
-                    [IndexedDBCryptoStore.STORE_ACCOUNT],
-                    (txn) => {
-                        store.getSecretStorePrivateKey(txn, resolve, type);
-                    },
-                );
+                return store.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+                    store.getSecretStorePrivateKey(txn, resolve, type);
+                });
             });
 
             if (key && key.ciphertext) {
@@ -727,24 +699,18 @@ export function createCryptoStoreCacheCallbacks(store: CryptoStore, olmDevice: O
                 return key;
             }
         },
-        storeCrossSigningKeyCache: async function(
+        storeCrossSigningKeyCache: async function (
             type: keyof SecretStorePrivateKeys,
             key?: Uint8Array,
         ): Promise<void> {
             if (!(key instanceof Uint8Array)) {
-                throw new Error(
-                    `storeCrossSigningKeyCache expects Uint8Array, got ${key}`,
-                );
+                throw new Error(`storeCrossSigningKeyCache expects Uint8Array, got ${key}`);
             }
             const pickleKey = Buffer.from(olmDevice.pickleKey);
             const encryptedKey = await encryptAES(encodeBase64(key), pickleKey, type);
-            return store.doTxn(
-                'readwrite',
-                [IndexedDBCryptoStore.STORE_ACCOUNT],
-                (txn) => {
-                    store.storeSecretStorePrivateKey(txn, type, encryptedKey);
-                },
-            );
+            return store.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+                store.storeSecretStorePrivateKey(txn, type, encryptedKey);
+            });
         },
     };
 }
@@ -780,15 +746,15 @@ export async function requestKeysDuringVerification(
         // CrossSigningInfo.getCrossSigningKey() to validate/cache
         const crossSigning = new CrossSigningInfo(
             original.userId,
-            { getCrossSigningKey: async (type): Promise<Uint8Array> => {
-                logger.debug("Cross-signing: requesting secret", type, deviceId);
-                const { promise } = client.requestSecret(
-                    `m.cross_signing.${type}`, [deviceId],
-                );
-                const result = await promise;
-                const decoded = decodeBase64(result);
-                return Uint8Array.from(decoded);
-            } },
+            {
+                getCrossSigningKey: async (type): Promise<Uint8Array> => {
+                    logger.debug("Cross-signing: requesting secret", type, deviceId);
+                    const { promise } = client.requestSecret(`m.cross_signing.${type}`, [deviceId]);
+                    const result = await promise;
+                    const decoded = decodeBase64(result);
+                    return Uint8Array.from(decoded);
+                },
+            },
             original.getCacheCallbacks(),
         );
         crossSigning.keys = original.keys;
@@ -798,11 +764,7 @@ export async function requestKeysDuringVerification(
         // then change here to reject on the timeout
         // Requests can be ignored, so don't wait around forever
         const timeout = new Promise<void>((resolve) => {
-            setTimeout(
-                resolve,
-                KEY_REQUEST_TIMEOUT_MS,
-                new Error("Timeout"),
-            );
+            setTimeout(resolve, KEY_REQUEST_TIMEOUT_MS, new Error("Timeout"));
         });
 
         // also request and cache the key backup key
@@ -810,16 +772,12 @@ export async function requestKeysDuringVerification(
             const cachedKey = await client.crypto!.getSessionBackupPrivateKey();
             if (!cachedKey) {
                 logger.info("No cached backup key found. Requesting...");
-                const secretReq = client.requestSecret(
-                    'm.megolm_backup.v1', [deviceId],
-                );
+                const secretReq = client.requestSecret("m.megolm_backup.v1", [deviceId]);
                 const base64Key = await secretReq.promise;
                 logger.info("Got key backup key, decoding...");
                 const decodedKey = decodeBase64(base64Key);
                 logger.info("Decoded backup key, storing...");
-                await client.crypto!.storeSessionBackupPrivateKey(
-                    Uint8Array.from(decodedKey),
-                );
+                await client.crypto!.storeSessionBackupPrivateKey(Uint8Array.from(decodedKey));
                 logger.info("Backup key stored. Starting backup restore...");
                 const backupInfo = await client.getKeyBackupVersion();
                 // no need to await for this - just let it go in the bg
diff --git a/src/crypto/DeviceList.ts b/src/crypto/DeviceList.ts
index 81dc5e18e68..292cf159b5a 100644
--- a/src/crypto/DeviceList.ts
+++ b/src/crypto/DeviceList.ts
@@ -18,12 +18,12 @@ limitations under the License.
  * Manages the list of other users' devices
  */
 
-import { logger } from '../logger';
-import { DeviceInfo, IDevice } from './deviceinfo';
-import { CrossSigningInfo, ICrossSigningInfo } from './CrossSigning';
-import * as olmlib from './olmlib';
-import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
-import { chunkPromises, defer, IDeferred, sleep } from '../utils';
+import { logger } from "../logger";
+import { DeviceInfo, IDevice } from "./deviceinfo";
+import { CrossSigningInfo, ICrossSigningInfo } from "./CrossSigning";
+import * as olmlib from "./olmlib";
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store";
+import { chunkPromises, defer, IDeferred, sleep } from "../utils";
 import { DeviceKeys, IDownloadKeyResult, Keys, MatrixClient, SigningKeys } from "../client";
 import { OlmDevice } from "./OlmDevice";
 import { CryptoStore } from "./store/base";
@@ -113,29 +113,25 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      * Load the device tracking state from storage
      */
     public async load(): Promise<void> {
-        await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_DEVICE_DATA], (txn) => {
-                this.cryptoStore.getEndToEndDeviceData(txn, (deviceData) => {
-                    this.hasFetched = Boolean(deviceData && deviceData.devices);
-                    this.devices = deviceData ? deviceData.devices : {};
-                    this.crossSigningInfo = deviceData ?
-                        deviceData.crossSigningInfo || {} : {};
-                    this.deviceTrackingStatus = deviceData ?
-                        deviceData.trackingStatus : {};
-                    this.syncToken = deviceData?.syncToken ?? null;
-                    this.userByIdentityKey = {};
-                    for (const user of Object.keys(this.devices)) {
-                        const userDevices = this.devices[user];
-                        for (const device of Object.keys(userDevices)) {
-                            const idKey = userDevices[device].keys['curve25519:'+device];
-                            if (idKey !== undefined) {
-                                this.userByIdentityKey[idKey] = user;
-                            }
+        await this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_DEVICE_DATA], (txn) => {
+            this.cryptoStore.getEndToEndDeviceData(txn, (deviceData) => {
+                this.hasFetched = Boolean(deviceData && deviceData.devices);
+                this.devices = deviceData ? deviceData.devices : {};
+                this.crossSigningInfo = deviceData ? deviceData.crossSigningInfo || {} : {};
+                this.deviceTrackingStatus = deviceData ? deviceData.trackingStatus : {};
+                this.syncToken = deviceData?.syncToken ?? null;
+                this.userByIdentityKey = {};
+                for (const user of Object.keys(this.devices)) {
+                    const userDevices = this.devices[user];
+                    for (const device of Object.keys(userDevices)) {
+                        const idKey = userDevices[device].keys["curve25519:" + device];
+                        if (idKey !== undefined) {
+                            this.userByIdentityKey[idKey] = user;
                         }
                     }
-                });
-            },
-        );
+                }
+            });
+        });
 
         for (const u of Object.keys(this.deviceTrackingStatus)) {
             // if a download was in progress when we got shut down, it isn't any more.
@@ -195,7 +191,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
             const resolveSavePromise = this.resolveSavePromise;
             this.savePromiseTime = targetTime;
             this.saveTimer = setTimeout(() => {
-                logger.log('Saving device tracking data', this.syncToken);
+                logger.log("Saving device tracking data", this.syncToken);
 
                 // null out savePromise now (after the delay but before the write),
                 // otherwise we could return the existing promise when the save has
@@ -205,23 +201,29 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
                 this.savePromise = null;
                 this.resolveSavePromise = null;
 
-                this.cryptoStore.doTxn(
-                    'readwrite', [IndexedDBCryptoStore.STORE_DEVICE_DATA], (txn) => {
-                        this.cryptoStore.storeEndToEndDeviceData({
-                            devices: this.devices,
-                            crossSigningInfo: this.crossSigningInfo,
-                            trackingStatus: this.deviceTrackingStatus,
-                            syncToken: this.syncToken ?? undefined,
-                        }, txn);
-                    },
-                ).then(() => {
-                    // The device list is considered dirty until the write completes.
-                    this.dirty = false;
-                    resolveSavePromise?.(true);
-                }, err => {
-                    logger.error('Failed to save device tracking data', this.syncToken);
-                    logger.error(err);
-                });
+                this.cryptoStore
+                    .doTxn("readwrite", [IndexedDBCryptoStore.STORE_DEVICE_DATA], (txn) => {
+                        this.cryptoStore.storeEndToEndDeviceData(
+                            {
+                                devices: this.devices,
+                                crossSigningInfo: this.crossSigningInfo,
+                                trackingStatus: this.deviceTrackingStatus,
+                                syncToken: this.syncToken ?? undefined,
+                            },
+                            txn,
+                        );
+                    })
+                    .then(
+                        () => {
+                            // The device list is considered dirty until the write completes.
+                            this.dirty = false;
+                            resolveSavePromise?.(true);
+                        },
+                        (err) => {
+                            logger.error("Failed to save device tracking data", this.syncToken);
+                            logger.error(err);
+                        },
+                    );
             }, delay);
         }
 
@@ -269,10 +271,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
             if (this.keyDownloadsInProgressByUser.has(u)) {
                 // already a key download in progress/queued for this user; its results
                 // will be good enough for us.
-                logger.log(
-                    `downloadKeys: already have a download in progress for ` +
-                    `${u}: awaiting its result`,
-                );
+                logger.log(`downloadKeys: already have a download in progress for ` + `${u}: awaiting its result`);
                 promises.push(this.keyDownloadsInProgressByUser.get(u)!);
             } else if (forceDownload || trackingStatus != TrackingStatus.UpToDate) {
                 usersToDownload.push(u);
@@ -306,7 +305,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
         userIds.forEach((u) => {
             stored[u] = {};
             const devices = this.getStoredDevicesForUser(u) || [];
-            devices.forEach(function(dev) {
+            devices.forEach(function (dev) {
                 stored[u][dev.deviceId] = dev;
             });
         });
@@ -467,11 +466,11 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
         // refresh request).
         // By checking it is at least a string, we can eliminate a class of
         // silly errors.
-        if (typeof userId !== 'string') {
-            throw new Error('userId must be a string; was '+userId);
+        if (typeof userId !== "string") {
+            throw new Error("userId must be a string; was " + userId);
         }
         if (!this.deviceTrackingStatus[userId]) {
-            logger.log('Now tracking device list for ' + userId);
+            logger.log("Now tracking device list for " + userId);
             this.deviceTrackingStatus[userId] = TrackingStatus.PendingDownload;
             // we don't yet persist the tracking status, since there may be a lot
             // of calls; we save all data together once the sync is done
@@ -489,7 +488,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
      */
     public stopTrackingDeviceList(userId: string): void {
         if (this.deviceTrackingStatus[userId]) {
-            logger.log('No longer tracking device list for ' + userId);
+            logger.log("No longer tracking device list for " + userId);
             this.deviceTrackingStatus[userId] = TrackingStatus.NotTracked;
 
             // we don't yet persist the tracking status, since there may be a lot
@@ -564,7 +563,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
         // remove old devices from userByIdentityKey
         if (this.devices[userId] !== undefined) {
             for (const [deviceId, dev] of Object.entries(this.devices[userId])) {
-                const identityKey = dev.keys['curve25519:'+deviceId];
+                const identityKey = dev.keys["curve25519:" + deviceId];
 
                 delete this.userByIdentityKey[identityKey];
             }
@@ -574,7 +573,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
 
         // add new devices into userByIdentityKey
         for (const [deviceId, dev] of Object.entries(devices)) {
-            const identityKey = dev.keys['curve25519:'+deviceId];
+            const identityKey = dev.keys["curve25519:" + deviceId];
 
             this.userByIdentityKey[identityKey] = userId;
         }
@@ -601,15 +600,16 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
             return Promise.resolve();
         }
 
-        const prom = this.serialiser.updateDevicesForUsers(users, this.syncToken!).then(() => {
-            finished(true);
-        }, (e) => {
-            logger.error(
-                'Error downloading keys for ' + users + ":", e,
-            );
-            finished(false);
-            throw e;
-        });
+        const prom = this.serialiser.updateDevicesForUsers(users, this.syncToken!).then(
+            () => {
+                finished(true);
+            },
+            (e) => {
+                logger.error("Error downloading keys for " + users + ":", e);
+                finished(false);
+                throw e;
+            },
+        );
 
         users.forEach((u) => {
             this.keyDownloadsInProgressByUser.set(u, prom);
@@ -628,7 +628,7 @@ export class DeviceList extends TypedEventEmitter<EmittedEvents, CryptoEventHand
                 // since we started this request. If that happens, we should
                 // ignore the completion of the first one.
                 if (this.keyDownloadsInProgressByUser.get(u) !== prom) {
-                    logger.log('Another update in the queue for', u, '- not marking up-to-date');
+                    logger.log("Another update in the queue for", u, "- not marking up-to-date");
                     return;
                 }
                 this.keyDownloadsInProgressByUser.delete(u);
@@ -714,7 +714,7 @@ class DeviceListUpdateSerialiser {
 
         if (this.downloadInProgress) {
             // just queue up these users
-            logger.log('Queued key download for', users);
+            logger.log("Queued key download for", users);
             return this.queuedQueryDeferred.promise;
         }
 
@@ -724,9 +724,7 @@ class DeviceListUpdateSerialiser {
 
     private doQueuedQueries(): Promise<void> {
         if (this.downloadInProgress) {
-            throw new Error(
-                "DeviceListUpdateSerialiser.doQueuedQueries called with request active",
-            );
+            throw new Error("DeviceListUpdateSerialiser.doQueuedQueries called with request active");
         }
 
         const downloadUsers = Object.keys(this.keyDownloadsQueuedByUser);
@@ -734,7 +732,7 @@ class DeviceListUpdateSerialiser {
         const deferred = this.queuedQueryDeferred;
         this.queuedQueryDeferred = undefined;
 
-        logger.log('Starting key download for', downloadUsers);
+        logger.log("Starting key download for", downloadUsers);
         this.downloadInProgress = true;
 
         const opts: Parameters<MatrixClient["downloadKeysForUsers"]>[1] = {};
@@ -748,53 +746,64 @@ class DeviceListUpdateSerialiser {
             factories.push(() => this.baseApis.downloadKeysForUsers(userSlice, opts));
         }
 
-        chunkPromises(factories, 3).then(async (responses: IDownloadKeyResult[]) => {
-            const dk: IDownloadKeyResult["device_keys"]
-                = Object.assign({}, ...(responses.map(res => res.device_keys || {})));
-            const masterKeys: IDownloadKeyResult["master_keys"]
-                = Object.assign({}, ...(responses.map(res => res.master_keys || {})));
-            const ssks: IDownloadKeyResult["self_signing_keys"]
-                = Object.assign({}, ...(responses.map(res => res.self_signing_keys || {})));
-            const usks: IDownloadKeyResult["user_signing_keys"]
-                = Object.assign({}, ...(responses.map(res => res.user_signing_keys || {})));
+        chunkPromises(factories, 3)
+            .then(async (responses: IDownloadKeyResult[]) => {
+                const dk: IDownloadKeyResult["device_keys"] = Object.assign(
+                    {},
+                    ...responses.map((res) => res.device_keys || {}),
+                );
+                const masterKeys: IDownloadKeyResult["master_keys"] = Object.assign(
+                    {},
+                    ...responses.map((res) => res.master_keys || {}),
+                );
+                const ssks: IDownloadKeyResult["self_signing_keys"] = Object.assign(
+                    {},
+                    ...responses.map((res) => res.self_signing_keys || {}),
+                );
+                const usks: IDownloadKeyResult["user_signing_keys"] = Object.assign(
+                    {},
+                    ...responses.map((res) => res.user_signing_keys || {}),
+                );
 
-            // yield to other things that want to execute in between users, to
-            // avoid wedging the CPU
-            // (https://github.com/vector-im/element-web/issues/3158)
-            //
-            // of course we ought to do this in a web worker or similar, but
-            // this serves as an easy solution for now.
-            for (const userId of downloadUsers) {
-                await sleep(5);
-                try {
-                    await this.processQueryResponseForUser(
-                        userId, dk[userId], {
+                // yield to other things that want to execute in between users, to
+                // avoid wedging the CPU
+                // (https://github.com/vector-im/element-web/issues/3158)
+                //
+                // of course we ought to do this in a web worker or similar, but
+                // this serves as an easy solution for now.
+                for (const userId of downloadUsers) {
+                    await sleep(5);
+                    try {
+                        await this.processQueryResponseForUser(userId, dk[userId], {
                             master: masterKeys?.[userId],
                             self_signing: ssks?.[userId],
                             user_signing: usks?.[userId],
-                        },
-                    );
-                } catch (e) {
-                    // log the error but continue, so that one bad key
-                    // doesn't kill the whole process
-                    logger.error(`Error processing keys for ${userId}:`, e);
+                        });
+                    } catch (e) {
+                        // log the error but continue, so that one bad key
+                        // doesn't kill the whole process
+                        logger.error(`Error processing keys for ${userId}:`, e);
+                    }
                 }
-            }
-        }).then(() => {
-            logger.log('Completed key download for ' + downloadUsers);
+            })
+            .then(
+                () => {
+                    logger.log("Completed key download for " + downloadUsers);
 
-            this.downloadInProgress = false;
-            deferred?.resolve();
+                    this.downloadInProgress = false;
+                    deferred?.resolve();
 
-            // if we have queued users, fire off another request.
-            if (this.queuedQueryDeferred) {
-                this.doQueuedQueries();
-            }
-        }, (e) => {
-            logger.warn('Error downloading keys for ' + downloadUsers + ':', e);
-            this.downloadInProgress = false;
-            deferred?.reject(e);
-        });
+                    // if we have queued users, fire off another request.
+                    if (this.queuedQueryDeferred) {
+                        this.doQueuedQueries();
+                    }
+                },
+                (e) => {
+                    logger.warn("Error downloading keys for " + downloadUsers + ":", e);
+                    this.downloadInProgress = false;
+                    deferred?.reject(e);
+                },
+            );
 
         return deferred!.promise;
     }
@@ -808,8 +817,8 @@ class DeviceListUpdateSerialiser {
             user_signing?: SigningKeys;
         },
     ): Promise<void> {
-        logger.log('got device keys for ' + userId + ':', dkResponse);
-        logger.log('got cross-signing keys for ' + userId + ':', crossSigningResponse);
+        logger.log("got device keys for " + userId + ":", dkResponse);
+        logger.log("got cross-signing keys for " + userId + ":", crossSigningResponse);
 
         {
             // map from deviceid -> deviceinfo for this user
@@ -823,8 +832,12 @@ class DeviceListUpdateSerialiser {
             }
 
             await updateStoredDeviceKeysForUser(
-                this.olmDevice, userId, userStore, dkResponse || {},
-                this.baseApis.getUserId()!, this.baseApis.deviceId!,
+                this.olmDevice,
+                userId,
+                userStore,
+                dkResponse || {},
+                this.baseApis.getUserId()!,
+                this.baseApis.deviceId!,
             );
 
             // put the updates into the object that will be returned as our results
@@ -840,12 +853,12 @@ class DeviceListUpdateSerialiser {
         {
             // FIXME: should we be ignoring empty cross-signing responses, or
             // should we be dropping the keys?
-            if (crossSigningResponse
-                && (crossSigningResponse.master || crossSigningResponse.self_signing
-                    || crossSigningResponse.user_signing)) {
-                const crossSigning
-                      = this.deviceList.getStoredCrossSigningForUser(userId)
-                      || new CrossSigningInfo(userId);
+            if (
+                crossSigningResponse &&
+                (crossSigningResponse.master || crossSigningResponse.self_signing || crossSigningResponse.user_signing)
+            ) {
+                const crossSigning =
+                    this.deviceList.getStoredCrossSigningForUser(userId) || new CrossSigningInfo(userId);
 
                 crossSigning.setKeys(crossSigningResponse);
 
@@ -877,14 +890,11 @@ async function updateStoredDeviceKeysForUser(
 
         if (!(deviceId in userResult)) {
             if (userId === localUserId && deviceId === localDeviceId) {
-                logger.warn(
-                    `Local device ${deviceId} missing from sync, skipping removal`,
-                );
+                logger.warn(`Local device ${deviceId} missing from sync, skipping removal`);
                 continue;
             }
 
-            logger.log("Device " + userId + ":" + deviceId +
-                " has been removed");
+            logger.log("Device " + userId + ":" + deviceId + " has been removed");
             delete userStore[deviceId];
             updated = true;
         }
@@ -900,13 +910,11 @@ async function updateStoredDeviceKeysForUser(
         // check that the user_id and device_id in the response object are
         // correct
         if (deviceResult.user_id !== userId) {
-            logger.warn("Mismatched user_id " + deviceResult.user_id +
-               " in keys from " + userId + ":" + deviceId);
+            logger.warn("Mismatched user_id " + deviceResult.user_id + " in keys from " + userId + ":" + deviceId);
             continue;
         }
         if (deviceResult.device_id !== deviceId) {
-            logger.warn("Mismatched device_id " + deviceResult.device_id +
-               " in keys from " + userId + ":" + deviceId);
+            logger.warn("Mismatched device_id " + deviceResult.device_id + " in keys from " + userId + ":" + deviceId);
             continue;
         }
 
@@ -965,8 +973,7 @@ async function storeDeviceKeys(
             // best off sticking with the original keys.
             //
             // Should we warn the user about it somehow?
-            logger.warn("Ed25519 key for device " + userId + ":" +
-               deviceId + " has changed");
+            logger.warn("Ed25519 key for device " + userId + ":" + deviceId + " has changed");
             return false;
         }
     } else {
diff --git a/src/crypto/EncryptionSetup.ts b/src/crypto/EncryptionSetup.ts
index 41310252bfd..7fe6d6457c3 100644
--- a/src/crypto/EncryptionSetup.ts
+++ b/src/crypto/EncryptionSetup.ts
@@ -17,7 +17,7 @@ limitations under the License.
 import { logger } from "../logger";
 import { IContent, MatrixEvent } from "../models/event";
 import { createCryptoStoreCacheCallbacks, ICacheCallbacks } from "./CrossSigning";
-import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store";
 import { Method, ClientPrefix } from "../http-api";
 import { Crypto, ICryptoCallbacks, IBootstrapCrossSigningOpts } from "./index";
 import {
@@ -127,12 +127,7 @@ export class EncryptionSetupBuilder {
      */
     public buildOperation(): EncryptionSetupOperation {
         const accountData = this.accountDataClientAdapter.values;
-        return new EncryptionSetupOperation(
-            accountData,
-            this.crossSigningKeys,
-            this.keyBackupInfo,
-            this.keySignatures,
-        );
+        return new EncryptionSetupOperation(accountData, this.crossSigningKeys, this.keyBackupInfo, this.keySignatures);
     }
 
     /**
@@ -151,13 +146,9 @@ export class EncryptionSetupBuilder {
                 await cacheCallbacks.storeCrossSigningKeyCache?.(type, privateKey);
             }
             // store own cross-sign pubkeys as trusted
-            await crypto.cryptoStore.doTxn(
-                'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-                (txn) => {
-                    crypto.cryptoStore.storeCrossSigningKeys(
-                        txn, this.crossSigningKeys!.keys);
-                },
-            );
+            await crypto.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+                crypto.cryptoStore.storeCrossSigningKeys(txn, this.crossSigningKeys!.keys);
+            });
         }
         // store session backup key in cache
         if (this.sessionBackupPrivateKey) {
@@ -191,12 +182,12 @@ export class EncryptionSetupOperation {
         if (this.crossSigningKeys) {
             const keys: Partial<CrossSigningKeys> = {};
             for (const [name, key] of Object.entries(this.crossSigningKeys.keys)) {
-                keys[((name as keyof ICrossSigningKeys["keys"]) + "_key" as keyof CrossSigningKeys)] = key;
+                keys[((name as keyof ICrossSigningKeys["keys"]) + "_key") as keyof CrossSigningKeys] = key;
             }
 
             // We must only call `uploadDeviceSigningKeys` from inside this auth
             // helper to ensure we properly handle auth errors.
-            await this.crossSigningKeys.authUpload?.(authDict => {
+            await this.crossSigningKeys.authUpload?.((authDict) => {
                 return baseApis.uploadDeviceSigningKeys(authDict, keys as CrossSigningKeys);
             });
 
@@ -222,8 +213,10 @@ export class EncryptionSetupOperation {
                 // Sign the backup with the cross signing key so the key backup can
                 // be trusted via cross-signing.
                 await baseApis.http.authedRequest(
-                    Method.Put, "/room_keys/version/" + this.keyBackupInfo.version,
-                    undefined, {
+                    Method.Put,
+                    "/room_keys/version/" + this.keyBackupInfo.version,
+                    undefined,
+                    {
                         algorithm: this.keyBackupInfo.algorithm,
                         auth_data: this.keyBackupInfo.auth_data,
                     },
@@ -231,11 +224,9 @@ export class EncryptionSetupOperation {
                 );
             } else {
                 // add new key backup
-                await baseApis.http.authedRequest(
-                    Method.Post, "/room_keys/version",
-                    undefined, this.keyBackupInfo,
-                    { prefix: ClientPrefix.V3 },
-                );
+                await baseApis.http.authedRequest(Method.Post, "/room_keys/version", undefined, this.keyBackupInfo, {
+                    prefix: ClientPrefix.V3,
+                });
             }
         }
     }
@@ -247,7 +238,8 @@ export class EncryptionSetupOperation {
  */
 class AccountDataClientAdapter
     extends TypedEventEmitter<ClientEvent.AccountData, ClientEventHandlerMap>
-    implements IAccountDataClient {
+    implements IAccountDataClient
+{
     //
     public readonly values = new Map<string, MatrixEvent>();
 
@@ -261,7 +253,7 @@ class AccountDataClientAdapter
     /**
      * @returns the content of the account data
      */
-    public getAccountDataFromServer<T extends {[k: string]: any}>(type: string): Promise<T> {
+    public getAccountDataFromServer<T extends { [k: string]: any }>(type: string): Promise<T> {
         return Promise.resolve(this.getAccountData(type) as T);
     }
 
@@ -336,7 +328,7 @@ class SSSSCryptoCallbacks {
     public async getSecretStorageKey(
         { keys }: { keys: Record<string, ISecretStorageKeyInfo> },
         name: string,
-    ): Promise<[string, Uint8Array]|null> {
+    ): Promise<[string, Uint8Array] | null> {
         for (const keyId of Object.keys(keys)) {
             const privateKey = this.privateKeys.get(keyId);
             if (privateKey) {
@@ -346,8 +338,7 @@ class SSSSCryptoCallbacks {
         // if we don't have the key cached yet, ask
         // for it to the general crypto callbacks and cache it
         if (this?.delegateCryptoCallbacks?.getSecretStorageKey) {
-            const result = await this.delegateCryptoCallbacks.
-                getSecretStorageKey({ keys }, name);
+            const result = await this.delegateCryptoCallbacks.getSecretStorageKey({ keys }, name);
             if (result) {
                 const [keyId, privateKey] = result;
                 this.privateKeys.set(keyId, privateKey);
diff --git a/src/crypto/OlmDevice.ts b/src/crypto/OlmDevice.ts
index d7d62099d82..9d342b8cc16 100644
--- a/src/crypto/OlmDevice.ts
+++ b/src/crypto/OlmDevice.ts
@@ -16,9 +16,9 @@ limitations under the License.
 
 import { Account, InboundGroupSession, OutboundGroupSession, Session, Utility } from "@matrix-org/olm";
 
-import { logger, PrefixedLogger } from '../logger';
-import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
-import * as algorithms from './algorithms';
+import { logger, PrefixedLogger } from "../logger";
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store";
+import * as algorithms from "./algorithms";
 import { CryptoStore, IProblem, ISessionInfo, IWithheld } from "./store/base";
 import { IOlmDevice, IOutboundGroupSessionKey } from "./algorithms/megolm";
 import { IMegolmSessionData } from "./index";
@@ -27,7 +27,7 @@ import { IMessage } from "./algorithms/olm";
 
 // The maximum size of an event is 65K, and we base64 the content, so this is a
 // reasonable approximation to the biggest plaintext we can encrypt.
-const MAX_PLAINTEXT_LENGTH = 65536 * 3 / 4;
+const MAX_PLAINTEXT_LENGTH = (65536 * 3) / 4;
 
 export class PayloadTooLargeError extends Error {
     public readonly data = {
@@ -48,8 +48,10 @@ function checkPayloadLength(payloadString: string): void {
         // Note that even if we manage to do the encryption, the message send may fail,
         // because by the time we've wrapped the ciphertext in the event object, it may
         // exceed 65K. But at least we won't just fail with "abort()" in that case.
-        throw new PayloadTooLargeError(`Message too long (${payloadString.length} bytes). ` +
-            `The maximum for an encrypted message is ${MAX_PLAINTEXT_LENGTH} bytes.`);
+        throw new PayloadTooLargeError(
+            `Message too long (${payloadString.length} bytes). ` +
+                `The maximum for an encrypted message is ${MAX_PLAINTEXT_LENGTH} bytes.`,
+        );
     }
 }
 
@@ -143,7 +145,7 @@ export class OlmDevice {
     //
     // Keys are strings of form "<senderKey>|<session_id>|<message_index>"
     // Values are objects of the form "{id: <event id>, timestamp: <ts>}"
-    private inboundGroupSessionMessageIndexes: Record<string, { id: string, timestamp: number }> = {};
+    private inboundGroupSessionMessageIndexes: Record<string, { id: string; timestamp: number }> = {};
 
     // Keep track of sessions that we're starting, so that we don't start
     // multiple sessions for the same device at the same time.
@@ -152,8 +154,7 @@ export class OlmDevice {
     // Used by olm to serialise prekey message decryptions
     public olmPrekeyPromise: Promise<any> = Promise.resolve(); // set by consumers
 
-    public constructor(private readonly cryptoStore: CryptoStore) {
-    }
+    public constructor(private readonly cryptoStore: CryptoStore) {}
 
     /**
      * @returns The version of Olm.
@@ -187,10 +188,7 @@ export class OlmDevice {
         try {
             if (fromExportedDevice) {
                 if (pickleKey) {
-                    logger.warn(
-                        'ignoring opts.pickleKey'
-                        + ' because opts.fromExportedDevice is present.',
-                    );
+                    logger.warn("ignoring opts.pickleKey" + " because opts.fromExportedDevice is present.");
                 }
                 this.pickleKey = fromExportedDevice.pickleKey;
                 await this.initialiseFromExportedDevice(fromExportedDevice, account);
@@ -222,49 +220,35 @@ export class OlmDevice {
      */
     private async initialiseFromExportedDevice(exportedData: IExportedDevice, account: Account): Promise<void> {
         await this.cryptoStore.doTxn(
-            'readwrite',
-            [
-                IndexedDBCryptoStore.STORE_ACCOUNT,
-                IndexedDBCryptoStore.STORE_SESSIONS,
-            ],
+            "readwrite",
+            [IndexedDBCryptoStore.STORE_ACCOUNT, IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.cryptoStore.storeAccount(txn, exportedData.pickledAccount);
                 exportedData.sessions.forEach((session) => {
-                    const {
-                        deviceKey,
-                        sessionId,
-                    } = session;
+                    const { deviceKey, sessionId } = session;
                     const sessionInfo = {
                         session: session.session,
                         lastReceivedMessageTs: session.lastReceivedMessageTs,
                     };
-                    this.cryptoStore.storeEndToEndSession(
-                        deviceKey!,
-                        sessionId!,
-                        sessionInfo,
-                        txn,
-                    );
+                    this.cryptoStore.storeEndToEndSession(deviceKey!, sessionId!, sessionInfo, txn);
                 });
-            });
+            },
+        );
         account.unpickle(this.pickleKey, exportedData.pickledAccount);
     }
 
     private async initialiseAccount(account: Account): Promise<void> {
-        await this.cryptoStore.doTxn(
-            'readwrite',
-            [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.cryptoStore.getAccount(txn, (pickledAccount) => {
-                    if (pickledAccount !== null) {
-                        account.unpickle(this.pickleKey, pickledAccount);
-                    } else {
-                        account.create();
-                        pickledAccount = account.pickle(this.pickleKey);
-                        this.cryptoStore.storeAccount(txn, pickledAccount);
-                    }
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.cryptoStore.getAccount(txn, (pickledAccount) => {
+                if (pickledAccount !== null) {
+                    account.unpickle(this.pickleKey, pickledAccount);
+                } else {
+                    account.create();
+                    pickledAccount = account.pickle(this.pickleKey);
+                    this.cryptoStore.storeAccount(txn, pickledAccount);
+                }
+            });
+        });
     }
 
     /**
@@ -316,11 +300,8 @@ export class OlmDevice {
         };
 
         await this.cryptoStore.doTxn(
-            'readonly',
-            [
-                IndexedDBCryptoStore.STORE_ACCOUNT,
-                IndexedDBCryptoStore.STORE_SESSIONS,
-            ],
+            "readonly",
+            [IndexedDBCryptoStore.STORE_ACCOUNT, IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.cryptoStore.getAccount(txn, (pickledAccount: string | null) => {
                     result.pickledAccount = pickledAccount!;
@@ -352,11 +333,9 @@ export class OlmDevice {
         txn: unknown,
         func: (unpickledSessionInfo: IUnpickledSessionInfo) => void,
     ): void {
-        this.cryptoStore.getEndToEndSession(
-            deviceKey, sessionId, txn, (sessionInfo: ISessionInfo | null) => {
-                this.unpickleSession(sessionInfo!, func);
-            },
-        );
+        this.cryptoStore.getEndToEndSession(deviceKey, sessionId, txn, (sessionInfo: ISessionInfo | null) => {
+            this.unpickleSession(sessionInfo!, func);
+        });
     }
 
     /**
@@ -419,13 +398,11 @@ export class OlmDevice {
      */
     public async sign(message: string): Promise<string> {
         let result: string;
-        await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.getAccount(txn, (account: Account) => {
-                    result = account.sign(message);
-                });
+        await this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.getAccount(txn, (account: Account) => {
+                result = account.sign(message);
             });
+        });
         return result!;
     }
 
@@ -438,14 +415,11 @@ export class OlmDevice {
      */
     public async getOneTimeKeys(): Promise<OneTimeKeys> {
         let result: OneTimeKeys;
-        await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.getAccount(txn, (account) => {
-                    result = JSON.parse(account.one_time_keys());
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.getAccount(txn, (account) => {
+                result = JSON.parse(account.one_time_keys());
+            });
+        });
 
         return result!;
     }
@@ -463,15 +437,12 @@ export class OlmDevice {
      * Marks all of the one-time keys as published.
      */
     public async markKeysAsPublished(): Promise<void> {
-        await this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.getAccount(txn, (account: Account) => {
-                    account.mark_keys_as_published();
-                    this.storeAccount(txn, account);
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.getAccount(txn, (account: Account) => {
+                account.mark_keys_as_published();
+                this.storeAccount(txn, account);
+            });
+        });
     }
 
     /**
@@ -481,15 +452,12 @@ export class OlmDevice {
      * @returns Resolved once the account is saved back having generated the keys
      */
     public generateOneTimeKeys(numKeys: number): Promise<void> {
-        return this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.getAccount(txn, (account) => {
-                    account.generate_one_time_keys(numKeys);
-                    this.storeAccount(txn, account);
-                });
-            },
-        );
+        return this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.getAccount(txn, (account) => {
+                account.generate_one_time_keys(numKeys);
+                this.storeAccount(txn, account);
+            });
+        });
     }
 
     /**
@@ -498,40 +466,31 @@ export class OlmDevice {
      * @returns Resolved once the account is saved back having generated the key
      */
     public async generateFallbackKey(): Promise<void> {
-        await this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.getAccount(txn, (account) => {
-                    account.generate_fallback_key();
-                    this.storeAccount(txn, account);
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.getAccount(txn, (account) => {
+                account.generate_fallback_key();
+                this.storeAccount(txn, account);
+            });
+        });
     }
 
     public async getFallbackKey(): Promise<Record<string, Record<string, string>>> {
         let result: Record<string, Record<string, string>>;
-        await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.getAccount(txn, (account: Account) => {
-                    result = JSON.parse(account.unpublished_fallback_key());
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.getAccount(txn, (account: Account) => {
+                result = JSON.parse(account.unpublished_fallback_key());
+            });
+        });
         return result!;
     }
 
     public async forgetOldFallbackKey(): Promise<void> {
-        await this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.getAccount(txn, (account: Account) => {
-                    account.forget_old_fallback_key();
-                    this.storeAccount(txn, account);
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.getAccount(txn, (account: Account) => {
+                account.forget_old_fallback_key();
+                this.storeAccount(txn, account);
+            });
+        });
     }
 
     /**
@@ -546,10 +505,8 @@ export class OlmDevice {
     public async createOutboundSession(theirIdentityKey: string, theirOneTimeKey: string): Promise<string> {
         let newSessionId: string;
         await this.cryptoStore.doTxn(
-            'readwrite', [
-                IndexedDBCryptoStore.STORE_ACCOUNT,
-                IndexedDBCryptoStore.STORE_SESSIONS,
-            ],
+            "readwrite",
+            [IndexedDBCryptoStore.STORE_ACCOUNT, IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.getAccount(txn, (account: Account) => {
                     const session = new global.Olm.Session();
@@ -596,12 +553,10 @@ export class OlmDevice {
             throw new Error("Need messageType == 0 to create inbound session");
         }
 
-        let result: { payload: string, session_id: string }; // eslint-disable-line camelcase
+        let result: { payload: string; session_id: string }; // eslint-disable-line camelcase
         await this.cryptoStore.doTxn(
-            'readwrite', [
-                IndexedDBCryptoStore.STORE_ACCOUNT,
-                IndexedDBCryptoStore.STORE_SESSIONS,
-            ],
+            "readwrite",
+            [IndexedDBCryptoStore.STORE_ACCOUNT, IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.getAccount(txn, (account: Account) => {
                     const session = new global.Olm.Session();
@@ -656,13 +611,12 @@ export class OlmDevice {
         }
         let sessionIds: string[];
         await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_SESSIONS],
+            "readonly",
+            [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
-                this.cryptoStore.getEndToEndSessions(
-                    theirDeviceIdentityKey, txn, (sessions) => {
-                        sessionIds = Object.keys(sessions);
-                    },
-                );
+                this.cryptoStore.getEndToEndSessions(theirDeviceIdentityKey, txn, (sessions) => {
+                    sessionIds = Object.keys(sessions);
+                });
             },
             log,
         );
@@ -695,17 +649,15 @@ export class OlmDevice {
         let idxOfBest = 0;
         for (let i = 1; i < sessionInfos.length; i++) {
             const thisSessInfo = sessionInfos[i];
-            const thisLastReceived = thisSessInfo.lastReceivedMessageTs === undefined ?
-                0 : thisSessInfo.lastReceivedMessageTs;
+            const thisLastReceived =
+                thisSessInfo.lastReceivedMessageTs === undefined ? 0 : thisSessInfo.lastReceivedMessageTs;
 
             const bestSessInfo = sessionInfos[idxOfBest];
-            const bestLastReceived = bestSessInfo.lastReceivedMessageTs === undefined ?
-                0 : bestSessInfo.lastReceivedMessageTs;
+            const bestLastReceived =
+                bestSessInfo.lastReceivedMessageTs === undefined ? 0 : bestSessInfo.lastReceivedMessageTs;
             if (
-                thisLastReceived > bestLastReceived || (
-                    thisLastReceived === bestLastReceived &&
-                    thisSessInfo.sessionId < bestSessInfo.sessionId
-                )
+                thisLastReceived > bestLastReceived ||
+                (thisLastReceived === bestLastReceived && thisSessInfo.sessionId < bestSessInfo.sessionId)
             ) {
                 idxOfBest = i;
             }
@@ -731,7 +683,7 @@ export class OlmDevice {
         deviceIdentityKey: string,
         nowait = false,
         log = logger,
-    ): Promise<{ sessionId: string, lastReceivedMessageTs: number, hasReceivedMessage: boolean }[]> {
+    ): Promise<{ sessionId: string; lastReceivedMessageTs: number; hasReceivedMessage: boolean }[]> {
         log = log.withPrefix("[getSessionInfoForDevice]");
 
         if (deviceIdentityKey in this.sessionsInProgress && !nowait) {
@@ -750,7 +702,8 @@ export class OlmDevice {
         }[] = [];
 
         await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_SESSIONS],
+            "readonly",
+            [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.cryptoStore.getEndToEndSessions(deviceIdentityKey, txn, (sessions) => {
                     const sessionIds = Object.keys(sessions).sort();
@@ -790,13 +743,18 @@ export class OlmDevice {
 
         let res: IMessage;
         await this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_SESSIONS],
+            "readwrite",
+            [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.getSession(theirDeviceIdentityKey, sessionId, txn, (sessionInfo) => {
                     const sessionDesc = sessionInfo.session.describe();
                     logger.log(
-                        "encryptMessage: Olm Session ID " + sessionId + " to " +
-                        theirDeviceIdentityKey + ": " + sessionDesc,
+                        "encryptMessage: Olm Session ID " +
+                            sessionId +
+                            " to " +
+                            theirDeviceIdentityKey +
+                            ": " +
+                            sessionDesc,
                     );
                     res = sessionInfo.session.encrypt(payloadString);
                     this.saveSession(theirDeviceIdentityKey, sessionInfo, txn);
@@ -826,13 +784,18 @@ export class OlmDevice {
     ): Promise<string> {
         let payloadString: string;
         await this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_SESSIONS],
+            "readwrite",
+            [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.getSession(theirDeviceIdentityKey, sessionId, txn, (sessionInfo: IUnpickledSessionInfo) => {
                     const sessionDesc = sessionInfo.session.describe();
                     logger.log(
-                        "decryptMessage: Olm Session ID " + sessionId + " from " +
-                        theirDeviceIdentityKey + ": " + sessionDesc,
+                        "decryptMessage: Olm Session ID " +
+                            sessionId +
+                            " from " +
+                            theirDeviceIdentityKey +
+                            ": " +
+                            sessionDesc,
                     );
                     payloadString = sessionInfo.session.decrypt(messageType, ciphertext);
                     sessionInfo.lastReceivedMessageTs = Date.now();
@@ -868,7 +831,8 @@ export class OlmDevice {
 
         let matches: boolean;
         await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_SESSIONS],
+            "readonly",
+            [IndexedDBCryptoStore.STORE_SESSIONS],
             (txn) => {
                 this.getSession(theirDeviceIdentityKey, sessionId, txn, (sessionInfo) => {
                     matches = sessionInfo.session.matches_inbound(ciphertext);
@@ -971,7 +935,7 @@ export class OlmDevice {
      *     base64-encoded secret key.
      */
     public getOutboundGroupSessionKey(sessionId: string): IOutboundGroupSessionKey {
-        return this.getOutboundGroupSession(sessionId, function(session: OutboundGroupSession) {
+        return this.getOutboundGroupSession(sessionId, function (session: OutboundGroupSession) {
             return {
                 chain_index: session.message_index(),
                 key: session.session_key(),
@@ -1025,7 +989,10 @@ export class OlmDevice {
         ) => void,
     ): void {
         this.cryptoStore.getEndToEndInboundGroupSession(
-            senderKey, sessionId, txn, (sessionData: InboundGroupSessionData | null, withheld: IWithheld | null) => {
+            senderKey,
+            sessionId,
+            txn,
+            (sessionData: InboundGroupSessionData | null, withheld: IWithheld | null) => {
                 if (sessionData === null) {
                     func(null, null, withheld);
                     return;
@@ -1036,7 +1003,10 @@ export class OlmDevice {
                 if (roomId !== null && roomId !== sessionData.room_id) {
                     throw new Error(
                         "Mismatched room_id for inbound group session (expected " +
-                        sessionData.room_id + ", was " + roomId + ")",
+                            sessionData.room_id +
+                            ", was " +
+                            roomId +
+                            ")",
                     );
                 }
 
@@ -1072,97 +1042,101 @@ export class OlmDevice {
         extraSessionData: OlmGroupSessionExtraData = {},
     ): Promise<void> {
         await this.cryptoStore.doTxn(
-            'readwrite', [
+            "readwrite",
+            [
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,
                 IndexedDBCryptoStore.STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS,
-            ], (txn) => {
+            ],
+            (txn) => {
                 /* if we already have this session, consider updating it */
-                this.getInboundGroupSession(roomId, senderKey, sessionId, txn, (
-                    existingSession: InboundGroupSession | null,
-                    existingSessionData: InboundGroupSessionData | null,
-                ) => {
-                    // new session.
-                    const session = new global.Olm.InboundGroupSession();
-                    try {
-                        if (exportFormat) {
-                            session.import_session(sessionKey);
-                        } else {
-                            session.create(sessionKey);
-                        }
-                        if (sessionId != session.session_id()) {
-                            throw new Error(
-                                "Mismatched group session ID from senderKey: " +
-                                senderKey,
-                            );
-                        }
+                this.getInboundGroupSession(
+                    roomId,
+                    senderKey,
+                    sessionId,
+                    txn,
+                    (
+                        existingSession: InboundGroupSession | null,
+                        existingSessionData: InboundGroupSessionData | null,
+                    ) => {
+                        // new session.
+                        const session = new global.Olm.InboundGroupSession();
+                        try {
+                            if (exportFormat) {
+                                session.import_session(sessionKey);
+                            } else {
+                                session.create(sessionKey);
+                            }
+                            if (sessionId != session.session_id()) {
+                                throw new Error("Mismatched group session ID from senderKey: " + senderKey);
+                            }
 
-                        if (existingSession) {
-                            logger.log(`Update for megolm session ${senderKey}|${sessionId}`);
-                            if (existingSession.first_known_index() <= session.first_known_index()) {
-                                if (!existingSessionData!.untrusted || extraSessionData.untrusted) {
-                                    // existing session has less-than-or-equal index
-                                    // (i.e. can decrypt at least as much), and the
-                                    // new session's trust does not win over the old
-                                    // session's trust, so keep it
-                                    logger.log(`Keeping existing megolm session ${senderKey}|${sessionId}`);
-                                    return;
-                                }
-                                if (existingSession.first_known_index() < session.first_known_index()) {
-                                    // We want to upgrade the existing session's trust,
-                                    // but we can't just use the new session because we'll
-                                    // lose the lower index. Check that the sessions connect
-                                    // properly, and then manually set the existing session
-                                    // as trusted.
-                                    if (
-                                        existingSession.export_session(session.first_known_index())
-                                        === session.export_session(session.first_known_index())
-                                    ) {
-                                        logger.info(
-                                            "Upgrading trust of existing megolm session " +
-                                            `${senderKey}|${sessionId} based on newly-received trusted session`,
-                                        );
-                                        existingSessionData!.untrusted = false;
-                                        this.cryptoStore.storeEndToEndInboundGroupSession(
-                                            senderKey, sessionId, existingSessionData!, txn,
-                                        );
-                                    } else {
-                                        logger.warn(
-                                            `Newly-received megolm session ${senderKey}|$sessionId}` +
-                                            " does not match existing session! Keeping existing session",
-                                        );
+                            if (existingSession) {
+                                logger.log(`Update for megolm session ${senderKey}|${sessionId}`);
+                                if (existingSession.first_known_index() <= session.first_known_index()) {
+                                    if (!existingSessionData!.untrusted || extraSessionData.untrusted) {
+                                        // existing session has less-than-or-equal index
+                                        // (i.e. can decrypt at least as much), and the
+                                        // new session's trust does not win over the old
+                                        // session's trust, so keep it
+                                        logger.log(`Keeping existing megolm session ${senderKey}|${sessionId}`);
+                                        return;
+                                    }
+                                    if (existingSession.first_known_index() < session.first_known_index()) {
+                                        // We want to upgrade the existing session's trust,
+                                        // but we can't just use the new session because we'll
+                                        // lose the lower index. Check that the sessions connect
+                                        // properly, and then manually set the existing session
+                                        // as trusted.
+                                        if (
+                                            existingSession.export_session(session.first_known_index()) ===
+                                            session.export_session(session.first_known_index())
+                                        ) {
+                                            logger.info(
+                                                "Upgrading trust of existing megolm session " +
+                                                    `${senderKey}|${sessionId} based on newly-received trusted session`,
+                                            );
+                                            existingSessionData!.untrusted = false;
+                                            this.cryptoStore.storeEndToEndInboundGroupSession(
+                                                senderKey,
+                                                sessionId,
+                                                existingSessionData!,
+                                                txn,
+                                            );
+                                        } else {
+                                            logger.warn(
+                                                `Newly-received megolm session ${senderKey}|$sessionId}` +
+                                                    " does not match existing session! Keeping existing session",
+                                            );
+                                        }
+                                        return;
                                     }
-                                    return;
+                                    // If the sessions have the same index, go ahead and store the new trusted one.
                                 }
-                                // If the sessions have the same index, go ahead and store the new trusted one.
                             }
-                        }
 
-                        logger.info(
-                            `Storing megolm session ${senderKey}|${sessionId} with first index `+
-                            session.first_known_index(),
-                        );
+                            logger.info(
+                                `Storing megolm session ${senderKey}|${sessionId} with first index ` +
+                                    session.first_known_index(),
+                            );
 
-                        const sessionData = Object.assign({}, extraSessionData, {
-                            room_id: roomId,
-                            session: session.pickle(this.pickleKey),
-                            keysClaimed: keysClaimed,
-                            forwardingCurve25519KeyChain: forwardingCurve25519KeyChain,
-                        });
+                            const sessionData = Object.assign({}, extraSessionData, {
+                                room_id: roomId,
+                                session: session.pickle(this.pickleKey),
+                                keysClaimed: keysClaimed,
+                                forwardingCurve25519KeyChain: forwardingCurve25519KeyChain,
+                            });
 
-                        this.cryptoStore.storeEndToEndInboundGroupSession(
-                            senderKey, sessionId, sessionData, txn,
-                        );
+                            this.cryptoStore.storeEndToEndInboundGroupSession(senderKey, sessionId, sessionData, txn);
 
-                        if (!existingSession && extraSessionData.sharedHistory) {
-                            this.cryptoStore.addSharedHistoryInboundGroupSession(
-                                roomId, senderKey, sessionId, txn,
-                            );
+                            if (!existingSession && extraSessionData.sharedHistory) {
+                                this.cryptoStore.addSharedHistoryInboundGroupSession(roomId, senderKey, sessionId, txn);
+                            }
+                        } finally {
+                            session.free();
                         }
-                    } finally {
-                        session.free();
-                    }
-                });
+                    },
+                );
             },
             logger.withPrefix("[addInboundGroupSession]"),
         );
@@ -1185,10 +1159,12 @@ export class OlmDevice {
         reason: string,
     ): Promise<void> {
         await this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD],
+            "readwrite",
+            [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD],
             (txn) => {
                 this.cryptoStore.storeEndToEndInboundGroupSessionWithheld(
-                    senderKey, sessionId,
+                    senderKey,
+                    sessionId,
                     {
                         room_id: roomId,
                         code: code,
@@ -1228,91 +1204,79 @@ export class OlmDevice {
         let error: Error;
 
         await this.cryptoStore.doTxn(
-            'readwrite', [
+            "readwrite",
+            [
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,
-            ], (txn) => {
-                this.getInboundGroupSession(
-                    roomId, senderKey, sessionId, txn, (session, sessionData, withheld) => {
-                        if (session === null || sessionData === null) {
-                            if (withheld) {
-                                error = new algorithms.DecryptionError(
-                                    "MEGOLM_UNKNOWN_INBOUND_SESSION_ID",
-                                    calculateWithheldMessage(withheld),
-                                    {
-                                        session: senderKey + '|' + sessionId,
-                                    },
-                                );
-                            }
-                            result = null;
-                            return;
+            ],
+            (txn) => {
+                this.getInboundGroupSession(roomId, senderKey, sessionId, txn, (session, sessionData, withheld) => {
+                    if (session === null || sessionData === null) {
+                        if (withheld) {
+                            error = new algorithms.DecryptionError(
+                                "MEGOLM_UNKNOWN_INBOUND_SESSION_ID",
+                                calculateWithheldMessage(withheld),
+                                {
+                                    session: senderKey + "|" + sessionId,
+                                },
+                            );
                         }
-                        let res: ReturnType<InboundGroupSession["decrypt"]>;
-                        try {
-                            res = session.decrypt(body);
-                        } catch (e) {
-                            if ((<Error>e)?.message === 'OLM.UNKNOWN_MESSAGE_INDEX' && withheld) {
-                                error = new algorithms.DecryptionError(
-                                    "MEGOLM_UNKNOWN_INBOUND_SESSION_ID",
-                                    calculateWithheldMessage(withheld),
-                                    {
-                                        session: senderKey + '|' + sessionId,
-                                    },
-                                );
-                            } else {
-                                error = <Error>e;
-                            }
-                            return;
+                        result = null;
+                        return;
+                    }
+                    let res: ReturnType<InboundGroupSession["decrypt"]>;
+                    try {
+                        res = session.decrypt(body);
+                    } catch (e) {
+                        if ((<Error>e)?.message === "OLM.UNKNOWN_MESSAGE_INDEX" && withheld) {
+                            error = new algorithms.DecryptionError(
+                                "MEGOLM_UNKNOWN_INBOUND_SESSION_ID",
+                                calculateWithheldMessage(withheld),
+                                {
+                                    session: senderKey + "|" + sessionId,
+                                },
+                            );
+                        } else {
+                            error = <Error>e;
                         }
+                        return;
+                    }
 
-                        let plaintext: string = res.plaintext;
-                        if (plaintext === undefined) {
-                            // @ts-ignore - Compatibility for older olm versions.
-                            plaintext = res as string;
-                        } else {
-                            // Check if we have seen this message index before to detect replay attacks.
-                            // If the event ID and timestamp are specified, and the match the event ID
-                            // and timestamp from the last time we used this message index, then we
-                            // don't consider it a replay attack.
-                            const messageIndexKey = (
-                                senderKey + "|" + sessionId + "|" + res.message_index
-                            );
-                            if (messageIndexKey in this.inboundGroupSessionMessageIndexes) {
-                                const msgInfo = (
-                                    this.inboundGroupSessionMessageIndexes[messageIndexKey]
+                    let plaintext: string = res.plaintext;
+                    if (plaintext === undefined) {
+                        // @ts-ignore - Compatibility for older olm versions.
+                        plaintext = res as string;
+                    } else {
+                        // Check if we have seen this message index before to detect replay attacks.
+                        // If the event ID and timestamp are specified, and the match the event ID
+                        // and timestamp from the last time we used this message index, then we
+                        // don't consider it a replay attack.
+                        const messageIndexKey = senderKey + "|" + sessionId + "|" + res.message_index;
+                        if (messageIndexKey in this.inboundGroupSessionMessageIndexes) {
+                            const msgInfo = this.inboundGroupSessionMessageIndexes[messageIndexKey];
+                            if (msgInfo.id !== eventId || msgInfo.timestamp !== timestamp) {
+                                error = new Error(
+                                    "Duplicate message index, possible replay attack: " + messageIndexKey,
                                 );
-                                if (
-                                    msgInfo.id !== eventId ||
-                                    msgInfo.timestamp !== timestamp
-                                ) {
-                                    error = new Error(
-                                        "Duplicate message index, possible replay attack: " +
-                                        messageIndexKey,
-                                    );
-                                    return;
-                                }
+                                return;
                             }
-                            this.inboundGroupSessionMessageIndexes[messageIndexKey] = {
-                                id: eventId,
-                                timestamp: timestamp,
-                            };
                         }
-
-                        sessionData.session = session.pickle(this.pickleKey);
-                        this.cryptoStore.storeEndToEndInboundGroupSession(
-                            senderKey, sessionId, sessionData, txn,
-                        );
-                        result = {
-                            result: plaintext,
-                            keysClaimed: sessionData.keysClaimed || {},
-                            senderKey: senderKey,
-                            forwardingCurve25519KeyChain: (
-                                sessionData.forwardingCurve25519KeyChain || []
-                            ),
-                            untrusted: !!sessionData.untrusted,
+                        this.inboundGroupSessionMessageIndexes[messageIndexKey] = {
+                            id: eventId,
+                            timestamp: timestamp,
                         };
-                    },
-                );
+                    }
+
+                    sessionData.session = session.pickle(this.pickleKey);
+                    this.cryptoStore.storeEndToEndInboundGroupSession(senderKey, sessionId, sessionData, txn);
+                    result = {
+                        result: plaintext,
+                        keysClaimed: sessionData.keysClaimed || {},
+                        senderKey: senderKey,
+                        forwardingCurve25519KeyChain: sessionData.forwardingCurve25519KeyChain || [],
+                        untrusted: !!sessionData.untrusted,
+                    };
+                });
             },
             logger.withPrefix("[decryptGroupMessage]"),
         );
@@ -1335,30 +1299,30 @@ export class OlmDevice {
     public async hasInboundSessionKeys(roomId: string, senderKey: string, sessionId: string): Promise<boolean> {
         let result: boolean;
         await this.cryptoStore.doTxn(
-            'readonly', [
+            "readonly",
+            [
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,
-            ], (txn) => {
-                this.cryptoStore.getEndToEndInboundGroupSession(
-                    senderKey, sessionId, txn, (sessionData) => {
-                        if (sessionData === null) {
-                            result = false;
-                            return;
-                        }
+            ],
+            (txn) => {
+                this.cryptoStore.getEndToEndInboundGroupSession(senderKey, sessionId, txn, (sessionData) => {
+                    if (sessionData === null) {
+                        result = false;
+                        return;
+                    }
 
-                        if (roomId !== sessionData.room_id) {
-                            logger.warn(
-                                `requested keys for inbound group session ${senderKey}|` +
+                    if (roomId !== sessionData.room_id) {
+                        logger.warn(
+                            `requested keys for inbound group session ${senderKey}|` +
                                 `${sessionId}, with incorrect room_id ` +
                                 `(expected ${sessionData.room_id}, ` +
                                 `was ${roomId})`,
-                            );
-                            result = false;
-                        } else {
-                            result = true;
-                        }
-                    },
-                );
+                        );
+                        result = false;
+                    } else {
+                        result = true;
+                    }
+                });
             },
             logger.withPrefix("[hasInboundSessionKeys]"),
         );
@@ -1390,46 +1354,45 @@ export class OlmDevice {
     ): Promise<IInboundGroupSessionKey | null> {
         let result: IInboundGroupSessionKey | null = null;
         await this.cryptoStore.doTxn(
-            'readonly', [
+            "readonly",
+            [
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
                 IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,
-            ], (txn) => {
-                this.getInboundGroupSession(
-                    roomId, senderKey, sessionId, txn, (session, sessionData) => {
-                        if (session === null || sessionData === null) {
-                            result = null;
-                            return;
-                        }
-
-                        if (chainIndex === undefined) {
-                            chainIndex = session.first_known_index();
-                        }
-
-                        const exportedSession = session.export_session(chainIndex);
-
-                        const claimedKeys = sessionData.keysClaimed || {};
-                        const senderEd25519Key = claimedKeys.ed25519 || null;
+            ],
+            (txn) => {
+                this.getInboundGroupSession(roomId, senderKey, sessionId, txn, (session, sessionData) => {
+                    if (session === null || sessionData === null) {
+                        result = null;
+                        return;
+                    }
 
-                        const forwardingKeyChain = sessionData.forwardingCurve25519KeyChain || [];
-                        // older forwarded keys didn't set the "untrusted"
-                        // property, but can be identified by having a
-                        // non-empty forwarding key chain.  These keys should
-                        // be marked as untrusted since we don't know that they
-                        // can be trusted
-                        const untrusted = "untrusted" in sessionData
-                            ? sessionData.untrusted
-                            : forwardingKeyChain.length > 0;
+                    if (chainIndex === undefined) {
+                        chainIndex = session.first_known_index();
+                    }
 
-                        result = {
-                            "chain_index": chainIndex,
-                            "key": exportedSession,
-                            "forwarding_curve25519_key_chain": forwardingKeyChain,
-                            "sender_claimed_ed25519_key": senderEd25519Key,
-                            "shared_history": sessionData.sharedHistory || false,
-                            "untrusted": untrusted,
-                        };
-                    },
-                );
+                    const exportedSession = session.export_session(chainIndex);
+
+                    const claimedKeys = sessionData.keysClaimed || {};
+                    const senderEd25519Key = claimedKeys.ed25519 || null;
+
+                    const forwardingKeyChain = sessionData.forwardingCurve25519KeyChain || [];
+                    // older forwarded keys didn't set the "untrusted"
+                    // property, but can be identified by having a
+                    // non-empty forwarding key chain.  These keys should
+                    // be marked as untrusted since we don't know that they
+                    // can be trusted
+                    const untrusted =
+                        "untrusted" in sessionData ? sessionData.untrusted : forwardingKeyChain.length > 0;
+
+                    result = {
+                        chain_index: chainIndex,
+                        key: exportedSession,
+                        forwarding_curve25519_key_chain: forwardingKeyChain,
+                        sender_claimed_ed25519_key: senderEd25519Key,
+                        shared_history: sessionData.sharedHistory || false,
+                        untrusted: untrusted,
+                    };
+                });
             },
             logger.withPrefix("[getInboundGroupSessionKey]"),
         );
@@ -1471,9 +1434,9 @@ export class OlmDevice {
     ): Promise<[senderKey: string, sessionId: string][]> {
         let result: Promise<[senderKey: string, sessionId: string][]>;
         await this.cryptoStore.doTxn(
-            'readonly', [
-                IndexedDBCryptoStore.STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS,
-            ], (txn) => {
+            "readonly",
+            [IndexedDBCryptoStore.STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS],
+            (txn) => {
                 result = this.cryptoStore.getSharedHistoryInboundGroupSessions(roomId, txn);
             },
             logger.withPrefix("[getSharedHistoryInboundGroupSessionsForRoom]"),
@@ -1495,12 +1458,8 @@ export class OlmDevice {
      * too small then the message will be "OLM.INVALID_BASE64". If the signature
      * was invalid then the message will be "OLM.BAD_MESSAGE_MAC".
      */
-    public verifySignature(
-        key: string,
-        message: string,
-        signature: string,
-    ): void {
-        this.getUtility(function(util: Utility) {
+    public verifySignature(key: string, message: string, signature: string): void {
+        this.getUtility(function (util: Utility) {
             util.ed25519_verify(key, message, signature);
         });
     }
diff --git a/src/crypto/OutgoingRoomKeyRequestManager.ts b/src/crypto/OutgoingRoomKeyRequestManager.ts
index 833592a4cc1..27bf8389bc0 100644
--- a/src/crypto/OutgoingRoomKeyRequestManager.ts
+++ b/src/crypto/OutgoingRoomKeyRequestManager.ts
@@ -16,10 +16,10 @@ limitations under the License.
 
 import { v4 as uuidv4 } from "uuid";
 
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { MatrixClient } from "../client";
 import { IRoomKeyRequestBody, IRoomKeyRequestRecipient } from "./index";
-import { CryptoStore, OutgoingRoomKeyRequest } from './store/base';
+import { CryptoStore, OutgoingRoomKeyRequest } from "./store/base";
 import { EventType, ToDeviceMessageId } from "../@types/event";
 
 /**
@@ -113,7 +113,7 @@ export class OutgoingRoomKeyRequestManager {
      * Called when the client is stopped. Stops any running background processes.
      */
     public stop(): void {
-        logger.log('stopping OutgoingRoomKeyRequestManager');
+        logger.log("stopping OutgoingRoomKeyRequestManager");
         // stop the timer on the next run
         this.clientRunning = false;
     }
@@ -164,11 +164,13 @@ export class OutgoingRoomKeyRequestManager {
                     // existing request is about to be cancelled.  If we want to
                     // resend, then change the state so that it resends after
                     // cancelling.  Otherwise, just cancel the cancellation.
-                    const state = resend ?
-                        RoomKeyRequestState.CancellationPendingAndWillResend :
-                        RoomKeyRequestState.Sent;
+                    const state = resend
+                        ? RoomKeyRequestState.CancellationPendingAndWillResend
+                        : RoomKeyRequestState.Sent;
                     await this.cryptoStore.updateOutgoingRoomKeyRequest(
-                        req.requestId, RoomKeyRequestState.CancellationPending, {
+                        req.requestId,
+                        RoomKeyRequestState.CancellationPending,
+                        {
                             state,
                             cancellationTxnId: this.baseApis.makeTxnId(),
                         },
@@ -180,18 +182,18 @@ export class OutgoingRoomKeyRequestManager {
                     // resend, then do nothing.  If we do want to, then cancel the
                     // existing request and send a new one.
                     if (resend) {
-                        const state =
-                              RoomKeyRequestState.CancellationPendingAndWillResend;
-                        const updatedReq =
-                              await this.cryptoStore.updateOutgoingRoomKeyRequest(
-                                  req.requestId, RoomKeyRequestState.Sent, {
-                                      state,
-                                      cancellationTxnId: this.baseApis.makeTxnId(),
-                                      // need to use a new transaction ID so that
-                                      // the request gets sent
-                                      requestTxnId: this.baseApis.makeTxnId(),
-                                  },
-                              );
+                        const state = RoomKeyRequestState.CancellationPendingAndWillResend;
+                        const updatedReq = await this.cryptoStore.updateOutgoingRoomKeyRequest(
+                            req.requestId,
+                            RoomKeyRequestState.Sent,
+                            {
+                                state,
+                                cancellationTxnId: this.baseApis.makeTxnId(),
+                                // need to use a new transaction ID so that
+                                // the request gets sent
+                                requestTxnId: this.baseApis.makeTxnId(),
+                            },
+                        );
                         if (!updatedReq) {
                             // updateOutgoingRoomKeyRequest couldn't find the request
                             // in state ROOM_KEY_REQUEST_STATES.SENT, so we must have
@@ -210,15 +212,9 @@ export class OutgoingRoomKeyRequestManager {
                         // here, as it will slow down processing of received keys if we
                         // do.)
                         try {
-                            await this.sendOutgoingRoomKeyRequestCancellation(
-                                updatedReq,
-                                true,
-                            );
+                            await this.sendOutgoingRoomKeyRequestCancellation(updatedReq, true);
                         } catch (e) {
-                            logger.error(
-                                "Error sending room key request cancellation;"
-                                    + " will retry later.", e,
-                            );
+                            logger.error("Error sending room key request cancellation;" + " will retry later.", e);
                         }
                         // The request has transitioned from
                         // CANCELLATION_PENDING_AND_WILL_RESEND to UNSENT. We
@@ -228,7 +224,7 @@ export class OutgoingRoomKeyRequestManager {
                     break;
                 }
                 default:
-                    throw new Error('unhandled state: ' + req.state);
+                    throw new Error("unhandled state: " + req.state);
             }
         }
     }
@@ -241,9 +237,7 @@ export class OutgoingRoomKeyRequestManager {
      *    pending list.
      */
     public cancelRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<unknown> {
-        return this.cryptoStore.getOutgoingRoomKeyRequest(
-            requestBody,
-        ).then((req): unknown => {
+        return this.cryptoStore.getOutgoingRoomKeyRequest(requestBody).then((req): unknown => {
             if (!req) {
                 // no request was made for this key
                 return;
@@ -262,57 +256,49 @@ export class OutgoingRoomKeyRequestManager {
                     // may have seen it, so we still need to send a cancellation
                     // in that case :/
 
-                    logger.log(
-                        'deleting unnecessary room key request for ' +
-                        stringifyRequestBody(requestBody),
-                    );
+                    logger.log("deleting unnecessary room key request for " + stringifyRequestBody(requestBody));
                     return this.cryptoStore.deleteOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Unsent);
 
                 case RoomKeyRequestState.Sent: {
                     // send a cancellation.
-                    return this.cryptoStore.updateOutgoingRoomKeyRequest(
-                        req.requestId, RoomKeyRequestState.Sent, {
+                    return this.cryptoStore
+                        .updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Sent, {
                             state: RoomKeyRequestState.CancellationPending,
                             cancellationTxnId: this.baseApis.makeTxnId(),
-                        },
-                    ).then((updatedReq) => {
-                        if (!updatedReq) {
-                            // updateOutgoingRoomKeyRequest couldn't find the
-                            // request in state ROOM_KEY_REQUEST_STATES.SENT,
-                            // so we must have raced with another tab to mark
-                            // the request cancelled. There is no point in
-                            // sending another cancellation since the other tab
-                            // will do it.
-                            logger.log(
-                                'Tried to cancel room key request for ' +
-                                stringifyRequestBody(requestBody) +
-                                ' but it was already cancelled in another tab',
-                            );
-                            return;
-                        }
-
-                        // We don't want to wait for the timer, so we send it
-                        // immediately. (We might actually end up racing with the timer,
-                        // but that's ok: even if we make the request twice, we'll do it
-                        // with the same transaction_id, so only one message will get
-                        // sent).
-                        //
-                        // (We also don't want to wait for the response from the server
-                        // here, as it will slow down processing of received keys if we
-                        // do.)
-                        this.sendOutgoingRoomKeyRequestCancellation(
-                            updatedReq,
-                        ).catch((e) => {
-                            logger.error(
-                                "Error sending room key request cancellation;"
-                                + " will retry later.", e,
-                            );
-                            this.startTimer();
+                        })
+                        .then((updatedReq) => {
+                            if (!updatedReq) {
+                                // updateOutgoingRoomKeyRequest couldn't find the
+                                // request in state ROOM_KEY_REQUEST_STATES.SENT,
+                                // so we must have raced with another tab to mark
+                                // the request cancelled. There is no point in
+                                // sending another cancellation since the other tab
+                                // will do it.
+                                logger.log(
+                                    "Tried to cancel room key request for " +
+                                        stringifyRequestBody(requestBody) +
+                                        " but it was already cancelled in another tab",
+                                );
+                                return;
+                            }
+
+                            // We don't want to wait for the timer, so we send it
+                            // immediately. (We might actually end up racing with the timer,
+                            // but that's ok: even if we make the request twice, we'll do it
+                            // with the same transaction_id, so only one message will get
+                            // sent).
+                            //
+                            // (We also don't want to wait for the response from the server
+                            // here, as it will slow down processing of received keys if we
+                            // do.)
+                            this.sendOutgoingRoomKeyRequestCancellation(updatedReq).catch((e) => {
+                                logger.error("Error sending room key request cancellation;" + " will retry later.", e);
+                                this.startTimer();
+                            });
                         });
-                    });
                 }
                 default:
-                    throw new Error('unhandled state: ' + req.state);
+                    throw new Error("unhandled state: " + req.state);
             }
         });
     }
@@ -338,8 +324,9 @@ export class OutgoingRoomKeyRequestManager {
      */
     public async cancelAndResendAllOutgoingRequests(): Promise<void[]> {
         const outgoings = await this.cryptoStore.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
-        return Promise.all(outgoings.map(({ requestBody, recipients }) =>
-            this.queueRoomKeyRequest(requestBody, recipients, true)));
+        return Promise.all(
+            outgoings.map(({ requestBody, recipients }) => this.queueRoomKeyRequest(requestBody, recipients, true)),
+        );
     }
 
     // start the background timer to send queued requests, if the timer isn't
@@ -355,15 +342,15 @@ export class OutgoingRoomKeyRequestManager {
             }
             this.sendOutgoingRoomKeyRequestsRunning = true;
 
-            this.sendOutgoingRoomKeyRequests().finally(() => {
-                this.sendOutgoingRoomKeyRequestsRunning = false;
-            }).catch((e) => {
-                // this should only happen if there is an indexeddb error,
-                // in which case we're a bit stuffed anyway.
-                logger.warn(
-                    `error in OutgoingRoomKeyRequestManager: ${e}`,
-                );
-            });
+            this.sendOutgoingRoomKeyRequests()
+                .finally(() => {
+                    this.sendOutgoingRoomKeyRequestsRunning = false;
+                })
+                .catch((e) => {
+                    // this should only happen if there is an indexeddb error,
+                    // in which case we're a bit stuffed anyway.
+                    logger.warn(`error in OutgoingRoomKeyRequestManager: ${e}`);
+                });
         };
 
         this.sendOutgoingRoomKeyRequestsTimer = setTimeout(
@@ -417,8 +404,8 @@ export class OutgoingRoomKeyRequestManager {
     private sendOutgoingRoomKeyRequest(req: OutgoingRoomKeyRequest): Promise<unknown> {
         logger.log(
             `Requesting keys for ${stringifyRequestBody(req.requestBody)}` +
-            ` from ${stringifyRecipientList(req.recipients)}` +
-            `(id ${req.requestId})`,
+                ` from ${stringifyRecipientList(req.recipients)}` +
+                `(id ${req.requestId})`,
         );
 
         const requestMessage: RequestMessage = {
@@ -429,10 +416,9 @@ export class OutgoingRoomKeyRequestManager {
         };
 
         return this.sendMessageToDevices(requestMessage, req.recipients, req.requestTxnId || req.requestId).then(() => {
-            return this.cryptoStore.updateOutgoingRoomKeyRequest(
-                req.requestId, RoomKeyRequestState.Unsent,
-                { state: RoomKeyRequestState.Sent },
-            );
+            return this.cryptoStore.updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Unsent, {
+                state: RoomKeyRequestState.Sent,
+            });
         });
     }
 
@@ -441,9 +427,9 @@ export class OutgoingRoomKeyRequestManager {
     private sendOutgoingRoomKeyRequestCancellation(req: OutgoingRoomKeyRequest, andResend = false): Promise<unknown> {
         logger.log(
             `Sending cancellation for key request for ` +
-            `${stringifyRequestBody(req.requestBody)} to ` +
-            `${stringifyRecipientList(req.recipients)} ` +
-            `(cancellation id ${req.cancellationTxnId})`,
+                `${stringifyRequestBody(req.requestBody)} to ` +
+                `${stringifyRecipientList(req.recipients)} ` +
+                `(cancellation id ${req.cancellationTxnId})`,
         );
 
         const requestMessage: RequestMessage = {
@@ -452,9 +438,7 @@ export class OutgoingRoomKeyRequestManager {
             request_id: req.requestId,
         };
 
-        return this.sendMessageToDevices(
-            requestMessage, req.recipients, req.cancellationTxnId,
-        ).then(() => {
+        return this.sendMessageToDevices(requestMessage, req.recipients, req.cancellationTxnId).then(() => {
             if (andResend) {
                 // We want to resend, so transition to UNSENT
                 return this.cryptoStore.updateOutgoingRoomKeyRequest(
@@ -464,7 +448,8 @@ export class OutgoingRoomKeyRequestManager {
                 );
             }
             return this.cryptoStore.deleteOutgoingRoomKeyRequest(
-                req.requestId, RoomKeyRequestState.CancellationPending,
+                req.requestId,
+                RoomKeyRequestState.CancellationPending,
             );
         });
     }
@@ -499,4 +484,3 @@ function stringifyRequestBody(requestBody: IRoomKeyRequestBody): string {
 function stringifyRecipientList(recipients: IRoomKeyRequestRecipient[]): string {
     return `[${recipients.map((r) => `${r.userId}:${r.deviceId}`).join(",")}]`;
 }
-
diff --git a/src/crypto/RoomList.ts b/src/crypto/RoomList.ts
index 2f5233bd2e4..a73efcd5528 100644
--- a/src/crypto/RoomList.ts
+++ b/src/crypto/RoomList.ts
@@ -18,8 +18,8 @@ limitations under the License.
  * Manages the list of encrypted rooms
  */
 
-import { CryptoStore } from './store/base';
-import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
+import { CryptoStore } from "./store/base";
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store";
 
 /* eslint-disable camelcase */
 export interface IRoomEncryption {
@@ -36,13 +36,11 @@ export class RoomList {
     public constructor(private readonly cryptoStore?: CryptoStore) {}
 
     public async init(): Promise<void> {
-        await this.cryptoStore!.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ROOMS], (txn) => {
-                this.cryptoStore!.getEndToEndRooms(txn, (result) => {
-                    this.roomEncryption = result;
-                });
-            },
-        );
+        await this.cryptoStore!.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ROOMS], (txn) => {
+            this.cryptoStore!.getEndToEndRooms(txn, (result) => {
+                this.roomEncryption = result;
+            });
+        });
     }
 
     public getRoomEncryption(roomId: string): IRoomEncryption {
@@ -58,10 +56,8 @@ export class RoomList {
         // as it prevents the Crypto::setRoomEncryption from calling
         // this twice for consecutive m.room.encryption events
         this.roomEncryption[roomId] = roomInfo;
-        await this.cryptoStore!.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ROOMS], (txn) => {
-                this.cryptoStore!.storeEndToEndRoom(roomId, roomInfo, txn);
-            },
-        );
+        await this.cryptoStore!.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ROOMS], (txn) => {
+            this.cryptoStore!.storeEndToEndRoom(roomId, roomInfo, txn);
+        });
     }
 }
diff --git a/src/crypto/SecretStorage.ts b/src/crypto/SecretStorage.ts
index 921207c4a16..c0aab32b880 100644
--- a/src/crypto/SecretStorage.ts
+++ b/src/crypto/SecretStorage.ts
@@ -14,17 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 
-import { logger } from '../logger';
-import * as olmlib from './olmlib';
-import { randomString } from '../randomstring';
-import { calculateKeyCheck, decryptAES, encryptAES, IEncryptedPayload } from './aes';
+import { logger } from "../logger";
+import * as olmlib from "./olmlib";
+import { randomString } from "../randomstring";
+import { calculateKeyCheck, decryptAES, encryptAES, IEncryptedPayload } from "./aes";
 import { ICryptoCallbacks, IEncryptedContent } from ".";
 import { IContent, MatrixEvent } from "../models/event";
 import { ClientEvent, ClientEventHandlerMap, MatrixClient } from "../client";
-import { IAddSecretStorageKeyOpts, ISecretStorageKeyInfo } from './api';
-import { TypedEventEmitter } from '../models/typed-event-emitter';
+import { IAddSecretStorageKeyOpts, ISecretStorageKeyInfo } from "./api";
+import { TypedEventEmitter } from "../models/typed-event-emitter";
 import { defer, IDeferred } from "../utils";
 import { ToDeviceMessageId } from "../@types/event";
 
@@ -32,7 +32,7 @@ export const SECRET_STORAGE_ALGORITHM_V1_AES = "m.secret_storage.v1.aes-hmac-sha
 
 // Some of the key functions use a tuple and some use an object...
 export type SecretStorageKeyTuple = [keyId: string, keyInfo: ISecretStorageKeyInfo];
-export type SecretStorageKeyObject = {keyId: string, keyInfo: ISecretStorageKeyInfo};
+export type SecretStorageKeyObject = { keyId: string; keyInfo: ISecretStorageKeyInfo };
 
 export interface ISecretRequest {
     requestId: string;
@@ -42,7 +42,7 @@ export interface ISecretRequest {
 
 export interface IAccountDataClient extends TypedEventEmitter<ClientEvent.AccountData, ClientEventHandlerMap> {
     // Subset of MatrixClient (which also uses any for the event content)
-    getAccountDataFromServer: <T extends {[k: string]: any}>(eventType: string) => Promise<T>;
+    getAccountDataFromServer: <T extends { [k: string]: any }>(eventType: string) => Promise<T>;
     getAccountData: (eventType: string) => IContent | null;
     setAccountData: (eventType: string, content: any) => Promise<{}>;
 }
@@ -86,7 +86,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
 
     public async getDefaultKeyId(): Promise<string | null> {
         const defaultKey = await this.accountDataAdapter.getAccountDataFromServer<{ key: string }>(
-            'm.secret_storage.default_key',
+            "m.secret_storage.default_key",
         );
         if (!defaultKey) return null;
         return defaultKey.key;
@@ -95,20 +95,14 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     public setDefaultKeyId(keyId: string): Promise<void> {
         return new Promise<void>((resolve, reject) => {
             const listener = (ev: MatrixEvent): void => {
-                if (
-                    ev.getType() === 'm.secret_storage.default_key' &&
-                    ev.getContent().key === keyId
-                ) {
+                if (ev.getType() === "m.secret_storage.default_key" && ev.getContent().key === keyId) {
                     this.accountDataAdapter.removeListener(ClientEvent.AccountData, listener);
                     resolve();
                 }
             };
             this.accountDataAdapter.on(ClientEvent.AccountData, listener);
 
-            this.accountDataAdapter.setAccountData(
-                'm.secret_storage.default_key',
-                { key: keyId },
-            ).catch(e => {
+            this.accountDataAdapter.setAccountData("m.secret_storage.default_key", { key: keyId }).catch((e) => {
                 this.accountDataAdapter.removeListener(ClientEvent.AccountData, listener);
                 reject(e);
             });
@@ -162,9 +156,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
             );
         }
 
-        await this.accountDataAdapter.setAccountData(
-            `m.secret_storage.key.${keyId}`, keyInfo,
-        );
+        await this.accountDataAdapter.setAccountData(`m.secret_storage.key.${keyId}`, keyInfo);
 
         return {
             keyId,
@@ -218,7 +210,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
         if (info.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {
             if (info.mac) {
                 const { mac } = await calculateKeyCheck(key, info.iv);
-                return info.mac.replace(/=+$/g, '') === mac.replace(/=+$/g, '');
+                return info.mac.replace(/=+$/g, "") === mac.replace(/=+$/g, "");
             } else {
                 // if we have no information, we have to assume the key is right
                 return true;
@@ -266,8 +258,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                 const [, encryption] = await this.getSecretStorageKey(keys, name);
                 encrypted[keyId] = await encryption.encrypt(secret);
             } else {
-                logger.warn("unknown algorithm for secret storage key " + keyId
-                            + ": " + keyInfo.algorithm);
+                logger.warn("unknown algorithm for secret storage key " + keyId + ": " + keyInfo.algorithm);
                 // do nothing if we don't understand the encryption algorithm
             }
         }
@@ -296,10 +287,8 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
         const keys: Record<string, ISecretStorageKeyInfo> = {};
         for (const keyId of Object.keys(secretInfo.encrypted)) {
             // get key information from key storage
-            const keyInfo = (
-                await this.accountDataAdapter.getAccountDataFromServer<ISecretStorageKeyInfo>(
-                    "m.secret_storage.key." + keyId,
-                )
+            const keyInfo = await this.accountDataAdapter.getAccountDataFromServer<ISecretStorageKeyInfo>(
+                "m.secret_storage.key." + keyId,
             );
             const encInfo = secretInfo.encrypted[keyId];
             // only use keys we understand the encryption algorithm of
@@ -311,8 +300,10 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
         }
 
         if (Object.keys(keys).length === 0) {
-            throw new Error(`Could not decrypt ${name} because none of ` +
-                `the keys it is encrypted with are for a supported algorithm`);
+            throw new Error(
+                `Could not decrypt ${name} because none of ` +
+                    `the keys it is encrypted with are for a supported algorithm`,
+            );
         }
 
         // fetch private key from app
@@ -416,9 +407,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
     public async onRequestReceived(this: SecretStorage<MatrixClient>, event: MatrixEvent): Promise<void> {
         const sender = event.getSender();
         const content = event.getContent();
-        if (sender !== this.baseApis.getUserId()
-            || !(content.name && content.action
-                 && content.requesting_device_id && content.request_id)
+        if (
+            sender !== this.baseApis.getUserId() ||
+            !(content.name && content.action && content.requesting_device_id && content.request_id)
         ) {
             // ignore requests from anyone else, for now
             return;
@@ -452,10 +443,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
             }
 
             // check if we have the secret
-            logger.info(
-                "received request for secret (" + sender +
-                ", " + deviceId + ", " + content.request_id + ")",
-            );
+            logger.info("received request for secret (" + sender + ", " + deviceId + ", " + content.request_id + ")");
             if (!this.cryptoCallbacks.onSecretRequested) {
                 return;
             }
@@ -481,15 +469,9 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                     ciphertext: {},
                     [ToDeviceMessageId]: uuidv4(),
                 };
-                await olmlib.ensureOlmSessionsForDevices(
-                    this.baseApis.crypto!.olmDevice,
-                    this.baseApis,
-                    {
-                        [sender]: [
-                            this.baseApis.getStoredDevice(sender, deviceId)!,
-                        ],
-                    },
-                );
+                await olmlib.ensureOlmSessionsForDevices(this.baseApis.crypto!.olmDevice, this.baseApis, {
+                    [sender]: [this.baseApis.getStoredDevice(sender, deviceId)!],
+                });
                 await olmlib.encryptMessageForDevice(
                     encryptedContent.ciphertext,
                     this.baseApis.getUserId()!,
@@ -546,9 +528,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                 event.getSenderKey()!,
             );
             if (!deviceInfo) {
-                logger.log(
-                    "secret share from unknown device with key", event.getSenderKey(),
-                );
+                logger.log("secret share from unknown device with key", event.getSenderKey());
                 return;
             }
             if (!requestControl.devices.includes(deviceInfo.deviceId)) {
@@ -564,10 +544,7 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
                 return;
             }
 
-            logger.log(
-                `Successfully received secret ${requestControl.name} ` +
-                `from ${deviceInfo.deviceId}`,
-            );
+            logger.log(`Successfully received secret ${requestControl.name} ` + `from ${deviceInfo.deviceId}`);
             requestControl.deferred.resolve(content.secret);
         }
     }
@@ -596,10 +573,10 @@ export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> {
 
         if (keys[keyId].algorithm === SECRET_STORAGE_ALGORITHM_V1_AES) {
             const decryption = {
-                encrypt: function(secret: string): Promise<IEncryptedPayload> {
+                encrypt: function (secret: string): Promise<IEncryptedPayload> {
                     return encryptAES(secret, privateKey, name);
                 },
-                decrypt: function(encInfo: IEncryptedPayload): Promise<string> {
+                decrypt: function (encInfo: IEncryptedPayload): Promise<string> {
                     return decryptAES(encInfo, privateKey, name);
                 },
             };
diff --git a/src/crypto/aes.ts b/src/crypto/aes.ts
index da546483439..48470af6261 100644
--- a/src/crypto/aes.ts
+++ b/src/crypto/aes.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { decodeBase64, encodeBase64 } from './olmlib';
+import { decodeBase64, encodeBase64 } from "./olmlib";
 import { subtleCrypto, crypto, TextEncoder } from "./crypto";
 
 // salt for HKDF, with 8 bytes of zeros
@@ -70,11 +70,7 @@ export async function encryptAES(
         encodedData,
     );
 
-    const hmac = await subtleCrypto.sign(
-        { name: 'HMAC' },
-        hmacKey,
-        ciphertext,
-    );
+    const hmac = await subtleCrypto.sign({ name: "HMAC" }, hmacKey, ciphertext);
 
     return {
         iv: encodeBase64(iv),
@@ -95,12 +91,7 @@ export async function decryptAES(data: IEncryptedPayload, key: Uint8Array, name:
 
     const ciphertext = decodeBase64(data.ciphertext);
 
-    if (!await subtleCrypto.verify(
-        { name: "HMAC" },
-        hmacKey,
-        decodeBase64(data.mac),
-        ciphertext,
-    )) {
+    if (!(await subtleCrypto.verify({ name: "HMAC" }, hmacKey, decodeBase64(data.mac), ciphertext))) {
         throw new Error(`Error decrypting secret ${name}: bad MAC`);
     }
 
@@ -118,20 +109,14 @@ export async function decryptAES(data: IEncryptedPayload, key: Uint8Array, name:
 }
 
 async function deriveKeys(key: Uint8Array, name: string): Promise<[CryptoKey, CryptoKey]> {
-    const hkdfkey = await subtleCrypto.importKey(
-        'raw',
-        key,
-        { name: "HKDF" },
-        false,
-        ["deriveBits"],
-    );
+    const hkdfkey = await subtleCrypto.importKey("raw", key, { name: "HKDF" }, false, ["deriveBits"]);
     const keybits = await subtleCrypto.deriveBits(
         {
             name: "HKDF",
             salt: zeroSalt,
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore: https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/879
-            info: (new TextEncoder().encode(name)),
+            info: new TextEncoder().encode(name),
             hash: "SHA-256",
         },
         hkdfkey,
@@ -141,23 +126,17 @@ async function deriveKeys(key: Uint8Array, name: string): Promise<[CryptoKey, Cr
     const aesKey = keybits.slice(0, 32);
     const hmacKey = keybits.slice(32);
 
-    const aesProm = subtleCrypto.importKey(
-        'raw',
-        aesKey,
-        { name: 'AES-CTR' },
-        false,
-        ['encrypt', 'decrypt'],
-    );
+    const aesProm = subtleCrypto.importKey("raw", aesKey, { name: "AES-CTR" }, false, ["encrypt", "decrypt"]);
 
     const hmacProm = subtleCrypto.importKey(
-        'raw',
+        "raw",
         hmacKey,
         {
-            name: 'HMAC',
-            hash: { name: 'SHA-256' },
+            name: "HMAC",
+            hash: { name: "SHA-256" },
         },
         false,
-        ['sign', 'verify'],
+        ["sign", "verify"],
     );
 
     return Promise.all([aesProm, hmacProm]);
diff --git a/src/crypto/algorithms/base.ts b/src/crypto/algorithms/base.ts
index 3229ad39bd2..e5c7a379408 100644
--- a/src/crypto/algorithms/base.ts
+++ b/src/crypto/algorithms/base.ts
@@ -22,13 +22,7 @@ import { MatrixClient } from "../../client";
 import { Room } from "../../models/room";
 import { OlmDevice } from "../OlmDevice";
 import { IContent, MatrixEvent, RoomMember } from "../../matrix";
-import {
-    Crypto,
-    IEncryptedContent,
-    IEventDecryptionResult,
-    IMegolmSessionData,
-    IncomingRoomKeyRequest,
-} from "..";
+import { Crypto, IEncryptedContent, IEventDecryptionResult, IMegolmSessionData, IncomingRoomKeyRequest } from "..";
 import { DeviceInfo } from "../deviceinfo";
 import { IRoomEncryption } from "../RoomList";
 
@@ -217,19 +211,23 @@ export class DecryptionError extends Error {
     public constructor(public readonly code: string, msg: string, details?: Record<string, string | Error>) {
         super(msg);
         this.code = code;
-        this.name = 'DecryptionError';
+        this.name = "DecryptionError";
         this.detailedString = detailedStringForDecryptionError(this, details);
     }
 }
 
 function detailedStringForDecryptionError(err: DecryptionError, details?: Record<string, string | Error>): string {
-    let result = err.name + '[msg: ' + err.message;
+    let result = err.name + "[msg: " + err.message;
 
     if (details) {
-        result += ', ' + Object.keys(details).map((k) => k + ': ' + details[k]).join(', ');
+        result +=
+            ", " +
+            Object.keys(details)
+                .map((k) => k + ": " + details[k])
+                .join(", ");
     }
 
-    result += ']';
+    result += "]";
 
     return result;
 }
diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index d995623d4ed..aed0ab28fef 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -20,7 +20,7 @@ limitations under the License.
 
 import { v4 as uuidv4 } from "uuid";
 
-import { logger } from '../../logger';
+import { logger } from "../../logger";
 import * as olmlib from "../olmlib";
 import {
     DecryptionAlgorithm,
@@ -31,13 +31,13 @@ import {
     registerAlgorithm,
     UnknownDeviceError,
 } from "./base";
-import { IDecryptedGroupMessage, WITHHELD_MESSAGES } from '../OlmDevice';
-import { Room } from '../../models/room';
+import { IDecryptedGroupMessage, WITHHELD_MESSAGES } from "../OlmDevice";
+import { Room } from "../../models/room";
 import { DeviceInfo } from "../deviceinfo";
 import { IOlmSessionResult } from "../olmlib";
 import { DeviceInfoMap } from "../DeviceList";
 import { IContent, MatrixEvent } from "../../models/event";
-import { EventType, MsgType, ToDeviceMessageId } from '../../@types/event';
+import { EventType, MsgType, ToDeviceMessageId } from "../../@types/event";
 import {
     IMegolmEncryptedContent,
     IEventDecryptionResult,
@@ -45,7 +45,7 @@ import {
     IncomingRoomKeyRequest,
     IEncryptedContent,
 } from "../index";
-import { RoomKeyRequestState } from '../OutgoingRoomKeyRequestManager';
+import { RoomKeyRequestState } from "../OutgoingRoomKeyRequestManager";
 import { OlmGroupSessionExtraData } from "../../@types/crypto";
 import { MatrixError } from "../../http-api";
 
@@ -87,14 +87,14 @@ export interface IOutboundGroupSessionKey {
 interface IMessage {
     type: string;
     content: {
-        algorithm: string;
-        room_id: string;
-        sender_key?: string;
-        sender_claimed_ed25519_key?: string;
-        session_id: string;
-        session_key: string;
-        chain_index: number;
-        forwarding_curve25519_key_chain?: string[];
+        "algorithm": string;
+        "room_id": string;
+        "sender_key"?: string;
+        "sender_claimed_ed25519_key"?: string;
+        "session_id": string;
+        "session_key": string;
+        "chain_index": number;
+        "forwarding_curve25519_key_chain"?: string[];
         "org.matrix.msc3061.shared_history": boolean;
     };
 }
@@ -146,13 +146,8 @@ class OutboundSessionInfo {
     public needsRotation(rotationPeriodMsgs: number, rotationPeriodMs: number): boolean {
         const sessionLifetime = new Date().getTime() - this.creationTime;
 
-        if (this.useCount >= rotationPeriodMsgs ||
-            sessionLifetime >= rotationPeriodMs
-        ) {
-            logger.log(
-                "Rotating megolm session after " + this.useCount +
-                " messages, " + sessionLifetime + "ms",
-            );
+        if (this.useCount >= rotationPeriodMsgs || sessionLifetime >= rotationPeriodMs) {
+            logger.log("Rotating megolm session after " + this.useCount + " messages, " + sessionLifetime + "ms");
             return true;
         }
 
@@ -200,10 +195,7 @@ class OutboundSessionInfo {
                 }
 
                 if (!devicesInRoom[userId].hasOwnProperty(deviceId)) {
-                    logger.log(
-                        "Starting new megolm session because we shared with " +
-                        userId + ":" + deviceId,
-                    );
+                    logger.log("Starting new megolm session because we shared with " + userId + ":" + deviceId);
                     return true;
                 }
             }
@@ -289,7 +281,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         const prom = this.setupPromise.then(setup);
 
         // Ensure any failures are logged for debugging
-        prom.catch(e => {
+        prom.catch((e) => {
             logger.error(`Failed to setup outbound session in ${this.roomId}`, e);
         });
 
@@ -324,8 +316,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         if (!session) {
             logger.log(`Starting new megolm session for room ${this.roomId}`);
             session = await this.prepareNewSession(sharedHistory);
-            logger.log(`Started new megolm session ${session.sessionId} ` +
-                `for room ${this.roomId}`);
+            logger.log(`Started new megolm session ${session.sessionId} ` + `for room ${this.roomId}`);
             this.outboundSessions[session.sessionId] = session;
         }
 
@@ -350,10 +341,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
                     continue;
                 }
 
-                if (
-                    !session.sharedWithDevices[userId] ||
-                    session.sharedWithDevices[userId][deviceId] === undefined
-                ) {
+                if (!session.sharedWithDevices[userId] || session.sharedWithDevices[userId][deviceId] === undefined) {
                     shareMap[userId] = shareMap[userId] || [];
                     shareMap[userId].push(deviceInfo);
                 }
@@ -373,7 +361,9 @@ export class MegolmEncryption extends EncryptionAlgorithm {
             },
         };
         const [devicesWithoutSession, olmSessions] = await olmlib.getExistingOlmSessions(
-            this.olmDevice, this.baseApis, shareMap,
+            this.olmDevice,
+            this.baseApis,
+            shareMap,
         );
 
         await Promise.all([
@@ -398,12 +388,17 @@ export class MegolmEncryption extends EncryptionAlgorithm {
                 const start = Date.now();
                 const failedServers: string[] = [];
                 await this.shareKeyWithDevices(
-                    session, key, payload, devicesWithoutSession, errorDevices,
-                    singleOlmCreationPhase ? 10000 : 2000, failedServers,
+                    session,
+                    key,
+                    payload,
+                    devicesWithoutSession,
+                    errorDevices,
+                    singleOlmCreationPhase ? 10000 : 2000,
+                    failedServers,
                 );
                 logger.debug(`Shared keys (end phase 1) with new Olm sessions in ${this.roomId}`);
 
-                if (!singleOlmCreationPhase && (Date.now() - start < 10000)) {
+                if (!singleOlmCreationPhase && Date.now() - start < 10000) {
                     // perform the second phase of olm session creation if requested,
                     // and if the first phase didn't take too long
                     (async (): Promise<void> => {
@@ -413,7 +408,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
                         // do this.  We only need to retry users from servers that didn't
                         // respond the first time.
                         const retryDevices: Record<string, DeviceInfo[]> = {};
-                        const failedServerMap = new Set;
+                        const failedServerMap = new Set();
                         for (const server of failedServers) {
                             failedServerMap.add(server);
                         }
@@ -431,9 +426,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
                         }
 
                         logger.debug(`Sharing keys (start phase 2) with new Olm sessions in ${this.roomId}`);
-                        await this.shareKeyWithDevices(
-                            session, key, payload, retryDevices, failedDevices, 30000,
-                        );
+                        await this.shareKeyWithDevices(session, key, payload, retryDevices, failedDevices, 30000);
                         logger.debug(`Shared keys (end phase 2) with new Olm sessions in ${this.roomId}`);
 
                         await this.notifyFailedOlmDevices(session, key, failedDevices);
@@ -444,8 +437,10 @@ export class MegolmEncryption extends EncryptionAlgorithm {
                 logger.debug(`Shared keys (all phases done) with new Olm sessions in ${this.roomId}`);
             })(),
             (async (): Promise<void> => {
-                logger.debug(`There are ${Object.entries(blocked).length} blocked devices in ${this.roomId}`,
-                    Object.entries(blocked));
+                logger.debug(
+                    `There are ${Object.entries(blocked).length} blocked devices in ${this.roomId}`,
+                    Object.entries(blocked),
+                );
 
                 // also, notify newly blocked devices that they're blocked
                 logger.debug(`Notifying newly blocked devices in ${this.roomId}`);
@@ -481,8 +476,13 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         const key = this.olmDevice.getOutboundGroupSessionKey(sessionId);
 
         await this.olmDevice.addInboundGroupSession(
-            this.roomId, this.olmDevice.deviceCurve25519Key!, [], sessionId,
-            key.key, { ed25519: this.olmDevice.deviceEd25519Key! }, false,
+            this.roomId,
+            this.olmDevice.deviceCurve25519Key!,
+            [],
+            sessionId,
+            key.key,
+            { ed25519: this.olmDevice.deviceEd25519Key! },
+            false,
             { sharedHistory },
         );
 
@@ -599,23 +599,23 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         devices: IOlmDevice[],
         payload: IPayload,
     ): Promise<void> {
-        return this.crypto.encryptAndSendToDevices(
-            devices,
-            payload,
-        ).then(() => {
-            // store that we successfully uploaded the keys of the current slice
-            for (const device of devices) {
-                session.markSharedWithDevice(
-                    device.userId,
-                    device.deviceInfo.deviceId,
-                    device.deviceInfo.getIdentityKey(),
-                    chainIndex,
-                );
-            }
-        }).catch((error) => {
-            logger.error("failed to encryptAndSendToDevices", error);
-            throw error;
-        });
+        return this.crypto
+            .encryptAndSendToDevices(devices, payload)
+            .then(() => {
+                // store that we successfully uploaded the keys of the current slice
+                for (const device of devices) {
+                    session.markSharedWithDevice(
+                        device.userId,
+                        device.deviceInfo.deviceId,
+                        device.deviceInfo.getIdentityKey(),
+                        chainIndex,
+                    );
+                }
+            })
+            .catch((error) => {
+                logger.error("failed to encryptAndSendToDevices", error);
+                throw error;
+            });
     }
 
     /**
@@ -707,7 +707,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         if (sessionSharedData.deviceKey !== device.getIdentityKey()) {
             logger.warn(
                 `Megolm session ${senderKey}|${sessionId} has been shared with device ${device.deviceId} but ` +
-                `with identity key ${sessionSharedData.deviceKey}. Key is now ${device.getIdentityKey()}!`,
+                    `with identity key ${sessionSharedData.deviceKey}. Key is now ${device.getIdentityKey()}!`,
             );
             return;
         }
@@ -715,7 +715,10 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         // get the key from the inbound session: the outbound one will already
         // have been ratcheted to the next chain index.
         const key = await this.olmDevice.getInboundGroupSessionKey(
-            this.roomId, senderKey, sessionId, sessionSharedData.messageIndex,
+            this.roomId,
+            senderKey,
+            sessionId,
+            sessionSharedData.messageIndex,
         );
 
         if (!key) {
@@ -725,11 +728,9 @@ export class MegolmEncryption extends EncryptionAlgorithm {
             return;
         }
 
-        await olmlib.ensureOlmSessionsForDevices(
-            this.olmDevice, this.baseApis, {
-                [userId]: [device],
-            },
-        );
+        await olmlib.ensureOlmSessionsForDevices(this.olmDevice, this.baseApis, {
+            [userId]: [device],
+        });
 
         const payload = {
             type: "m.forwarded_room_key",
@@ -801,7 +802,12 @@ export class MegolmEncryption extends EncryptionAlgorithm {
     ): Promise<void> {
         logger.debug(`Ensuring Olm sessions for devices in ${this.roomId}`);
         const devicemap = await olmlib.ensureOlmSessionsForDevices(
-            this.olmDevice, this.baseApis, devicesByUser, false, otkTimeout, failedServers,
+            this.olmDevice,
+            this.baseApis,
+            devicesByUser,
+            false,
+            otkTimeout,
+            failedServers,
             logger.withPrefix?.(`[${this.roomId}]`),
         );
         logger.debug(`Ensured Olm sessions for devices in ${this.roomId}`);
@@ -823,14 +829,13 @@ export class MegolmEncryption extends EncryptionAlgorithm {
 
         for (let i = 0; i < userDeviceMaps.length; i++) {
             const taskDetail =
-                `megolm keys for ${session.sessionId} ` +
-                `in ${this.roomId} (slice ${i + 1}/${userDeviceMaps.length})`;
+                `megolm keys for ${session.sessionId} ` + `in ${this.roomId} (slice ${i + 1}/${userDeviceMaps.length})`;
             try {
-                logger.debug(`Sharing ${taskDetail}`,
-                    userDeviceMaps[i].map((d) => `${d.userId}/${d.deviceInfo.deviceId}`));
-                await this.encryptAndSendKeysToDevices(
-                    session, key.chain_index, userDeviceMaps[i], payload,
+                logger.debug(
+                    `Sharing ${taskDetail}`,
+                    userDeviceMaps[i].map((d) => `${d.userId}/${d.deviceInfo.deviceId}`),
                 );
+                await this.encryptAndSendKeysToDevices(session, key.chain_index, userDeviceMaps[i], payload);
                 logger.debug(`Shared ${taskDetail}`);
             } catch (e) {
                 logger.error(`Failed to share ${taskDetail}`);
@@ -853,8 +858,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         failedDevices: IOlmDevice[],
     ): Promise<void> {
         logger.debug(
-            `Notifying ${failedDevices.length} devices we failed to ` +
-            `create Olm sessions in ${this.roomId}`,
+            `Notifying ${failedDevices.length} devices we failed to ` + `create Olm sessions in ${this.roomId}`,
         );
 
         // mark the devices that failed as "handled" because we don't want to try
@@ -862,18 +866,13 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         for (const { userId, deviceInfo } of failedDevices) {
             const deviceId = deviceInfo.deviceId;
 
-            session.markSharedWithDevice(
-                userId, deviceId, deviceInfo.getIdentityKey(), key.chain_index,
-            );
+            session.markSharedWithDevice(userId, deviceId, deviceInfo.getIdentityKey(), key.chain_index);
         }
 
-        const unnotifiedFailedDevices =
-            await this.olmDevice.filterOutNotifiedErrorDevices(
-                failedDevices,
-            );
+        const unnotifiedFailedDevices = await this.olmDevice.filterOutNotifiedErrorDevices(failedDevices);
         logger.debug(
             `Need to notify ${unnotifiedFailedDevices.length} failed devices ` +
-            `which haven't been notified before in ${this.roomId}`,
+                `which haven't been notified before in ${this.roomId}`,
         );
         const blockedMap: Record<string, Record<string, { device: IBlockedDevice }>> = {};
         for (const { userId, deviceInfo } of unnotifiedFailedDevices) {
@@ -894,7 +893,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         await this.notifyBlockedDevices(session, blockedMap);
         logger.debug(
             `Notified ${unnotifiedFailedDevices.length} devices we failed to ` +
-            `create Olm sessions in ${this.roomId}`,
+                `create Olm sessions in ${this.roomId}`,
         );
     }
 
@@ -920,11 +919,15 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         for (let i = 0; i < userDeviceMaps.length; i++) {
             try {
                 await this.sendBlockedNotificationsToDevices(session, userDeviceMaps[i], payload);
-                logger.log(`Completed blacklist notification for ${session.sessionId} `
-                    + `in ${this.roomId} (slice ${i + 1}/${userDeviceMaps.length})`);
+                logger.log(
+                    `Completed blacklist notification for ${session.sessionId} ` +
+                        `in ${this.roomId} (slice ${i + 1}/${userDeviceMaps.length})`,
+                );
             } catch (e) {
-                logger.log(`blacklist notification for ${session.sessionId} in `
-                    + `${this.roomId} (slice ${i + 1}/${userDeviceMaps.length}) failed`);
+                logger.log(
+                    `blacklist notification for ${session.sessionId} in ` +
+                        `${this.roomId} (slice ${i + 1}/${userDeviceMaps.length}) failed`,
+                );
 
                 throw e;
             }
@@ -944,8 +947,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
             // (https://github.com/matrix-org/matrix-js-sdk/issues/1255)
             const elapsedTime = Date.now() - this.encryptionPreparation.startTime;
             logger.debug(
-                `Already started preparing to encrypt for ${this.roomId} ` +
-                `${elapsedTime} ms ago, skipping`,
+                `Already started preparing to encrypt for ${this.roomId} ` + `${elapsedTime} ms ago, skipping`,
             );
             return;
         }
@@ -1048,7 +1050,7 @@ export class MegolmEncryption extends EncryptionAlgorithm {
                 return true;
             }
             case EventType.RoomMessage: {
-                return content['msgtype'] === MsgType.KeyVerificationRequest;
+                return content["msgtype"] === MsgType.KeyVerificationRequest;
             }
             default: {
                 return false;
@@ -1093,7 +1095,9 @@ export class MegolmEncryption extends EncryptionAlgorithm {
             // it'd be kind to pass unknownDevices up to the user in this error
             throw new UnknownDeviceError(
                 "This room contains unknown devices which have not been verified. " +
-                "We strongly recommend you verify them before continuing.", unknownDevices);
+                    "We strongly recommend you verify them before continuing.",
+                unknownDevices,
+            );
         }
     }
 
@@ -1135,14 +1139,14 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         forceDistributeToUnverified = false,
     ): Promise<[DeviceInfoMap, IBlockedMap]> {
         const members = await room.getEncryptionTargetMembers();
-        const roomMembers = members.map(function(u) {
+        const roomMembers = members.map(function (u) {
             return u.userId;
         });
 
         // The global value is treated as a default for when rooms don't specify a value.
         let isBlacklisting = this.crypto.globalBlacklistUnverifiedDevices;
         const isRoomBlacklisting = room.getBlacklistUnverifiedDevices();
-        if (typeof isRoomBlacklisting === 'boolean') {
+        if (typeof isRoomBlacklisting === "boolean") {
             isBlacklisting = isRoomBlacklisting;
         }
 
@@ -1168,7 +1172,8 @@ export class MegolmEncryption extends EncryptionAlgorithm {
 
                 const deviceTrust = this.crypto.checkDeviceTrust(userId, deviceId);
 
-                if (userDevices[deviceId].isBlocked() ||
+                if (
+                    userDevices[deviceId].isBlocked() ||
                     (!deviceTrust.isVerified() && isBlacklisting && !forceDistributeToUnverified)
                 ) {
                     if (!blocked[userId]) {
@@ -1219,13 +1224,8 @@ export class MegolmDecryption extends DecryptionAlgorithm {
     public async decryptEvent(event: MatrixEvent): Promise<IEventDecryptionResult> {
         const content = event.getWireContent();
 
-        if (!content.sender_key || !content.session_id ||
-            !content.ciphertext
-        ) {
-            throw new DecryptionError(
-                "MEGOLM_MISSING_FIELDS",
-                "Missing fields in input",
-            );
+        if (!content.sender_key || !content.session_id || !content.ciphertext) {
+            throw new DecryptionError("MEGOLM_MISSING_FIELDS", "Missing fields in input");
         }
 
         // we add the event to the pending list *before* we start decryption.
@@ -1238,8 +1238,12 @@ export class MegolmDecryption extends DecryptionAlgorithm {
         let res: IDecryptedGroupMessage | null;
         try {
             res = await this.olmDevice.decryptGroupMessage(
-                event.getRoomId()!, content.sender_key, content.session_id, content.ciphertext,
-                event.getId()!, event.getTs(),
+                event.getRoomId()!,
+                content.sender_key,
+                content.session_id,
+                content.ciphertext,
+                event.getId()!,
+                event.getTs(),
             );
         } catch (e) {
             if ((<Error>e).name === "DecryptionError") {
@@ -1249,18 +1253,15 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
             let errorCode = "OLM_DECRYPT_GROUP_MESSAGE_ERROR";
 
-            if ((<MatrixError>e)?.message === 'OLM.UNKNOWN_MESSAGE_INDEX') {
+            if ((<MatrixError>e)?.message === "OLM.UNKNOWN_MESSAGE_INDEX") {
                 this.requestKeysForEvent(event);
 
-                errorCode = 'OLM_UNKNOWN_MESSAGE_INDEX';
+                errorCode = "OLM_UNKNOWN_MESSAGE_INDEX";
             }
 
-            throw new DecryptionError(
-                errorCode,
-                e ? e.toString() : "Unknown Error: Error is undefined", {
-                    session: content.sender_key + '|' + content.session_id,
-                },
-            );
+            throw new DecryptionError(errorCode, e ? e.toString() : "Unknown Error: Error is undefined", {
+                session: content.sender_key + "|" + content.session_id,
+            });
         }
 
         if (res === null) {
@@ -1277,33 +1278,26 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
             // See if there was a problem with the olm session at the time the
             // event was sent.  Use a fuzz factor of 2 minutes.
-            const problem = await this.olmDevice.sessionMayHaveProblems(
-                content.sender_key, event.getTs() - 120000,
-            );
+            const problem = await this.olmDevice.sessionMayHaveProblems(content.sender_key, event.getTs() - 120000);
             if (problem) {
                 logger.info(
                     `When handling UISI from ${event.getSender()} (sender key ${content.sender_key}): ` +
-                    `recent session problem with that sender: ${problem}`,
+                        `recent session problem with that sender: ${problem}`,
                 );
                 let problemDescription = PROBLEM_DESCRIPTIONS[problem.type as "no_olm"] || PROBLEM_DESCRIPTIONS.unknown;
                 if (problem.fixed) {
-                    problemDescription +=
-                        " Trying to create a new secure channel and re-requesting the keys.";
+                    problemDescription += " Trying to create a new secure channel and re-requesting the keys.";
                 }
-                throw new DecryptionError(
-                    "MEGOLM_UNKNOWN_INBOUND_SESSION_ID",
-                    problemDescription,
-                    {
-                        session: content.sender_key + '|' + content.session_id,
-                    },
-                );
+                throw new DecryptionError("MEGOLM_UNKNOWN_INBOUND_SESSION_ID", problemDescription, {
+                    session: content.sender_key + "|" + content.session_id,
+                });
             }
 
             throw new DecryptionError(
                 "MEGOLM_UNKNOWN_INBOUND_SESSION_ID",
                 "The sender's device has not sent us the keys for this message.",
                 {
-                    session: content.sender_key + '|' + content.session_id,
+                    session: content.sender_key + "|" + content.session_id,
                 },
             );
         }
@@ -1322,10 +1316,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
         // (this is somewhat redundant, since the megolm session is scoped to the
         // room, so neither the sender nor a MITM can lie about the room_id).
         if (payload.room_id !== event.getRoomId()) {
-            throw new DecryptionError(
-                "MEGOLM_BAD_ROOM",
-                "Message intended for room " + payload.room_id,
-            );
+            throw new DecryptionError("MEGOLM_BAD_ROOM", "Message intended for room " + payload.room_id);
         }
 
         return {
@@ -1342,12 +1333,15 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
         const recipients = event.getKeyRequestRecipients(this.userId);
 
-        this.crypto.requestRoomKey({
-            room_id: event.getRoomId()!,
-            algorithm: wireContent.algorithm,
-            sender_key: wireContent.sender_key,
-            session_id: wireContent.session_id,
-        }, recipients);
+        this.crypto.requestRoomKey(
+            {
+                room_id: event.getRoomId()!,
+                algorithm: wireContent.algorithm,
+                sender_key: wireContent.sender_key,
+                session_id: wireContent.session_id,
+            },
+            recipients,
+        );
     }
 
     /**
@@ -1404,11 +1398,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
         const extraSessionData: OlmGroupSessionExtraData = {};
 
-        if (!content.room_id ||
-            !content.session_key ||
-            !content.session_id ||
-            !content.algorithm
-        ) {
+        if (!content.room_id || !content.session_key || !content.session_id || !content.algorithm) {
             logger.error("key event is missing fields");
             return;
         }
@@ -1423,10 +1413,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
         }
 
         if (event.getType() == "m.forwarded_room_key") {
-            const deviceInfo = this.crypto.deviceList.getDeviceByIdentityKey(
-                olmlib.OLM_ALGORITHM,
-                senderKey,
-            );
+            const deviceInfo = this.crypto.deviceList.getDeviceByIdentityKey(olmlib.OLM_ALGORITHM, senderKey);
             const senderKeyUser = this.baseApis.crypto!.deviceList.getUserByIdentityKey(
                 olmlib.OLM_ALGORITHM,
                 senderKey,
@@ -1435,15 +1422,21 @@ export class MegolmDecryption extends DecryptionAlgorithm {
                 logger.error("sending device does not belong to the user it claims to be from");
                 return;
             }
-            const outgoingRequests = deviceInfo ? await this.crypto.cryptoStore.getOutgoingRoomKeyRequestsByTarget(
-                event.getSender()!, deviceInfo.deviceId, [RoomKeyRequestState.Sent],
-            ) : [];
-            const weRequested = outgoingRequests.some((req) => (
-                req.requestBody.room_id === content.room_id && req.requestBody.session_id === content.session_id
-            ));
+            const outgoingRequests = deviceInfo
+                ? await this.crypto.cryptoStore.getOutgoingRoomKeyRequestsByTarget(
+                      event.getSender()!,
+                      deviceInfo.deviceId,
+                      [RoomKeyRequestState.Sent],
+                  )
+                : [];
+            const weRequested = outgoingRequests.some(
+                (req) =>
+                    req.requestBody.room_id === content.room_id && req.requestBody.session_id === content.session_id,
+            );
             const room = this.baseApis.getRoom(content.room_id);
             const memberEvent = room?.getMember(this.userId)?.events.member;
-            const fromInviter = memberEvent?.getSender() === event.getSender() ||
+            const fromInviter =
+                memberEvent?.getSender() === event.getSender() ||
                 (memberEvent?.getUnsigned()?.prev_sender === event.getSender() &&
                     memberEvent?.getPrevContent()?.membership === "invite");
             const fromUs = event.getSender() === this.baseApis.getUserId();
@@ -1467,8 +1460,9 @@ export class MegolmDecryption extends DecryptionAlgorithm {
             }
 
             exportFormat = true;
-            forwardingKeyChain = Array.isArray(content.forwarding_curve25519_key_chain) ?
-                content.forwarding_curve25519_key_chain : [];
+            forwardingKeyChain = Array.isArray(content.forwarding_curve25519_key_chain)
+                ? content.forwarding_curve25519_key_chain
+                : [];
 
             // copy content before we modify it
             forwardingKeyChain = forwardingKeyChain.slice();
@@ -1481,9 +1475,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
             const ed25519Key = content.sender_claimed_ed25519_key;
             if (!ed25519Key) {
-                logger.error(
-                    `forwarded_room_key_event is missing sender_claimed_ed25519_key field`,
-                );
+                logger.error(`forwarded_room_key_event is missing sender_claimed_ed25519_key field`);
                 return;
             }
 
@@ -1504,18 +1496,16 @@ export class MegolmDecryption extends DecryptionAlgorithm {
                     forwardingCurve25519KeyChain: forwardingKeyChain,
                 };
                 await this.crypto.cryptoStore.doTxn(
-                    'readwrite',
-                    ['parked_shared_history'],
+                    "readwrite",
+                    ["parked_shared_history"],
                     (txn) => this.crypto.cryptoStore.addParkedSharedHistory(content.room_id!, parkedData, txn),
                     logger.withPrefix("[addParkedSharedHistory]"),
                 );
                 return;
             }
 
-            const sendingDevice = this.crypto.deviceList.getDeviceByIdentityKey(
-                olmlib.OLM_ALGORITHM,
-                senderKey,
-            ) ?? undefined;
+            const sendingDevice =
+                this.crypto.deviceList.getDeviceByIdentityKey(olmlib.OLM_ALGORITHM, senderKey) ?? undefined;
             const deviceTrust = this.crypto.checkDeviceInfoTrust(event.getSender()!, sendingDevice);
 
             if (fromUs && !deviceTrust.isVerified()) {
@@ -1579,9 +1569,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
         if (content.code === "m.no_olm") {
             const sender = event.getSender()!;
-            logger.warn(
-                `${sender}:${senderKey} was unable to establish an olm session with us`,
-            );
+            logger.warn(`${sender}:${senderKey} was unable to establish an olm session with us`);
             // if the sender says that they haven't been able to establish an olm
             // session, let's proactively establish one
 
@@ -1598,21 +1586,14 @@ export class MegolmDecryption extends DecryptionAlgorithm {
                 this.retryDecryptionFromSender(senderKey);
                 return;
             }
-            let device = this.crypto.deviceList.getDeviceByIdentityKey(
-                content.algorithm, senderKey,
-            );
+            let device = this.crypto.deviceList.getDeviceByIdentityKey(content.algorithm, senderKey);
             if (!device) {
                 // if we don't know about the device, fetch the user's devices again
                 // and retry before giving up
                 await this.crypto.downloadKeys([sender], false);
-                device = this.crypto.deviceList.getDeviceByIdentityKey(
-                    content.algorithm, senderKey,
-                );
+                device = this.crypto.deviceList.getDeviceByIdentityKey(content.algorithm, senderKey);
                 if (!device) {
-                    logger.info(
-                        "Couldn't find device for identity key " + senderKey +
-                        ": not establishing session",
-                    );
+                    logger.info("Couldn't find device for identity key " + senderKey + ": not establishing session");
                     await this.olmDevice.recordSessionProblem(senderKey, "no_olm", false);
                     this.retryDecryptionFromSender(senderKey);
                     return;
@@ -1621,9 +1602,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
             // XXX: switch this to use encryptAndSendToDevices() rather than duplicating it?
 
-            await olmlib.ensureOlmSessionsForDevices(
-                this.olmDevice, this.baseApis, { [sender]: [device] }, false,
-            );
+            await olmlib.ensureOlmSessionsForDevices(this.olmDevice, this.baseApis, { [sender]: [device] }, false);
             const encryptedContent: IEncryptedContent = {
                 algorithm: olmlib.OLM_ALGORITHM,
                 sender_key: this.olmDevice.deviceCurve25519Key!,
@@ -1650,7 +1629,10 @@ export class MegolmDecryption extends DecryptionAlgorithm {
             });
         } else {
             await this.olmDevice.addInboundGroupSessionWithheld(
-                content.room_id, senderKey, content.session_id, content.code,
+                content.room_id,
+                senderKey,
+                content.session_id,
+                content.code,
                 content.reason,
             );
         }
@@ -1675,57 +1657,63 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
         // XXX: switch this to use encryptAndSendToDevices()?
 
-        this.olmlib.ensureOlmSessionsForDevices(
-            this.olmDevice, this.baseApis, {
+        this.olmlib
+            .ensureOlmSessionsForDevices(this.olmDevice, this.baseApis, {
                 [userId]: [deviceInfo],
-            },
-        ).then((devicemap) => {
-            const olmSessionResult = devicemap[userId][deviceId];
-            if (!olmSessionResult.sessionId) {
-                // no session with this device, probably because there
-                // were no one-time keys.
-                //
-                // ensureOlmSessionsForUsers has already done the logging,
-                // so just skip it.
-                return null;
-            }
-
-            logger.log(
-                "sharing keys for session " + body.sender_key + "|"
-                + body.session_id + " with device "
-                + userId + ":" + deviceId,
-            );
+            })
+            .then((devicemap) => {
+                const olmSessionResult = devicemap[userId][deviceId];
+                if (!olmSessionResult.sessionId) {
+                    // no session with this device, probably because there
+                    // were no one-time keys.
+                    //
+                    // ensureOlmSessionsForUsers has already done the logging,
+                    // so just skip it.
+                    return null;
+                }
 
-            return this.buildKeyForwardingMessage(
-                body.room_id, body.sender_key, body.session_id,
-            );
-        }).then((payload) => {
-            const encryptedContent: IEncryptedContent = {
-                algorithm: olmlib.OLM_ALGORITHM,
-                sender_key: this.olmDevice.deviceCurve25519Key!,
-                ciphertext: {},
-                [ToDeviceMessageId]: uuidv4(),
-            };
+                logger.log(
+                    "sharing keys for session " +
+                        body.sender_key +
+                        "|" +
+                        body.session_id +
+                        " with device " +
+                        userId +
+                        ":" +
+                        deviceId,
+                );
 
-            return this.olmlib.encryptMessageForDevice(
-                encryptedContent.ciphertext,
-                this.userId,
-                undefined,
-                this.olmDevice,
-                userId,
-                deviceInfo,
-                payload!,
-            ).then(() => {
-                const contentMap = {
-                    [userId]: {
-                        [deviceId]: encryptedContent,
-                    },
+                return this.buildKeyForwardingMessage(body.room_id, body.sender_key, body.session_id);
+            })
+            .then((payload) => {
+                const encryptedContent: IEncryptedContent = {
+                    algorithm: olmlib.OLM_ALGORITHM,
+                    sender_key: this.olmDevice.deviceCurve25519Key!,
+                    ciphertext: {},
+                    [ToDeviceMessageId]: uuidv4(),
                 };
 
-                // TODO: retries
-                return this.baseApis.sendToDevice("m.room.encrypted", contentMap);
+                return this.olmlib
+                    .encryptMessageForDevice(
+                        encryptedContent.ciphertext,
+                        this.userId,
+                        undefined,
+                        this.olmDevice,
+                        userId,
+                        deviceInfo,
+                        payload!,
+                    )
+                    .then(() => {
+                        const contentMap = {
+                            [userId]: {
+                                [deviceId]: encryptedContent,
+                            },
+                        };
+
+                        // TODO: retries
+                        return this.baseApis.sendToDevice("m.room.encrypted", contentMap);
+                    });
             });
-        });
     }
 
     private async buildKeyForwardingMessage(
@@ -1757,7 +1745,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
      */
     public importRoomKey(
         session: IMegolmSessionData,
-        { untrusted, source }: { untrusted?: boolean, source?: string } = {},
+        { untrusted, source }: { untrusted?: boolean; source?: string } = {},
     ): Promise<void> {
         const extraSessionData: OlmGroupSessionExtraData = {};
         if (untrusted || session.untrusted) {
@@ -1766,29 +1754,29 @@ export class MegolmDecryption extends DecryptionAlgorithm {
         if (session["org.matrix.msc3061.shared_history"]) {
             extraSessionData.sharedHistory = true;
         }
-        return this.olmDevice.addInboundGroupSession(
-            session.room_id,
-            session.sender_key,
-            session.forwarding_curve25519_key_chain,
-            session.session_id,
-            session.session_key,
-            session.sender_claimed_keys,
-            true,
-            extraSessionData,
-        ).then(() => {
-            if (source !== "backup") {
-                // don't wait for it to complete
-                this.crypto.backupManager.backupGroupSession(
-                    session.sender_key, session.session_id,
-                ).catch((e) => {
-                    // This throws if the upload failed, but this is fine
-                    // since it will have written it to the db and will retry.
-                    logger.log("Failed to back up megolm session", e);
-                });
-            }
-            // have another go at decrypting events sent with this session.
-            this.retryDecryption(session.sender_key, session.session_id, !extraSessionData.untrusted);
-        });
+        return this.olmDevice
+            .addInboundGroupSession(
+                session.room_id,
+                session.sender_key,
+                session.forwarding_curve25519_key_chain,
+                session.session_id,
+                session.session_key,
+                session.sender_claimed_keys,
+                true,
+                extraSessionData,
+            )
+            .then(() => {
+                if (source !== "backup") {
+                    // don't wait for it to complete
+                    this.crypto.backupManager.backupGroupSession(session.sender_key, session.session_id).catch((e) => {
+                        // This throws if the upload failed, but this is fine
+                        // since it will have written it to the db and will retry.
+                        logger.log("Failed to back up megolm session", e);
+                    });
+                }
+                // have another go at decrypting events sent with this session.
+                this.retryDecryption(session.sender_key, session.session_id, !extraSessionData.untrusted);
+            });
     }
 
     /**
@@ -1819,13 +1807,15 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
         logger.debug("Retrying decryption on events", [...pending]);
 
-        await Promise.all([...pending].map(async (ev) => {
-            try {
-                await ev.attemptDecryption(this.crypto, { isRetry: true, forceRedecryptIfUntrusted });
-            } catch (e) {
-                // don't die if something goes wrong
-            }
-        }));
+        await Promise.all(
+            [...pending].map(async (ev) => {
+                try {
+                    await ev.attemptDecryption(this.crypto, { isRetry: true, forceRedecryptIfUntrusted });
+                } catch (e) {
+                    // don't die if something goes wrong
+                }
+            }),
+        );
 
         // If decrypted successfully with trusted keys, they'll have
         // been removed from pendingEvents
@@ -1840,15 +1830,19 @@ export class MegolmDecryption extends DecryptionAlgorithm {
 
         this.pendingEvents.delete(senderKey);
 
-        await Promise.all([...senderPendingEvents].map(async ([_sessionId, pending]) => {
-            await Promise.all([...pending].map(async (ev) => {
-                try {
-                    await ev.attemptDecryption(this.crypto);
-                } catch (e) {
-                    // don't die if something goes wrong
-                }
-            }));
-        }));
+        await Promise.all(
+            [...senderPendingEvents].map(async ([_sessionId, pending]) => {
+                await Promise.all(
+                    [...pending].map(async (ev) => {
+                        try {
+                            await ev.attemptDecryption(this.crypto);
+                        } catch (e) {
+                            // don't die if something goes wrong
+                        }
+                    }),
+                );
+            }),
+        );
 
         return !this.pendingEvents.has(senderKey);
     }
@@ -1899,10 +1893,7 @@ export class MegolmDecryption extends DecryptionAlgorithm {
             for (const userId of Object.keys(contentMap)) {
                 for (const deviceId of Object.keys(contentMap[userId])) {
                     if (Object.keys(contentMap[userId][deviceId].ciphertext).length === 0) {
-                        logger.log(
-                            "No ciphertext for device " +
-                            userId + ":" + deviceId + ": pruning",
-                        );
+                        logger.log("No ciphertext for device " + userId + ":" + deviceId + ": pruning");
                         delete contentMap[userId][deviceId];
                     }
                 }
diff --git a/src/crypto/algorithms/olm.ts b/src/crypto/algorithms/olm.ts
index 1feee6ba6cf..90e724d3804 100644
--- a/src/crypto/algorithms/olm.ts
+++ b/src/crypto/algorithms/olm.ts
@@ -18,16 +18,11 @@ limitations under the License.
  * Defines m.olm encryption/decryption
  */
 
-import { logger } from '../../logger';
+import { logger } from "../../logger";
 import * as olmlib from "../olmlib";
 import { DeviceInfo } from "../deviceinfo";
-import {
-    DecryptionAlgorithm,
-    DecryptionError,
-    EncryptionAlgorithm,
-    registerAlgorithm,
-} from "./base";
-import { Room } from '../../models/room';
+import { DecryptionAlgorithm, DecryptionError, EncryptionAlgorithm, registerAlgorithm } from "./base";
+import { Room } from "../../models/room";
 import { IContent, MatrixEvent } from "../../models/event";
 import { IEncryptedContent, IEventDecryptionResult, IOlmEncryptedContent } from "../index";
 import { IInboundSession } from "../OlmDevice";
@@ -65,13 +60,17 @@ class OlmEncryption extends EncryptionAlgorithm {
             return Promise.resolve();
         }
 
-        this.prepPromise = this.crypto.downloadKeys(roomMembers).then(() => {
-            return this.crypto.ensureOlmSessionsForUsers(roomMembers);
-        }).then(() => {
-            this.sessionPrepared = true;
-        }).finally(() => {
-            this.prepPromise = null;
-        });
+        this.prepPromise = this.crypto
+            .downloadKeys(roomMembers)
+            .then(() => {
+                return this.crypto.ensureOlmSessionsForUsers(roomMembers);
+            })
+            .then(() => {
+                this.sessionPrepared = true;
+            })
+            .finally(() => {
+                this.prepPromise = null;
+            });
 
         return this.prepPromise;
     }
@@ -89,7 +88,7 @@ class OlmEncryption extends EncryptionAlgorithm {
 
         const members = await room.getEncryptionTargetMembers();
 
-        const users = members.map(function(u) {
+        const users = members.map(function (u) {
             return u.userId;
         });
 
@@ -126,8 +125,12 @@ class OlmEncryption extends EncryptionAlgorithm {
                 promises.push(
                     olmlib.encryptMessageForDevice(
                         encryptedContent.ciphertext,
-                        this.userId, this.deviceId, this.olmDevice,
-                        userId, deviceInfo, payloadFields,
+                        this.userId,
+                        this.deviceId,
+                        this.olmDevice,
+                        userId,
+                        deviceInfo,
+                        payloadFields,
                     ),
                 );
             }
@@ -155,17 +158,11 @@ class OlmDecryption extends DecryptionAlgorithm {
         const ciphertext = content.ciphertext;
 
         if (!ciphertext) {
-            throw new DecryptionError(
-                "OLM_MISSING_CIPHERTEXT",
-                "Missing ciphertext",
-            );
+            throw new DecryptionError("OLM_MISSING_CIPHERTEXT", "Missing ciphertext");
         }
 
         if (!(this.olmDevice.deviceCurve25519Key! in ciphertext)) {
-            throw new DecryptionError(
-                "OLM_NOT_INCLUDED_IN_RECIPIENTS",
-                "Not included in recipients",
-            );
+            throw new DecryptionError("OLM_NOT_INCLUDED_IN_RECIPIENTS", "Not included in recipients");
         }
         const message = ciphertext[this.olmDevice.deviceCurve25519Key!];
         let payloadString: string;
@@ -173,13 +170,10 @@ class OlmDecryption extends DecryptionAlgorithm {
         try {
             payloadString = await this.decryptMessage(deviceKey, message);
         } catch (e) {
-            throw new DecryptionError(
-                "OLM_BAD_ENCRYPTED_MESSAGE",
-                "Bad Encrypted Message", {
-                    sender: deviceKey,
-                    err: e as Error,
-                },
-            );
+            throw new DecryptionError("OLM_BAD_ENCRYPTED_MESSAGE", "Bad Encrypted Message", {
+                sender: deviceKey,
+                err: e as Error,
+            });
         }
 
         const payload = JSON.parse(payloadString);
@@ -187,20 +181,14 @@ class OlmDecryption extends DecryptionAlgorithm {
         // check that we were the intended recipient, to avoid unknown-key attack
         // https://github.com/vector-im/vector-web/issues/2483
         if (payload.recipient != this.userId) {
-            throw new DecryptionError(
-                "OLM_BAD_RECIPIENT",
-                "Message was intented for " + payload.recipient,
-            );
+            throw new DecryptionError("OLM_BAD_RECIPIENT", "Message was intented for " + payload.recipient);
         }
 
         if (payload.recipient_keys.ed25519 != this.olmDevice.deviceEd25519Key) {
-            throw new DecryptionError(
-                "OLM_BAD_RECIPIENT_KEY",
-                "Message not intended for this device", {
-                    intended: payload.recipient_keys.ed25519,
-                    our_key: this.olmDevice.deviceEd25519Key!,
-                },
-            );
+            throw new DecryptionError("OLM_BAD_RECIPIENT_KEY", "Message not intended for this device", {
+                intended: payload.recipient_keys.ed25519,
+                our_key: this.olmDevice.deviceEd25519Key!,
+            });
         }
 
         // check that the device that encrypted the event belongs to the user
@@ -210,17 +198,11 @@ class OlmDecryption extends DecryptionAlgorithm {
         // secret sharing, may be more strict and reject events that come from
         // unknown devices.
         await this.crypto.deviceList.downloadKeys([event.getSender()!], false);
-        const senderKeyUser = this.crypto.deviceList.getUserByIdentityKey(
-            olmlib.OLM_ALGORITHM,
-            deviceKey,
-        );
+        const senderKeyUser = this.crypto.deviceList.getUserByIdentityKey(olmlib.OLM_ALGORITHM, deviceKey);
         if (senderKeyUser !== event.getSender() && senderKeyUser != undefined) {
-            throw new DecryptionError(
-                "OLM_BAD_SENDER",
-                "Message claimed to be from " + event.getSender(), {
-                    real_sender: senderKeyUser,
-                },
-            );
+            throw new DecryptionError("OLM_BAD_SENDER", "Message claimed to be from " + event.getSender(), {
+                real_sender: senderKeyUser,
+            });
         }
 
         // check that the original sender matches what the homeserver told us, to
@@ -228,22 +210,16 @@ class OlmDecryption extends DecryptionAlgorithm {
         // (this check is also provided via the sender's embedded ed25519 key,
         // which is checked elsewhere).
         if (payload.sender != event.getSender()) {
-            throw new DecryptionError(
-                "OLM_FORWARDED_MESSAGE",
-                "Message forwarded from " + payload.sender, {
-                    reported_sender: event.getSender()!,
-                },
-            );
+            throw new DecryptionError("OLM_FORWARDED_MESSAGE", "Message forwarded from " + payload.sender, {
+                reported_sender: event.getSender()!,
+            });
         }
 
         // Olm events intended for a room have a room_id.
         if (payload.room_id !== event.getRoomId()) {
-            throw new DecryptionError(
-                "OLM_BAD_ROOM",
-                "Message intended for room " + payload.room_id, {
-                    reported_room: event.getRoomId() || "ROOM_ID_UNDEFINED",
-                },
-            );
+            throw new DecryptionError("OLM_BAD_ROOM", "Message intended for room " + payload.room_id, {
+                reported_room: event.getRoomId() || "ROOM_ID_UNDEFINED",
+            });
         }
 
         const claimedKeys = payload.keys || {};
@@ -288,16 +264,19 @@ class OlmDecryption extends DecryptionAlgorithm {
         for (const sessionId of sessionIds) {
             try {
                 const payload = await this.olmDevice.decryptMessage(
-                    theirDeviceIdentityKey, sessionId, message.type, message.body,
-                );
-                logger.log(
-                    "Decrypted Olm message from " + theirDeviceIdentityKey +
-                    " with session " + sessionId,
+                    theirDeviceIdentityKey,
+                    sessionId,
+                    message.type,
+                    message.body,
                 );
+                logger.log("Decrypted Olm message from " + theirDeviceIdentityKey + " with session " + sessionId);
                 return payload;
             } catch (e) {
                 const foundSession = await this.olmDevice.matchesSession(
-                    theirDeviceIdentityKey, sessionId, message.type, message.body,
+                    theirDeviceIdentityKey,
+                    sessionId,
+                    message.type,
+                    message.body,
                 );
 
                 if (foundSession) {
@@ -305,7 +284,9 @@ class OlmDecryption extends DecryptionAlgorithm {
                     // session, so it should have worked.
                     throw new Error(
                         "Error decrypting prekey message with existing session id " +
-                        sessionId + ": " + (<Error>e).message,
+                            sessionId +
+                            ": " +
+                            (<Error>e).message,
                     );
                 }
 
@@ -324,8 +305,7 @@ class OlmDecryption extends DecryptionAlgorithm {
             }
 
             throw new Error(
-                "Error decrypting non-prekey message with existing sessions: " +
-                JSON.stringify(decryptionErrors),
+                "Error decrypting non-prekey message with existing sessions: " + JSON.stringify(decryptionErrors),
             );
         }
 
@@ -334,21 +314,13 @@ class OlmDecryption extends DecryptionAlgorithm {
 
         let res: IInboundSession;
         try {
-            res = await this.olmDevice.createInboundSession(
-                theirDeviceIdentityKey, message.type, message.body,
-            );
+            res = await this.olmDevice.createInboundSession(theirDeviceIdentityKey, message.type, message.body);
         } catch (e) {
             decryptionErrors["(new)"] = (<Error>e).message;
-            throw new Error(
-                "Error decrypting prekey message: " +
-                JSON.stringify(decryptionErrors),
-            );
+            throw new Error("Error decrypting prekey message: " + JSON.stringify(decryptionErrors));
         }
 
-        logger.log(
-            "created new inbound Olm session ID " +
-            res.session_id + " with " + theirDeviceIdentityKey,
-        );
+        logger.log("created new inbound Olm session ID " + res.session_id + " with " + theirDeviceIdentityKey);
         return res.payload;
     }
 }
diff --git a/src/crypto/backup.ts b/src/crypto/backup.ts
index fa90c6b7865..fe1ae6622af 100644
--- a/src/crypto/backup.ts
+++ b/src/crypto/backup.ts
@@ -22,12 +22,12 @@ import { MatrixClient } from "../client";
 import { logger } from "../logger";
 import { MEGOLM_ALGORITHM, verifySignature } from "./olmlib";
 import { DeviceInfo } from "./deviceinfo";
-import { DeviceTrustLevel } from './CrossSigning';
-import { keyFromPassphrase } from './key_passphrase';
+import { DeviceTrustLevel } from "./CrossSigning";
+import { keyFromPassphrase } from "./key_passphrase";
 import { sleep } from "../utils";
-import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
-import { encodeRecoveryKey } from './recoverykey';
-import { calculateKeyCheck, decryptAES, encryptAES, IEncryptedPayload } from './aes';
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store";
+import { encodeRecoveryKey } from "./recoverykey";
+import { calculateKeyCheck, decryptAES, encryptAES, IEncryptedPayload } from "./aes";
 import {
     Curve25519SessionData,
     IAes256AuthData,
@@ -227,7 +227,7 @@ export class BackupManager {
         }
         let backupInfo: IKeyBackupInfo | undefined;
         try {
-            backupInfo = await this.baseApis.getKeyBackupVersion() ?? undefined;
+            backupInfo = (await this.baseApis.getKeyBackupVersion()) ?? undefined;
         } catch (e) {
             logger.log("Error checking for active key backup", e);
             if ((<HTTPError>e).httpStatus === 404) {
@@ -252,8 +252,10 @@ export class BackupManager {
         } else if (trustInfo.usable && this.backupInfo) {
             // may not be the same version: if not, we should switch
             if (backupInfo!.version !== this.backupInfo.version) {
-                logger.log(`On backup version ${this.backupInfo.version} but ` +
-                    `found version ${backupInfo!.version}: switching.`);
+                logger.log(
+                    `On backup version ${this.backupInfo.version} but ` +
+                        `found version ${backupInfo!.version}: switching.`,
+                );
                 this.disableKeyBackup();
                 await this.enableKeyBackup(backupInfo!);
                 // We're now using a new backup, so schedule all the keys we have to be
@@ -292,12 +294,14 @@ export class BackupManager {
         targetRoomId: string | undefined,
         targetSessionId: string | undefined,
     ): Promise<void> {
-        if (!this.backupInfo) { return; }
+        if (!this.backupInfo) {
+            return;
+        }
 
         const now = new Date().getTime();
         if (
-            !this.sessionLastCheckAttemptedTime[targetSessionId!]
-                || now - this.sessionLastCheckAttemptedTime[targetSessionId!] > KEY_BACKUP_CHECK_RATE_LIMIT
+            !this.sessionLastCheckAttemptedTime[targetSessionId!] ||
+            now - this.sessionLastCheckAttemptedTime[targetSessionId!] > KEY_BACKUP_CHECK_RATE_LIMIT
         ) {
             this.sessionLastCheckAttemptedTime[targetSessionId!] = now;
             await this.baseApis.restoreKeyBackupWithCache(targetRoomId!, targetSessionId!, this.backupInfo, {});
@@ -316,12 +320,7 @@ export class BackupManager {
             sigs: [] as SigInfo[],
         };
 
-        if (
-            !backupInfo ||
-                !backupInfo.algorithm ||
-                !backupInfo.auth_data ||
-                !backupInfo.auth_data.signatures
-        ) {
+        if (!backupInfo || !backupInfo.algorithm || !backupInfo.auth_data || !backupInfo.auth_data.signatures) {
             logger.info("Key backup is absent or missing required data");
             return ret;
         }
@@ -348,8 +347,8 @@ export class BackupManager {
         const mySigs = backupInfo.auth_data.signatures[userId] || {};
 
         for (const keyId of Object.keys(mySigs)) {
-            const keyIdParts = keyId.split(':');
-            if (keyIdParts[0] !== 'ed25519') {
+            const keyIdParts = keyId.split(":");
+            if (keyIdParts[0] !== "ed25519") {
                 logger.log("Ignoring unknown signature type: " + keyIdParts[0]);
                 continue;
             }
@@ -371,9 +370,7 @@ export class BackupManager {
                     );
                     sigInfo.valid = true;
                 } catch (e) {
-                    logger.warn(
-                        "Bad signature from cross signing key " + crossSigningId, e,
-                    );
+                    logger.warn("Bad signature from cross signing key " + crossSigningId, e);
                     sigInfo.valid = false;
                 }
                 ret.sigs.push(sigInfo);
@@ -383,8 +380,7 @@ export class BackupManager {
             // Now look for a sig from a device
             // At some point this can probably go away and we'll just support
             // it being signed by the cross-signing master key
-            const device = this.baseApis.crypto!.deviceList.getStoredDevice(userId, sigInfo.deviceId,
-            );
+            const device = this.baseApis.crypto!.deviceList.getStoredDevice(userId, sigInfo.deviceId);
             if (device) {
                 sigInfo.device = device;
                 sigInfo.deviceTrust = this.baseApis.checkDeviceTrust(userId, sigInfo.deviceId);
@@ -399,9 +395,16 @@ export class BackupManager {
                     sigInfo.valid = true;
                 } catch (e) {
                     logger.info(
-                        "Bad signature from key ID " + keyId + " userID " + this.baseApis.getUserId() +
-                            " device ID " + device.deviceId + " fingerprint: " +
-                            device.getFingerprint(), backupInfo.auth_data, e,
+                        "Bad signature from key ID " +
+                            keyId +
+                            " userID " +
+                            this.baseApis.getUserId() +
+                            " device ID " +
+                            device.deviceId +
+                            " fingerprint: " +
+                            device.getFingerprint(),
+                        backupInfo.auth_data,
+                        e,
                     );
                     sigInfo.valid = false;
                 }
@@ -413,7 +416,7 @@ export class BackupManager {
         }
 
         ret.usable = ret.sigs.some((s) => {
-            return s.valid && ((s.device && s.deviceTrust?.isVerified()) || (s.crossSigningId));
+            return s.valid && ((s.device && s.deviceTrust?.isVerified()) || s.crossSigningId);
         });
         return ret;
     }
@@ -441,8 +444,7 @@ export class BackupManager {
                     return;
                 }
                 try {
-                    const numBackedUp =
-                        await this.backupPendingKeys(KEY_BACKUP_KEYS_PER_REQUEST);
+                    const numBackedUp = await this.backupPendingKeys(KEY_BACKUP_KEYS_PER_REQUEST);
                     if (numBackedUp === 0) {
                         // no sessions left needing backup: we're done
                         return;
@@ -453,8 +455,8 @@ export class BackupManager {
                     logger.log("Key backup request failed", err);
                     if ((<MatrixError>err).data) {
                         if (
-                            (<MatrixError>err).data.errcode == 'M_NOT_FOUND' ||
-                            (<MatrixError>err).data.errcode == 'M_WRONG_ROOM_KEYS_VERSION'
+                            (<MatrixError>err).data.errcode == "M_NOT_FOUND" ||
+                            (<MatrixError>err).data.errcode == "M_WRONG_ROOM_KEYS_VERSION"
                         ) {
                             // Re-check key backup status on error, so we can be
                             // sure to present the current situation when asked.
@@ -500,22 +502,21 @@ export class BackupManager {
             }
 
             const sessionData = this.baseApis.crypto!.olmDevice.exportInboundGroupSession(
-                session.senderKey, session.sessionId, session.sessionData!,
+                session.senderKey,
+                session.sessionId,
+                session.sessionData!,
             );
             sessionData.algorithm = MEGOLM_ALGORITHM;
 
-            const forwardedCount =
-                (sessionData.forwarding_curve25519_key_chain || []).length;
+            const forwardedCount = (sessionData.forwarding_curve25519_key_chain || []).length;
 
-            const userId = this.baseApis.crypto!.deviceList.getUserByIdentityKey(
-                MEGOLM_ALGORITHM, session.senderKey,
-            );
-            const device = this.baseApis.crypto!.deviceList.getDeviceByIdentityKey(
-                MEGOLM_ALGORITHM, session.senderKey,
-            ) ?? undefined;
+            const userId = this.baseApis.crypto!.deviceList.getUserByIdentityKey(MEGOLM_ALGORITHM, session.senderKey);
+            const device =
+                this.baseApis.crypto!.deviceList.getDeviceByIdentityKey(MEGOLM_ALGORITHM, session.senderKey) ??
+                undefined;
             const verified = this.baseApis.crypto!.checkDeviceInfoTrust(userId!, device).isVerified();
 
-            rooms[roomId]['sessions'][session.sessionId] = {
+            rooms[roomId]["sessions"][session.sessionId] = {
                 first_message_index: sessionData.first_known_index,
                 forwarded_count: forwardedCount,
                 is_verified: verified,
@@ -532,13 +533,13 @@ export class BackupManager {
         return sessions.length;
     }
 
-    public async backupGroupSession(
-        senderKey: string, sessionId: string,
-    ): Promise<void> {
-        await this.baseApis.crypto!.cryptoStore.markSessionsNeedingBackup([{
-            senderKey: senderKey,
-            sessionId: sessionId,
-        }]);
+    public async backupGroupSession(senderKey: string, sessionId: string): Promise<void> {
+        await this.baseApis.crypto!.cryptoStore.markSessionsNeedingBackup([
+            {
+                senderKey: senderKey,
+                sessionId: sessionId,
+            },
+        ]);
 
         if (this.backupInfo) {
             // don't wait for this to complete: it will delay so
@@ -568,11 +569,8 @@ export class BackupManager {
      */
     public async flagAllGroupSessionsForBackup(): Promise<number> {
         await this.baseApis.crypto!.cryptoStore.doTxn(
-            'readwrite',
-            [
-                IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
-                IndexedDBCryptoStore.STORE_BACKUP,
-            ],
+            "readwrite",
+            [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS, IndexedDBCryptoStore.STORE_BACKUP],
             (txn) => {
                 this.baseApis.crypto!.cryptoStore.getAllEndToEndInboundGroupSessions(txn, (session) => {
                     if (session !== null) {
@@ -605,10 +603,7 @@ export class Curve25519 implements BackupAlgorithm {
         private getKey: () => Promise<Uint8Array>,
     ) {}
 
-    public static async init(
-        authData: AuthData,
-        getKey: () => Promise<Uint8Array>,
-    ): Promise<Curve25519> {
+    public static async init(authData: AuthData, getKey: () => Promise<Uint8Array>): Promise<Curve25519> {
         if (!authData || !("public_key" in authData)) {
             throw new Error("auth_data missing required information");
         }
@@ -617,9 +612,7 @@ export class Curve25519 implements BackupAlgorithm {
         return new Curve25519(authData as ICurve25519AuthData, publicKey, getKey);
     }
 
-    public static async prepare(
-        key?: string | Uint8Array | null,
-    ): Promise<[Uint8Array, AuthData]> {
+    public static async prepare(key?: string | Uint8Array | null): Promise<[Uint8Array, AuthData]> {
         const decryption = new global.Olm.PkDecryption();
         try {
             const authData: Partial<ICurve25519AuthData> = {};
@@ -636,10 +629,7 @@ export class Curve25519 implements BackupAlgorithm {
             const publicKey = new global.Olm.PkEncryption();
             publicKey.set_recipient_key(authData.public_key);
 
-            return [
-                decryption.get_private_key(),
-                authData as AuthData,
-            ];
+            return [decryption.get_private_key(), authData as AuthData];
         } finally {
             decryption.free();
         }
@@ -651,7 +641,9 @@ export class Curve25519 implements BackupAlgorithm {
         }
     }
 
-    public get untrusted(): boolean { return true; }
+    public get untrusted(): boolean {
+        return true;
+    }
 
     public async encryptSession(data: Record<string, any>): Promise<Curve25519SessionData> {
         const plainText: Record<string, any> = Object.assign({}, data);
@@ -677,11 +669,13 @@ export class Curve25519 implements BackupAlgorithm {
 
             for (const [sessionId, sessionData] of Object.entries(sessions)) {
                 try {
-                    const decrypted = JSON.parse(decryption.decrypt(
-                        sessionData.session_data.ephemeral,
-                        sessionData.session_data.mac,
-                        sessionData.session_data.ciphertext,
-                    ));
+                    const decrypted = JSON.parse(
+                        decryption.decrypt(
+                            sessionData.session_data.ephemeral,
+                            sessionData.session_data.mac,
+                            sessionData.session_data.ciphertext,
+                        ),
+                    );
                     decrypted.session_id = sessionId;
                     keys.push(decrypted);
                 } catch (e) {
@@ -725,31 +719,23 @@ const UNSTABLE_MSC3270_NAME = new UnstableValue(
 export class Aes256 implements BackupAlgorithm {
     public static algorithmName = UNSTABLE_MSC3270_NAME.name;
 
-    public constructor(
-        public readonly authData: IAes256AuthData,
-        private readonly key: Uint8Array,
-    ) {}
+    public constructor(public readonly authData: IAes256AuthData, private readonly key: Uint8Array) {}
 
-    public static async init(
-        authData: IAes256AuthData,
-        getKey: () => Promise<Uint8Array>,
-    ): Promise<Aes256> {
+    public static async init(authData: IAes256AuthData, getKey: () => Promise<Uint8Array>): Promise<Aes256> {
         if (!authData) {
             throw new Error("auth_data missing");
         }
         const key = await getKey();
         if (authData.mac) {
             const { mac } = await calculateKeyCheck(key, authData.iv);
-            if (authData.mac.replace(/=+$/g, '') !== mac.replace(/=+/g, '')) {
+            if (authData.mac.replace(/=+$/g, "") !== mac.replace(/=+/g, "")) {
                 throw new Error("Key does not match");
             }
         }
         return new Aes256(authData, key);
     }
 
-    public static async prepare(
-        key?: string | Uint8Array | null,
-    ): Promise<[Uint8Array, AuthData]> {
+    public static async prepare(key?: string | Uint8Array | null): Promise<[Uint8Array, AuthData]> {
         let outKey: Uint8Array;
         const authData: Partial<IAes256AuthData> = {};
         if (!key) {
@@ -776,7 +762,9 @@ export class Aes256 implements BackupAlgorithm {
         }
     }
 
-    public get untrusted(): boolean { return false; }
+    public get untrusted(): boolean {
+        return false;
+    }
 
     public encryptSession(data: Record<string, any>): Promise<IEncryptedPayload> {
         const plainText: Record<string, any> = Object.assign({}, data);
@@ -806,7 +794,7 @@ export class Aes256 implements BackupAlgorithm {
     public async keyMatches(key: Uint8Array): Promise<boolean> {
         if (this.authData.mac) {
             const { mac } = await calculateKeyCheck(key, this.authData.iv);
-            return this.authData.mac.replace(/=+$/g, '') === mac.replace(/=+/g, '');
+            return this.authData.mac.replace(/=+$/g, "") === mac.replace(/=+/g, "");
         } else {
             // if we have no information, we have to assume the key is right
             return true;
diff --git a/src/crypto/dehydration.ts b/src/crypto/dehydration.ts
index 1ed16b74cbd..f30d2a5329b 100644
--- a/src/crypto/dehydration.ts
+++ b/src/crypto/dehydration.ts
@@ -16,10 +16,10 @@ limitations under the License.
 
 import anotherjson from "another-json";
 
-import { decodeBase64, encodeBase64 } from './olmlib';
-import { IndexedDBCryptoStore } from '../crypto/store/indexeddb-crypto-store';
-import { decryptAES, encryptAES } from './aes';
-import { logger } from '../logger';
+import { decodeBase64, encodeBase64 } from "./olmlib";
+import { IndexedDBCryptoStore } from "../crypto/store/indexeddb-crypto-store";
+import { decryptAES, encryptAES } from "./aes";
+import { logger } from "../logger";
 import { ISecretStorageKeyInfo } from "./api";
 import { Crypto } from "./index";
 import { Method } from "../http-api";
@@ -27,7 +27,8 @@ import { ISignatures } from "../@types/signed";
 
 export interface IDehydratedDevice {
     device_id: string; // eslint-disable-line camelcase
-    device_data: ISecretStorageKeyInfo & { // eslint-disable-line camelcase
+    device_data: ISecretStorageKeyInfo & {
+        // eslint-disable-line camelcase
         algorithm: string;
         account: string; // pickle
     };
@@ -59,7 +60,7 @@ export class DehydrationManager {
     private inProgress = false;
     private timeoutId: any;
     private key?: Uint8Array;
-    private keyInfo?: {[props: string]: any};
+    private keyInfo?: { [props: string]: any };
     private deviceDisplayName?: string;
 
     public constructor(private readonly crypto: Crypto) {
@@ -67,36 +68,31 @@ export class DehydrationManager {
     }
 
     public getDehydrationKeyFromCache(): Promise<void> {
-        return this.crypto.cryptoStore.doTxn(
-            'readonly',
-            [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.crypto.cryptoStore.getSecretStorePrivateKey(
-                    txn,
-                    async (result) => {
-                        if (result) {
-                            const { key, keyInfo, deviceDisplayName, time } = result;
-                            const pickleKey = Buffer.from(this.crypto.olmDevice.pickleKey);
-                            const decrypted = await decryptAES(key, pickleKey, DEHYDRATION_ALGORITHM);
-                            this.key = decodeBase64(decrypted);
-                            this.keyInfo = keyInfo;
-                            this.deviceDisplayName = deviceDisplayName;
-                            const now = Date.now();
-                            const delay = Math.max(1, time + oneweek - now);
-                            this.timeoutId = global.setTimeout(
-                                this.dehydrateDevice.bind(this), delay,
-                            );
-                        }
-                    },
-                    "dehydration",
-                );
-            },
-        );
+        return this.crypto.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.crypto.cryptoStore.getSecretStorePrivateKey(
+                txn,
+                async (result) => {
+                    if (result) {
+                        const { key, keyInfo, deviceDisplayName, time } = result;
+                        const pickleKey = Buffer.from(this.crypto.olmDevice.pickleKey);
+                        const decrypted = await decryptAES(key, pickleKey, DEHYDRATION_ALGORITHM);
+                        this.key = decodeBase64(decrypted);
+                        this.keyInfo = keyInfo;
+                        this.deviceDisplayName = deviceDisplayName;
+                        const now = Date.now();
+                        const delay = Math.max(1, time + oneweek - now);
+                        this.timeoutId = global.setTimeout(this.dehydrateDevice.bind(this), delay);
+                    }
+                },
+                "dehydration",
+            );
+        });
     }
 
     /** set the key, and queue periodic dehydration to the server in the background */
     public async setKeyAndQueueDehydration(
-        key: Uint8Array, keyInfo: {[props: string]: any} = {},
+        key: Uint8Array,
+        keyInfo: { [props: string]: any } = {},
         deviceDisplayName?: string,
     ): Promise<void> {
         const matches = await this.setKey(key, keyInfo, deviceDisplayName);
@@ -107,7 +103,8 @@ export class DehydrationManager {
     }
 
     public async setKey(
-        key: Uint8Array, keyInfo: {[props: string]: any} = {},
+        key: Uint8Array,
+        keyInfo: { [props: string]: any } = {},
         deviceDisplayName?: string,
     ): Promise<boolean | undefined> {
         if (!key) {
@@ -117,15 +114,9 @@ export class DehydrationManager {
                 this.timeoutId = undefined;
             }
             // clear storage
-            await this.crypto.cryptoStore.doTxn(
-                'readwrite',
-                [IndexedDBCryptoStore.STORE_ACCOUNT],
-                (txn) => {
-                    this.crypto.cryptoStore.storeSecretStorePrivateKey(
-                        txn, "dehydration", null,
-                    );
-                },
-            );
+            await this.crypto.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+                this.crypto.cryptoStore.storeSecretStorePrivateKey(txn, "dehydration", null);
+            });
             this.key = undefined;
             this.keyInfo = undefined;
             return;
@@ -165,21 +156,14 @@ export class DehydrationManager {
 
             // update the crypto store with the timestamp
             const key = await encryptAES(encodeBase64(this.key!), pickleKey, DEHYDRATION_ALGORITHM);
-            await this.crypto.cryptoStore.doTxn(
-                'readwrite',
-                [IndexedDBCryptoStore.STORE_ACCOUNT],
-                (txn) => {
-                    this.crypto.cryptoStore.storeSecretStorePrivateKey(
-                        txn, "dehydration",
-                        {
-                            keyInfo: this.keyInfo,
-                            key,
-                            deviceDisplayName: this.deviceDisplayName!,
-                            time: Date.now(),
-                        },
-                    );
-                },
-            );
+            await this.crypto.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+                this.crypto.cryptoStore.storeSecretStorePrivateKey(txn, "dehydration", {
+                    keyInfo: this.keyInfo,
+                    key,
+                    deviceDisplayName: this.deviceDisplayName!,
+                    time: Date.now(),
+                });
+            });
             logger.log("Attempting to dehydrate device");
 
             logger.log("Creating account");
@@ -199,7 +183,7 @@ export class DehydrationManager {
             // dehydrate the account and store it on the server
             const pickledAccount = account.pickle(new Uint8Array(this.key!));
 
-            const deviceData: {[props: string]: any} = {
+            const deviceData: { [props: string]: any } = {
                 algorithm: DEHYDRATION_ALGORITHM,
                 account: pickledAccount,
             };
@@ -284,9 +268,7 @@ export class DehydrationManager {
             logger.log("Done dehydrating");
 
             // dehydrate again in a week
-            this.timeoutId = global.setTimeout(
-                this.dehydrateDevice.bind(this), oneweek,
-            );
+            this.timeoutId = global.setTimeout(this.dehydrateDevice.bind(this), oneweek);
 
             return deviceId;
         } finally {
diff --git a/src/crypto/deviceinfo.ts b/src/crypto/deviceinfo.ts
index 1fbbd280044..b4bb4fd2e80 100644
--- a/src/crypto/deviceinfo.ts
+++ b/src/crypto/deviceinfo.ts
@@ -32,8 +32,8 @@ enum DeviceVerification {
 }
 
 /**
-  * Information about a user's device
-  */
+ * Information about a user's device
+ */
 export class DeviceInfo {
     /**
      * rehydrate a DeviceInfo from the session store
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 9191522da25..74df3b5a13a 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -22,8 +22,8 @@ import { v4 as uuidv4 } from "uuid";
 
 import type { PkDecryption, PkSigning } from "@matrix-org/olm";
 import { EventType, ToDeviceMessageId } from "../@types/event";
-import { TypedReEmitter } from '../ReEmitter';
-import { logger } from '../logger';
+import { TypedReEmitter } from "../ReEmitter";
+import { logger } from "../logger";
 import { IExportedDevice, OlmDevice } from "./OlmDevice";
 import { IOlmDevice } from "./algorithms/megolm";
 import * as olmlib from "./olmlib";
@@ -31,7 +31,7 @@ import { DeviceInfoMap, DeviceList } from "./DeviceList";
 import { DeviceInfo, IDevice } from "./deviceinfo";
 import type { DecryptionAlgorithm, EncryptionAlgorithm } from "./algorithms";
 import * as algorithms from "./algorithms";
-import { createCryptoStoreCacheCallbacks, CrossSigningInfo, DeviceTrustLevel, UserTrustLevel } from './CrossSigning';
+import { createCryptoStoreCacheCallbacks, CrossSigningInfo, DeviceTrustLevel, UserTrustLevel } from "./CrossSigning";
 import { EncryptionSetupBuilder } from "./EncryptionSetup";
 import {
     IAccountDataClient,
@@ -40,7 +40,7 @@ import {
     SecretStorage,
     SecretStorageKeyObject,
     SecretStorageKeyTuple,
-} from './SecretStorage';
+} from "./SecretStorage";
 import {
     IAddSecretStorageKeyOpts,
     ICreateSecretStorageOpts,
@@ -49,20 +49,20 @@ import {
     IRecoveryKey,
     ISecretStorageKeyInfo,
 } from "./api";
-import { OutgoingRoomKeyRequestManager } from './OutgoingRoomKeyRequestManager';
-import { IndexedDBCryptoStore } from './store/indexeddb-crypto-store';
+import { OutgoingRoomKeyRequestManager } from "./OutgoingRoomKeyRequestManager";
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store";
 import { VerificationBase } from "./verification/Base";
-import { ReciprocateQRCode, SCAN_QR_CODE_METHOD, SHOW_QR_CODE_METHOD } from './verification/QRCode';
-import { SAS as SASVerification } from './verification/SAS';
-import { keyFromPassphrase } from './key_passphrase';
-import { decodeRecoveryKey, encodeRecoveryKey } from './recoverykey';
+import { ReciprocateQRCode, SCAN_QR_CODE_METHOD, SHOW_QR_CODE_METHOD } from "./verification/QRCode";
+import { SAS as SASVerification } from "./verification/SAS";
+import { keyFromPassphrase } from "./key_passphrase";
+import { decodeRecoveryKey, encodeRecoveryKey } from "./recoverykey";
 import { VerificationRequest } from "./verification/request/VerificationRequest";
 import { InRoomChannel, InRoomRequests } from "./verification/request/InRoomChannel";
 import { ToDeviceChannel, ToDeviceRequests, Request } from "./verification/request/ToDeviceChannel";
 import { IllegalMethod } from "./verification/IllegalMethod";
 import { KeySignatureUploadError } from "../errors";
-import { calculateKeyCheck, decryptAES, encryptAES } from './aes';
-import { DehydrationManager, IDeviceKeys, IOneTimeKey } from './dehydration';
+import { calculateKeyCheck, decryptAES, encryptAES } from "./aes";
+import { DehydrationManager, IDeviceKeys, IOneTimeKey } from "./dehydration";
 import { BackupManager } from "./backup";
 import { IStore } from "../store";
 import { Room, RoomEvent } from "../models/room";
@@ -136,23 +136,20 @@ export interface IBootstrapCrossSigningOpts {
 export interface ICryptoCallbacks {
     getCrossSigningKey?: (keyType: string, pubKey: string) => Promise<Uint8Array | null>;
     saveCrossSigningKeys?: (keys: Record<string, Uint8Array>) => void;
-    shouldUpgradeDeviceVerifications?: (
-        users: Record<string, any>
-    ) => Promise<string[]>;
+    shouldUpgradeDeviceVerifications?: (users: Record<string, any>) => Promise<string[]>;
     getSecretStorageKey?: (
-        keys: {keys: Record<string, ISecretStorageKeyInfo>}, name: string
+        keys: { keys: Record<string, ISecretStorageKeyInfo> },
+        name: string,
     ) => Promise<[string, Uint8Array] | null>;
-    cacheSecretStorageKey?: (
-        keyId: string, keyInfo: ISecretStorageKeyInfo, key: Uint8Array
-    ) => void;
+    cacheSecretStorageKey?: (keyId: string, keyInfo: ISecretStorageKeyInfo, key: Uint8Array) => void;
     onSecretRequested?: (
-        userId: string, deviceId: string,
-        requestId: string, secretName: string, deviceTrust: DeviceTrustLevel
+        userId: string,
+        deviceId: string,
+        requestId: string,
+        secretName: string,
+        deviceTrust: DeviceTrustLevel,
     ) => Promise<string>;
-    getDehydrationKey?: (
-        keyInfo: ISecretStorageKeyInfo,
-        checkFunc: (key: Uint8Array) => void,
-    ) => Promise<Uint8Array>;
+    getDehydrationKey?: (keyInfo: ISecretStorageKeyInfo, checkFunc: (key: Uint8Array) => void) => Promise<Uint8Array>;
     getBackupKey?: () => Promise<Uint8Array>;
 }
 
@@ -340,10 +337,11 @@ export type CryptoEventHandlerMap = {
     [CryptoEvent.KeySignatureUploadFailure]: (
         failures: IUploadKeySignaturesResponse["failures"],
         source: "checkOwnCrossSigningTrust" | "afterCrossSigningLocalKeyChange" | "setDeviceVerification",
-        upload: (opts: { shouldEmit: boolean }) => Promise<void>
-    ) => void;/**
+        upload: (opts: { shouldEmit: boolean }) => Promise<void>,
+    ) => void
+    /**
      * Fires when a key verification is requested.
-     */
+     */;
     [CryptoEvent.VerificationRequest]: (request: VerificationRequest<any>) => void;
     /**
      * Fires when the app may wish to warn the user about something related
@@ -499,17 +497,16 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                         );
                     }
                 } else if (method["NAME"]) {
-                    this.verificationMethods.set(
-                        method["NAME"],
-                        method as typeof VerificationBase,
-                    );
+                    this.verificationMethods.set(method["NAME"], method as typeof VerificationBase);
                 } else {
                     logger.warn(`Excluding unknown verification method ${method}`);
                 }
             }
         } else {
-            this.verificationMethods =
-                new Map(Object.entries(defaultVerificationMethods)) as Map<VerificationMethod, typeof VerificationBase>;
+            this.verificationMethods = new Map(Object.entries(defaultVerificationMethods)) as Map<
+                VerificationMethod,
+                typeof VerificationBase
+            >;
         }
 
         this.backupManager = new BackupManager(baseApis, async () => {
@@ -553,7 +550,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         this.supportedAlgorithms = Array.from(algorithms.DECRYPTION_CLASSES.keys());
 
         this.outgoingRoomKeyRequestManager = new OutgoingRoomKeyRequestManager(
-            baseApis, this.deviceId, this.cryptoStore,
+            baseApis,
+            this.deviceId,
+            this.cryptoStore,
         );
 
         this.toDeviceVerificationRequests = new ToDeviceRequests();
@@ -586,9 +585,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     public async init({ exportedOlmDevice, pickleKey }: IInitOpts = {}): Promise<void> {
         logger.log("Crypto: initialising Olm...");
         await global.Olm.init();
-        logger.log(exportedOlmDevice
-            ? "Crypto: initialising Olm device from exported device..."
-            : "Crypto: initialising Olm device...",
+        logger.log(
+            exportedOlmDevice
+                ? "Crypto: initialising Olm device from exported device..."
+                : "Crypto: initialising Olm device...",
         );
         await this.olmDevice.init({ fromExportedDevice: exportedOlmDevice, pickleKey });
         logger.log("Crypto: loading device list...");
@@ -620,18 +620,15 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             this.deviceList.saveIfDirty();
         }
 
-        await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.cryptoStore.getCrossSigningKeys(txn, (keys) => {
-                    // can be an empty object after resetting cross-signing keys, see storeTrustedSelfKeys
-                    if (keys && Object.keys(keys).length !== 0) {
-                        logger.log("Loaded cross-signing public keys from crypto store");
-                        this.crossSigningInfo.setKeys(keys);
-                    }
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.cryptoStore.getCrossSigningKeys(txn, (keys) => {
+                // can be an empty object after resetting cross-signing keys, see storeTrustedSelfKeys
+                if (keys && Object.keys(keys).length !== 0) {
+                    logger.log("Loaded cross-signing public keys from crypto store");
+                    this.crossSigningInfo.setKeys(keys);
+                }
+            });
+        });
         // make sure we are keeping track of our own devices
         // (this is important for key backups & things)
         this.deviceList.startTrackingDeviceList(this.userId);
@@ -670,10 +667,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                 // If the device is locally verified then isVerified() is always true,
                 // so this will only have caused the value to change if the device is
                 // cross-signing verified but not locally verified
-                if (
-                    !deviceTrust.isLocallyVerified() &&
-                    deviceTrust.isCrossSigningVerified()
-                ) {
+                if (!deviceTrust.isLocallyVerified() && deviceTrust.isCrossSigningVerified()) {
                     const deviceObj = this.deviceList.getStoredDevice(userId, deviceId)!;
                     this.emit(CryptoEvent.DeviceVerificationChanged, userId, deviceId, deviceObj);
                 }
@@ -747,10 +741,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      */
     public async isCrossSigningReady(): Promise<boolean> {
         const publicKeysOnDevice = this.crossSigningInfo.getId();
-        const privateKeysExistSomewhere = (
-            await this.crossSigningInfo.isStoredInKeyCache() ||
-            await this.crossSigningInfo.isStoredInSecretStorage(this.secretStorage)
-        );
+        const privateKeysExistSomewhere =
+            (await this.crossSigningInfo.isStoredInKeyCache()) ||
+            (await this.crossSigningInfo.isStoredInSecretStorage(this.secretStorage));
 
         return !!(publicKeysOnDevice && privateKeysExistSomewhere);
     }
@@ -772,19 +765,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      */
     public async isSecretStorageReady(): Promise<boolean> {
         const secretStorageKeyInAccount = await this.secretStorage.hasKey();
-        const privateKeysInStorage = await this.crossSigningInfo.isStoredInSecretStorage(
-            this.secretStorage,
-        );
-        const sessionBackupInStorage = (
-            !this.backupManager.getKeyBackupEnabled() ||
-            await this.baseApis.isKeyBackupKeyStored()
-        );
+        const privateKeysInStorage = await this.crossSigningInfo.isStoredInSecretStorage(this.secretStorage);
+        const sessionBackupInStorage =
+            !this.backupManager.getKeyBackupEnabled() || (await this.baseApis.isKeyBackupKeyStored());
 
-        return !!(
-            secretStorageKeyInAccount &&
-            privateKeysInStorage &&
-            sessionBackupInStorage
-        );
+        return !!(secretStorageKeyInAccount && privateKeysInStorage && sessionBackupInStorage);
     }
 
     /**
@@ -814,10 +799,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         logger.log("Bootstrapping cross-signing");
 
         const delegateCryptoCallbacks = this.baseApis.cryptoCallbacks;
-        const builder = new EncryptionSetupBuilder(
-            this.baseApis.store.accountData,
-            delegateCryptoCallbacks,
-        );
+        const builder = new EncryptionSetupBuilder(this.baseApis.store.accountData, delegateCryptoCallbacks);
         const crossSigningInfo = new CrossSigningInfo(
             this.userId,
             builder.crossSigningCallbacks,
@@ -841,22 +823,15 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
             // Sign message key backup with cross-signing master key
             if (this.backupManager.backupInfo) {
-                await crossSigningInfo.signObject(
-                    this.backupManager.backupInfo.auth_data, "master",
-                );
+                await crossSigningInfo.signObject(this.backupManager.backupInfo.auth_data, "master");
                 builder.addSessionBackup(this.backupManager.backupInfo);
             }
         };
 
         const publicKeysOnDevice = this.crossSigningInfo.getId();
         const privateKeysInCache = await this.crossSigningInfo.isStoredInKeyCache();
-        const privateKeysInStorage = await this.crossSigningInfo.isStoredInSecretStorage(
-            this.secretStorage,
-        );
-        const privateKeysExistSomewhere = (
-            privateKeysInCache ||
-            privateKeysInStorage
-        );
+        const privateKeysInStorage = await this.crossSigningInfo.isStoredInSecretStorage(this.secretStorage);
+        const privateKeysExistSomewhere = privateKeysInCache || privateKeysInStorage;
 
         // Log all relevant state for easier parsing of debug logs.
         logger.log({
@@ -868,10 +843,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         });
 
         if (!privateKeysExistSomewhere || setupNewCrossSigning) {
-            logger.log(
-                "Cross-signing private keys not found locally or in secret storage, " +
-                "creating new keys",
-            );
+            logger.log("Cross-signing private keys not found locally or in secret storage, " + "creating new keys");
             // If a user has multiple devices, it important to only call bootstrap
             // as part of some UI flow (and not silently during startup), as they
             // may have setup cross-signing on a platform which has not saved keys
@@ -880,13 +852,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             // request private keys from those devices) before calling bootstrap.
             await resetCrossSigning();
         } else if (publicKeysOnDevice && privateKeysInCache) {
-            logger.log(
-                "Cross-signing public keys trusted and private keys found locally",
-            );
+            logger.log("Cross-signing public keys trusted and private keys found locally");
         } else if (privateKeysInStorage) {
             logger.log(
                 "Cross-signing private keys not found locally, but they are available " +
-                "in secret storage, reading storage and caching locally",
+                    "in secret storage, reading storage and caching locally",
             );
             await this.checkOwnCrossSigningTrust({
                 allowPrivateKeyRequests: true,
@@ -897,10 +867,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         // secret storage if it exists. If it does not, it is assumed this will be
         // done as part of setting up secret storage later.
         const crossSigningPrivateKeys = builder.crossSigningCallbacks.privateKeys;
-        if (
-            crossSigningPrivateKeys.size &&
-            !this.baseApis.cryptoCallbacks.saveCrossSigningKeys
-        ) {
+        if (crossSigningPrivateKeys.size && !this.baseApis.cryptoCallbacks.saveCrossSigningKeys) {
             const secretStorage = new SecretStorage(
                 builder.accountDataClientAdapter,
                 builder.ssssCryptoCallbacks,
@@ -910,10 +877,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                 logger.log("Storing new cross-signing private keys in secret storage");
                 // This is writing to in-memory account data in
                 // builder.accountDataClientAdapter so won't fail
-                await CrossSigningInfo.storeInSecretStorage(
-                    crossSigningPrivateKeys,
-                    secretStorage,
-                );
+                await CrossSigningInfo.storeInSecretStorage(crossSigningPrivateKeys, secretStorage);
             }
         }
 
@@ -969,10 +933,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     }: ICreateSecretStorageOpts = {}): Promise<void> {
         logger.log("Bootstrapping Secure Secret Storage");
         const delegateCryptoCallbacks = this.baseApis.cryptoCallbacks;
-        const builder = new EncryptionSetupBuilder(
-            this.baseApis.store.accountData,
-            delegateCryptoCallbacks,
-        );
+        const builder = new EncryptionSetupBuilder(this.baseApis.store.accountData, delegateCryptoCallbacks);
         const secretStorage = new SecretStorage(
             builder.accountDataClientAdapter,
             builder.ssssCryptoCallbacks,
@@ -1002,7 +963,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const ensureCanCheckPassphrase = async (keyId: string, keyInfo: ISecretStorageKeyInfo): Promise<void> => {
             if (!keyInfo.mac) {
                 const key = await this.baseApis.cryptoCallbacks.getSecretStorageKey?.(
-                    { keys: { [keyId]: keyInfo } }, "",
+                    { keys: { [keyId]: keyInfo } },
+                    "",
                 );
                 if (key) {
                     const privateKey = key[1];
@@ -1011,18 +973,13 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                     keyInfo.iv = iv;
                     keyInfo.mac = mac;
 
-                    await builder.setAccountData(
-                        `m.secret_storage.key.${keyId}`, keyInfo,
-                    );
+                    await builder.setAccountData(`m.secret_storage.key.${keyId}`, keyInfo);
                 }
             }
         };
 
         const signKeyBackupWithCrossSigning = async (keyBackupAuthData: IKeyBackupInfo["auth_data"]): Promise<void> => {
-            if (
-                this.crossSigningInfo.getId() &&
-                await this.crossSigningInfo.isStoredInKeyCache("master")
-            ) {
+            if (this.crossSigningInfo.getId() && (await this.crossSigningInfo.isStoredInKeyCache("master"))) {
                 try {
                     logger.log("Adding cross-signing signature to key backup");
                     await this.crossSigningInfo.signObject(keyBackupAuthData, "master");
@@ -1032,19 +989,14 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                     logger.error("Signing key backup with cross-signing keys failed", e);
                 }
             } else {
-                logger.warn(
-                    "Cross-signing keys not available, skipping signature on key backup",
-                );
+                logger.warn("Cross-signing keys not available, skipping signature on key backup");
             }
         };
 
         const oldSSSSKey = await this.getSecretStorageKey();
         const [oldKeyId, oldKeyInfo] = oldSSSSKey || [null, null];
-        const storageExists = (
-            !setupNewSecretStorage &&
-            oldKeyInfo &&
-            oldKeyInfo.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES
-        );
+        const storageExists =
+            !setupNewSecretStorage && oldKeyInfo && oldKeyInfo.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES;
 
         // Log all relevant state for easier parsing of debug logs.
         logger.log({
@@ -1058,9 +1010,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         if (!storageExists && !keyBackupInfo) {
             // either we don't have anything, or we've been asked to restart
             // from scratch
-            logger.log(
-                "Secret storage does not exist, creating new storage key",
-            );
+            logger.log("Secret storage does not exist, creating new storage key");
 
             // if we already have a usable default SSSS key and aren't resetting
             // SSSS just use it. otherwise, create a new one
@@ -1076,15 +1026,12 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
             // if we have the backup key already cached, use it; otherwise use the
             // callback to prompt for the key
-            const backupKey = await this.getSessionBackupPrivateKey() || await getKeyBackupPassphrase?.();
+            const backupKey = (await this.getSessionBackupPrivateKey()) || (await getKeyBackupPassphrase?.());
 
             // create a new SSSS key and use the backup key as the new SSSS key
             const opts = {} as IAddSecretStorageKeyOpts;
 
-            if (
-                keyBackupInfo.auth_data.private_key_salt &&
-                keyBackupInfo.auth_data.private_key_iterations
-            ) {
+            if (keyBackupInfo.auth_data.private_key_salt && keyBackupInfo.auth_data.private_key_iterations) {
                 // FIXME: ???
                 opts.passphrase = {
                     algorithm: "m.pbkdf2",
@@ -1120,12 +1067,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         // storage if they are not there already.
         if (
             !this.baseApis.cryptoCallbacks.saveCrossSigningKeys &&
-            await this.isCrossSigningReady() &&
-            (newKeyId || !await this.crossSigningInfo.isStoredInSecretStorage(secretStorage))
+            (await this.isCrossSigningReady()) &&
+            (newKeyId || !(await this.crossSigningInfo.isStoredInSecretStorage(secretStorage)))
         ) {
             logger.log("Copying cross-signing private keys from cache to secret storage");
-            const crossSigningPrivateKeys =
-                await this.crossSigningInfo.getCrossSigningKeysFromCache();
+            const crossSigningPrivateKeys = await this.crossSigningInfo.getCrossSigningKeysFromCache();
             // This is writing to in-memory account data in
             // builder.accountDataClientAdapter so won't fail
             await CrossSigningInfo.storeInSecretStorage(crossSigningPrivateKeys, secretStorage);
@@ -1160,7 +1106,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         }
 
         // Cache the session backup key
-        const sessionBackupKey = await secretStorage.get('m.megolm_backup.v1');
+        const sessionBackupKey = await secretStorage.get("m.megolm_backup.v1");
         if (sessionBackupKey) {
             logger.info("Got session backup key from secret storage: caching");
             // fix up the backup key if it's in the wrong format, and replace
@@ -1168,18 +1114,14 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             const fixedBackupKey = fixBackupKey(sessionBackupKey);
             if (fixedBackupKey) {
                 const keyId = newKeyId || oldKeyId;
-                await secretStorage.store("m.megolm_backup.v1",
-                    fixedBackupKey, keyId ? [keyId] : null,
-                );
+                await secretStorage.store("m.megolm_backup.v1", fixedBackupKey, keyId ? [keyId] : null);
             }
-            const decodedBackupKey = new Uint8Array(olmlib.decodeBase64(
-                fixedBackupKey || sessionBackupKey,
-            ));
+            const decodedBackupKey = new Uint8Array(olmlib.decodeBase64(fixedBackupKey || sessionBackupKey));
             builder.addSessionBackupPrivateKeyToCache(decodedBackupKey);
         } else if (this.backupManager.getKeyBackupEnabled()) {
             // key backup is enabled but we don't have a session backup key in SSSS: see if we have one in
             // the cache or the user can provide one, and if so, write it to SSSS
-            const backupKey = await this.getSessionBackupPrivateKey() || await getKeyBackupPassphrase?.();
+            const backupKey = (await this.getSessionBackupPrivateKey()) || (await getKeyBackupPassphrase?.());
             if (!backupKey) {
                 // This will require user intervention to recover from since we don't have the key
                 // backup key anywhere. The user should probably just set up a new key backup and
@@ -1274,18 +1216,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @returns the key, if any, or null
      */
     public async getSessionBackupPrivateKey(): Promise<Uint8Array | null> {
-        let key = await new Promise<any>((resolve) => { // TODO types
-            this.cryptoStore.doTxn(
-                'readonly',
-                [IndexedDBCryptoStore.STORE_ACCOUNT],
-                (txn) => {
-                    this.cryptoStore.getSecretStorePrivateKey(
-                        txn,
-                        resolve,
-                        "m.megolm_backup.v1",
-                    );
-                },
-            );
+        let key = await new Promise<any>((resolve) => {
+            // TODO types
+            this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+                this.cryptoStore.getSecretStorePrivateKey(txn, resolve, "m.megolm_backup.v1");
+            });
         });
 
         // make sure we have a Uint8Array, rather than a string
@@ -1312,13 +1247,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         }
         const pickleKey = Buffer.from(this.olmDevice.pickleKey);
         const encryptedKey = await encryptAES(olmlib.encodeBase64(key), pickleKey, "m.megolm_backup.v1");
-        return this.cryptoStore.doTxn(
-            'readwrite',
-            [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.cryptoStore.storeSecretStorePrivateKey(txn, "m.megolm_backup.v1", encryptedKey);
-            },
-        );
+        return this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.cryptoStore.storeSecretStorePrivateKey(txn, "m.megolm_backup.v1", encryptedKey);
+        });
     }
 
     /**
@@ -1357,46 +1288,44 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         logger.info(`Starting background key sig upload for ${this.deviceId}`);
 
         const upload = ({ shouldEmit = false }): Promise<void> => {
-            return this.baseApis.uploadKeySignatures({
-                [this.userId]: {
-                    [this.deviceId]: signedDevice!,
-                },
-            }).then((response) => {
-                const { failures } = response || {};
-                if (Object.keys(failures || []).length > 0) {
-                    if (shouldEmit) {
-                        this.baseApis.emit(
-                            CryptoEvent.KeySignatureUploadFailure,
-                            failures,
-                            "afterCrossSigningLocalKeyChange",
-                            upload, // continuation
-                        );
+            return this.baseApis
+                .uploadKeySignatures({
+                    [this.userId]: {
+                        [this.deviceId]: signedDevice!,
+                    },
+                })
+                .then((response) => {
+                    const { failures } = response || {};
+                    if (Object.keys(failures || []).length > 0) {
+                        if (shouldEmit) {
+                            this.baseApis.emit(
+                                CryptoEvent.KeySignatureUploadFailure,
+                                failures,
+                                "afterCrossSigningLocalKeyChange",
+                                upload, // continuation
+                            );
+                        }
+                        throw new KeySignatureUploadError("Key upload failed", { failures });
                     }
-                    throw new KeySignatureUploadError("Key upload failed", { failures });
-                }
-                logger.info(`Finished background key sig upload for ${this.deviceId}`);
-            }).catch(e => {
-                logger.error(
-                    `Error during background key sig upload for ${this.deviceId}`,
-                    e,
-                );
-            });
+                    logger.info(`Finished background key sig upload for ${this.deviceId}`);
+                })
+                .catch((e) => {
+                    logger.error(`Error during background key sig upload for ${this.deviceId}`, e);
+                });
         };
         upload({ shouldEmit: true });
 
-        const shouldUpgradeCb = (
-            this.baseApis.cryptoCallbacks.shouldUpgradeDeviceVerifications
-        );
+        const shouldUpgradeCb = this.baseApis.cryptoCallbacks.shouldUpgradeDeviceVerifications;
         if (shouldUpgradeCb) {
             logger.info("Starting device verification upgrade");
 
             // Check all users for signatures if upgrade callback present
             // FIXME: do this in batches
             const users: Record<string, IDeviceVerificationUpgrade> = {};
-            for (const [userId, crossSigningInfo]
-                of Object.entries(this.deviceList.crossSigningInfo)) {
+            for (const [userId, crossSigningInfo] of Object.entries(this.deviceList.crossSigningInfo)) {
                 const upgradeInfo = await this.checkForDeviceVerificationUpgrade(
-                    userId, CrossSigningInfo.fromStorage(crossSigningInfo, userId),
+                    userId,
+                    CrossSigningInfo.fromStorage(crossSigningInfo, userId),
                 );
                 if (upgradeInfo) {
                     users[userId] = upgradeInfo;
@@ -1415,9 +1344,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                         }
                     }
                 } catch (e) {
-                    logger.log(
-                        "shouldUpgradeDeviceVerifications threw an error: not upgrading", e,
-                    );
+                    logger.log("shouldUpgradeDeviceVerifications threw an error: not upgrading", e);
                 }
             }
 
@@ -1443,14 +1370,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const trustLevel = this.crossSigningInfo.checkUserTrust(crossSigningInfo);
         if (crossSigningInfo.firstUse && !trustLevel.isVerified()) {
             const devices = this.deviceList.getRawStoredDevicesForUser(userId);
-            const deviceIds = await this.checkForValidDeviceSignature(
-                userId, crossSigningInfo.keys.master, devices,
-            );
+            const deviceIds = await this.checkForValidDeviceSignature(userId, crossSigningInfo.keys.master, devices);
             if (deviceIds.length) {
                 return {
-                    devices: deviceIds.map(
-                        deviceId => DeviceInfo.fromStorage(devices[deviceId], deviceId),
-                    ),
+                    devices: deviceIds.map((deviceId) => DeviceInfo.fromStorage(devices[deviceId], deviceId)),
                     crossSigningInfo,
                 };
             }
@@ -1473,9 +1396,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const deviceIds: string[] = [];
         if (devices && key.signatures && key.signatures[userId]) {
             for (const signame of Object.keys(key.signatures[userId])) {
-                const [, deviceId] = signame.split(':', 2);
-                if (deviceId in devices
-                    && devices[deviceId].verified === DeviceVerification.VERIFIED) {
+                const [, deviceId] = signame.split(":", 2);
+                if (deviceId in devices && devices[deviceId].verified === DeviceVerification.VERIFIED) {
                     try {
                         await olmlib.verifySignature(
                             this.olmDevice,
@@ -1559,9 +1481,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             // The trustCrossSignedDevices only affects trust of other people's cross-signing
             // signatures
             const trustCrossSig = this.trustCrossSignedDevices || userId === this.userId;
-            return this.crossSigningInfo.checkDeviceTrust(
-                userCrossSigning, device, trustedLocally, trustCrossSig,
-            );
+            return this.crossSigningInfo.checkDeviceTrust(userCrossSigning, device, trustedLocally, trustCrossSig);
         } else {
             return new DeviceTrustLevel(false, false, trustedLocally, false);
         }
@@ -1579,12 +1499,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const device = this.deviceList.getStoredDevice(this.userId, deviceId);
         if (!device) return false;
         const userCrossSigning = this.deviceList.getStoredCrossSigningForUser(this.userId);
-        return userCrossSigning?.checkDeviceTrust(
-            userCrossSigning,
-            device,
-            false,
-            true,
-        ).isCrossSigningVerified() ?? false;
+        return (
+            userCrossSigning?.checkDeviceTrust(userCrossSigning, device, false, true).isCrossSigningVerified() ?? false
+        );
     }
 
     /*
@@ -1622,9 +1539,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             // latch value in the device list store.
             const crossSigning = this.deviceList.getStoredCrossSigningForUser(userId);
             if (crossSigning) {
-                crossSigning.updateCrossSigningVerifiedBefore(
-                    this.checkUserTrust(userId).isCrossSigningVerified(),
-                );
+                crossSigning.updateCrossSigningVerifiedBefore(this.checkUserTrust(userId).isCrossSigningVerified());
                 this.deviceList.setRawStoredCrossSigningForUser(userId, crossSigning.toStorage());
             }
 
@@ -1646,8 +1561,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         await this.downloadKeys([this.userId]);
 
         // Also check which private keys are locally cached.
-        const crossSigningPrivateKeys =
-            await this.crossSigningInfo.getCrossSigningKeysFromCache();
+        const crossSigningPrivateKeys = await this.crossSigningInfo.getCrossSigningKeysFromCache();
 
         // If we see an update to our own master key, check it against the master
         // key we have and, if it matches, mark it as verified
@@ -1656,30 +1570,25 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const newCrossSigning = this.deviceList.getStoredCrossSigningForUser(userId);
         if (!newCrossSigning) {
             logger.error(
-                "Got cross-signing update event for user " + userId +
-                " but no new cross-signing information found!",
+                "Got cross-signing update event for user " + userId + " but no new cross-signing information found!",
             );
             return;
         }
 
         const seenPubkey = newCrossSigning.getId()!;
         const masterChanged = this.crossSigningInfo.getId() !== seenPubkey;
-        const masterExistsNotLocallyCached =
-            newCrossSigning.getId() && !crossSigningPrivateKeys.has("master");
+        const masterExistsNotLocallyCached = newCrossSigning.getId() && !crossSigningPrivateKeys.has("master");
         if (masterChanged) {
             logger.info("Got new master public key", seenPubkey);
         }
-        if (
-            allowPrivateKeyRequests &&
-            (masterChanged || masterExistsNotLocallyCached)
-        ) {
+        if (allowPrivateKeyRequests && (masterChanged || masterExistsNotLocallyCached)) {
             logger.info("Attempting to retrieve cross-signing master private key");
             let signing: PkSigning | null = null;
             // It's important for control flow that we leave any errors alone for
             // higher levels to handle so that e.g. cancelling access properly
             // aborts any larger operation as well.
             try {
-                const ret = await this.crossSigningInfo.getCrossSigningKey('master', seenPubkey);
+                const ret = await this.crossSigningInfo.getCrossSigningKey("master", seenPubkey);
                 signing = ret[1];
                 logger.info("Got cross-signing master private key");
             } finally {
@@ -1696,29 +1605,23 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const selfSigningChanged = oldSelfSigningId !== newCrossSigning.getId("self_signing");
         const userSigningChanged = oldUserSigningId !== newCrossSigning.getId("user_signing");
 
-        const selfSigningExistsNotLocallyCached = (
-            newCrossSigning.getId("self_signing") &&
-            !crossSigningPrivateKeys.has("self_signing")
-        );
-        const userSigningExistsNotLocallyCached = (
-            newCrossSigning.getId("user_signing") &&
-            !crossSigningPrivateKeys.has("user_signing")
-        );
+        const selfSigningExistsNotLocallyCached =
+            newCrossSigning.getId("self_signing") && !crossSigningPrivateKeys.has("self_signing");
+        const userSigningExistsNotLocallyCached =
+            newCrossSigning.getId("user_signing") && !crossSigningPrivateKeys.has("user_signing");
 
         const keySignatures: Record<string, ISignedKey> = {};
 
         if (selfSigningChanged) {
             logger.info("Got new self-signing key", newCrossSigning.getId("self_signing"));
         }
-        if (
-            allowPrivateKeyRequests &&
-            (selfSigningChanged || selfSigningExistsNotLocallyCached)
-        ) {
+        if (allowPrivateKeyRequests && (selfSigningChanged || selfSigningExistsNotLocallyCached)) {
             logger.info("Attempting to retrieve cross-signing self-signing private key");
             let signing: PkSigning | null = null;
             try {
                 const ret = await this.crossSigningInfo.getCrossSigningKey(
-                    "self_signing", newCrossSigning.getId("self_signing")!,
+                    "self_signing",
+                    newCrossSigning.getId("self_signing")!,
                 );
                 signing = ret[1];
                 logger.info("Got cross-signing self-signing private key");
@@ -1733,15 +1636,13 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         if (userSigningChanged) {
             logger.info("Got new user-signing key", newCrossSigning.getId("user_signing"));
         }
-        if (
-            allowPrivateKeyRequests &&
-            (userSigningChanged || userSigningExistsNotLocallyCached)
-        ) {
+        if (allowPrivateKeyRequests && (userSigningChanged || userSigningExistsNotLocallyCached)) {
             logger.info("Attempting to retrieve cross-signing user-signing private key");
             let signing: PkSigning | null = null;
             try {
                 const ret = await this.crossSigningInfo.getCrossSigningKey(
-                    "user_signing", newCrossSigning.getId("user_signing")!,
+                    "user_signing",
+                    newCrossSigning.getId("user_signing")!,
                 );
                 signing = ret[1];
                 logger.info("Got cross-signing user-signing private key");
@@ -1757,24 +1658,21 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             // Include only the _new_ device signature in the upload.
             // We may have existing signatures from deleted devices, which will cause
             // the entire upload to fail.
-            keySignatures[this.crossSigningInfo.getId()!] = Object.assign(
-                {} as ISignedKey,
-                masterKey,
-                {
-                    signatures: {
-                        [this.userId]: {
-                            ["ed25519:" + this.deviceId]: deviceSig,
-                        },
+            keySignatures[this.crossSigningInfo.getId()!] = Object.assign({} as ISignedKey, masterKey, {
+                signatures: {
+                    [this.userId]: {
+                        ["ed25519:" + this.deviceId]: deviceSig,
                     },
                 },
-            );
+            });
         }
 
         const keysToUpload = Object.keys(keySignatures);
         if (keysToUpload.length) {
             const upload = ({ shouldEmit = false }): Promise<void> => {
                 logger.info(`Starting background key sig upload for ${keysToUpload}`);
-                return this.baseApis.uploadKeySignatures({ [this.userId]: keySignatures })
+                return this.baseApis
+                    .uploadKeySignatures({ [this.userId]: keySignatures })
                     .then((response) => {
                         const { failures } = response || {};
                         logger.info(`Finished background key sig upload for ${keysToUpload}`);
@@ -1789,11 +1687,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                             }
                             throw new KeySignatureUploadError("Key upload failed", { failures });
                         }
-                    }).catch(e => {
-                        logger.error(
-                            `Error during background key sig upload for ${keysToUpload}`,
-                            e,
-                        );
+                    })
+                    .catch((e) => {
+                        logger.error(`Error during background key sig upload for ${keysToUpload}`, e);
                     });
             };
             upload({ shouldEmit: true });
@@ -1823,12 +1719,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         } else {
             this.crossSigningInfo.clearKeys();
         }
-        await this.cryptoStore.doTxn(
-            'readwrite', [IndexedDBCryptoStore.STORE_ACCOUNT],
-            (txn) => {
-                this.cryptoStore.storeCrossSigningKeys(txn, this.crossSigningInfo.keys);
-            },
-        );
+        await this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ACCOUNT], (txn) => {
+            this.cryptoStore.storeCrossSigningKeys(txn, this.crossSigningInfo.keys);
+        });
     }
 
     /**
@@ -1838,9 +1731,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @param userId - the user ID whose key should be checked
      */
     private async checkDeviceVerifications(userId: string): Promise<void> {
-        const shouldUpgradeCb = (
-            this.baseApis.cryptoCallbacks.shouldUpgradeDeviceVerifications
-        );
+        const shouldUpgradeCb = this.baseApis.cryptoCallbacks.shouldUpgradeDeviceVerifications;
         if (!shouldUpgradeCb) {
             // Upgrading skipped when callback is not present.
             return;
@@ -1849,9 +1740,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         if (this.crossSigningInfo.keys.user_signing) {
             const crossSigningInfo = this.deviceList.getStoredCrossSigningForUser(userId);
             if (crossSigningInfo) {
-                const upgradeInfo = await this.checkForDeviceVerificationUpgrade(
-                    userId, crossSigningInfo,
-                );
+                const upgradeInfo = await this.checkForDeviceVerificationUpgrade(userId, crossSigningInfo);
                 if (upgradeInfo) {
                     const usersToUpgrade = await shouldUpgradeCb({
                         users: {
@@ -1880,10 +1769,12 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @param eventEmitter - event source where we can register
      *    for event notifications
      */
-    public registerEventHandlers(eventEmitter: TypedEventEmitter<
-        RoomMemberEvent.Membership | ClientEvent.ToDeviceEvent | RoomEvent.Timeline | MatrixEventEvent.Decrypted,
-        any
-    >): void {
+    public registerEventHandlers(
+        eventEmitter: TypedEventEmitter<
+            RoomMemberEvent.Membership | ClientEvent.ToDeviceEvent | RoomEvent.Timeline | MatrixEventEvent.Decrypted,
+            any
+        >,
+    ): void {
         eventEmitter.on(RoomMemberEvent.Membership, this.onMembership);
         eventEmitter.on(ClientEvent.ToDeviceEvent, this.onToDeviceEvent);
         eventEmitter.on(RoomEvent.Timeline, this.onTimelineEvent);
@@ -2003,9 +1894,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         }
 
         const now = Date.now();
-        if (this.lastOneTimeKeyCheck !== null &&
-            now - this.lastOneTimeKeyCheck < uploadPeriod
-        ) {
+        if (this.lastOneTimeKeyCheck !== null && now - this.lastOneTimeKeyCheck < uploadPeriod) {
             // we've done a key upload recently.
             return;
         }
@@ -2048,8 +1937,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                     // if fallbackKeys is non-empty, we've already generated a
                     // fallback key, but it hasn't been published yet, so we
                     // can use that instead of generating a new one
-                    if (!fallbackKeys.curve25519 ||
-                        Object.keys(fallbackKeys.curve25519).length == 0) {
+                    if (!fallbackKeys.curve25519 || Object.keys(fallbackKeys.curve25519).length == 0) {
                         logger.info("generating fallback key");
                         if (this.fallbackCleanup) {
                             // cancel any pending fallback cleanup because generating
@@ -2070,37 +1958,42 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                     // for the next loop
                     keyCount = res.one_time_key_counts.signed_curve25519;
                 } else {
-                    throw new Error("response for uploading keys does not contain " +
-                        "one_time_key_counts.signed_curve25519");
+                    throw new Error(
+                        "response for uploading keys does not contain " + "one_time_key_counts.signed_curve25519",
+                    );
                 }
             }
         };
 
         this.oneTimeKeyCheckInProgress = true;
-        Promise.resolve().then(() => {
-            if (this.oneTimeKeyCount !== undefined) {
-                // We already have the current one_time_key count from a /sync response.
-                // Use this value instead of asking the server for the current key count.
-                return Promise.resolve(this.oneTimeKeyCount);
-            }
-            // ask the server how many keys we have
-            return this.baseApis.uploadKeysRequest({}).then((res) => {
-                return res.one_time_key_counts.signed_curve25519 || 0;
+        Promise.resolve()
+            .then(() => {
+                if (this.oneTimeKeyCount !== undefined) {
+                    // We already have the current one_time_key count from a /sync response.
+                    // Use this value instead of asking the server for the current key count.
+                    return Promise.resolve(this.oneTimeKeyCount);
+                }
+                // ask the server how many keys we have
+                return this.baseApis.uploadKeysRequest({}).then((res) => {
+                    return res.one_time_key_counts.signed_curve25519 || 0;
+                });
+            })
+            .then((keyCount) => {
+                // Start the uploadLoop with the current keyCount. The function checks if
+                // we need to upload new keys or not.
+                // If there are too many keys on the server then we don't need to
+                // create any more keys.
+                return uploadLoop(keyCount);
+            })
+            .catch((e) => {
+                logger.error("Error uploading one-time keys", e.stack || e);
+            })
+            .finally(() => {
+                // reset oneTimeKeyCount to prevent start uploading based on old data.
+                // it will be set again on the next /sync-response
+                this.oneTimeKeyCount = undefined;
+                this.oneTimeKeyCheckInProgress = false;
             });
-        }).then((keyCount) => {
-            // Start the uploadLoop with the current keyCount. The function checks if
-            // we need to upload new keys or not.
-            // If there are too many keys on the server then we don't need to
-            // create any more keys.
-            return uploadLoop(keyCount);
-        }).catch((e) => {
-            logger.error("Error uploading one-time keys", e.stack || e);
-        }).finally(() => {
-            // reset oneTimeKeyCount to prevent start uploading based on old data.
-            // it will be set again on the next /sync-response
-            this.oneTimeKeyCount = undefined;
-            this.oneTimeKeyCheckInProgress = false;
-        });
     }
 
     // returns a promise which resolves to the response
@@ -2135,7 +2028,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         await Promise.all(promises);
 
         const requestBody: Record<string, any> = {
-            "one_time_keys": oneTimeJson,
+            one_time_keys: oneTimeJson,
         };
 
         if (fallbackJson) {
@@ -2149,7 +2042,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             this.fallbackCleanup = setTimeout(() => {
                 delete this.fallbackCleanup;
                 this.olmDevice.forgetOldFallbackKey();
-            }, 60*60*1000);
+            }, 60 * 60 * 1000);
         }
 
         await this.olmDevice.markKeysAsPublished();
@@ -2261,10 +2154,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
             // Now sign the master key with our user signing key (unless it's ourself)
             if (userId !== this.userId) {
-                logger.info(
-                    "Master key " + xsk.getId() + " for " + userId +
-                    " marked verified. Signing...",
-                );
+                logger.info("Master key " + xsk.getId() + " for " + userId + " marked verified. Signing...");
                 const device = await this.crossSigningInfo.signUser(xsk);
                 if (device) {
                     const upload = async ({ shouldEmit = false }): Promise<void> => {
@@ -2285,11 +2175,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                                 );
                             }
                             /* Throwing here causes the process to be cancelled and the other
-                            * user to be notified */
-                            throw new KeySignatureUploadError(
-                                "Key upload failed",
-                                { failures },
-                            );
+                             * user to be notified */
+                            throw new KeySignatureUploadError("Key upload failed", { failures });
                         }
                     };
                     await upload({ shouldEmit: true });
@@ -2352,9 +2239,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             if (deviceTrust.isCrossSigningVerified()) {
                 logger.log(`Own device ${deviceId} already cross-signing verified`);
             } else {
-                device = (await this.crossSigningInfo.signDevice(
-                    userId, DeviceInfo.fromStorage(dev, deviceId),
-                ))!;
+                device = (await this.crossSigningInfo.signDevice(userId, DeviceInfo.fromStorage(dev, deviceId)))!;
             }
 
             if (device) {
@@ -2436,8 +2321,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         if (racingRequest) {
             request = racingRequest;
         } else {
-            logger.log(`Crypto: adding new request to ` +
-                `requestsByTxnId with id ${channel.transactionId} ${channel.roomId}`);
+            logger.log(
+                `Crypto: adding new request to ` + `requestsByTxnId with id ${channel.transactionId} ${channel.roomId}`,
+            );
             requestsMap.setRequestByChannel(channel, request);
         }
         return request;
@@ -2453,9 +2339,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         if (transactionId) {
             request = this.toDeviceVerificationRequests.getRequestBySenderAndTxnId(userId, transactionId);
             if (!request) {
-                throw new Error(
-                    `No request found for user ${userId} with ` +
-                    `transactionId ${transactionId}`);
+                throw new Error(`No request found for user ${userId} with ` + `transactionId ${transactionId}`);
             }
         } else {
             transactionId = ToDeviceChannel.makeTransactionId();
@@ -2479,10 +2363,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         // either reject by an error from verify() while sending .start
         // or resolve when the request receives the
         // local (fake remote) echo for sending the .start event
-        await Promise.race([
-            verifier.verify(),
-            request.waitFor(r => r.started),
-        ]);
+        await Promise.race([verifier.verify(), request.waitFor((r) => r.started)]);
         return request;
     }
 
@@ -2535,9 +2416,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         // was sent from. In the case of Megolm, it's actually the Curve25519
         // identity key of the device which set up the Megolm session.
 
-        const device = this.deviceList.getDeviceByIdentityKey(
-            algorithm, senderKey,
-        );
+        const device = this.deviceList.getDeviceByIdentityKey(algorithm, senderKey);
 
         if (device === null) {
             // we haven't downloaded the details of this device yet.
@@ -2554,15 +2433,19 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
         const claimedKey = event.getClaimedEd25519Key();
         if (!claimedKey) {
-            logger.warn("Event " + event.getId() + " claims no ed25519 key: " +
-                "cannot verify sending device");
+            logger.warn("Event " + event.getId() + " claims no ed25519 key: " + "cannot verify sending device");
             return null;
         }
 
         if (claimedKey !== device.getFingerprint()) {
             logger.warn(
-                "Event " + event.getId() + " claims ed25519 key " + claimedKey +
-                " but sender device has key " + device.getFingerprint());
+                "Event " +
+                    event.getId() +
+                    " claims ed25519 key " +
+                    claimedKey +
+                    " but sender device has key " +
+                    device.getFingerprint(),
+            );
             return null;
         }
 
@@ -2621,15 +2504,19 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
         const claimedKey = event.getClaimedEd25519Key();
         if (!claimedKey) {
-            logger.warn("Event " + event.getId() + " claims no ed25519 key: " +
-                "cannot verify sending device");
+            logger.warn("Event " + event.getId() + " claims no ed25519 key: " + "cannot verify sending device");
             ret.mismatchedSender = true;
         }
 
         if (ret.sender && claimedKey !== ret.sender.getFingerprint()) {
             logger.warn(
-                "Event " + event.getId() + " claims ed25519 key " + claimedKey +
-                "but sender device has key " + ret.sender.getFingerprint());
+                "Event " +
+                    event.getId() +
+                    " claims ed25519 key " +
+                    claimedKey +
+                    "but sender device has key " +
+                    ret.sender.getFingerprint(),
+            );
             ret.mismatchedSender = true;
         }
 
@@ -2696,10 +2583,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @param room - The room to enable encryption in.
      * @param config - The encryption config for the room.
      */
-    private async setRoomEncryptionImpl(
-        room: Room,
-        config: IRoomEncryption,
-    ): Promise<void> {
+    private async setRoomEncryptionImpl(room: Room, config: IRoomEncryption): Promise<void> {
         const roomId = room.roomId;
 
         // ignore crypto events with no algorithm defined
@@ -2719,8 +2603,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const existingConfig = this.roomList.getRoomEncryption(roomId);
         if (existingConfig) {
             if (JSON.stringify(existingConfig) != JSON.stringify(config)) {
-                logger.error("Ignoring m.room.encryption event which requests " +
-                    "a change of config in " + roomId);
+                logger.error("Ignoring m.room.encryption event which requests " + "a change of config in " + roomId);
                 return;
             }
         }
@@ -2766,8 +2649,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         }
 
         if (!this.lazyLoadMembers) {
-            logger.log("Enabling encryption in " + roomId + "; " +
-                "starting to track device lists for all users therein");
+            logger.log(
+                "Enabling encryption in " + roomId + "; " + "starting to track device lists for all users therein",
+            );
 
             await this.trackRoomDevicesImpl(room);
         } else {
@@ -2816,7 +2700,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         let promise = this.roomDeviceTrackingState[roomId];
         if (!promise) {
             promise = trackMembers();
-            this.roomDeviceTrackingState[roomId] = promise.catch(err => {
+            this.roomDeviceTrackingState[roomId] = promise.catch((err) => {
                 delete this.roomDeviceTrackingState[roomId];
                 throw err;
             });
@@ -2870,18 +2754,16 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      */
     public async exportRoomKeys(): Promise<IMegolmSessionData[]> {
         const exportedSessions: IMegolmSessionData[] = [];
-        await this.cryptoStore.doTxn(
-            'readonly', [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS], (txn) => {
-                this.cryptoStore.getAllEndToEndInboundGroupSessions(txn, (s) => {
-                    if (s === null) return;
-
-                    const sess = this.olmDevice.exportInboundGroupSession(s.senderKey, s.sessionId, s.sessionData!);
-                    delete sess.first_known_index;
-                    sess.algorithm = olmlib.MEGOLM_ALGORITHM;
-                    exportedSessions.push(sess);
-                });
-            },
-        );
+        await this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS], (txn) => {
+            this.cryptoStore.getAllEndToEndInboundGroupSessions(txn, (s) => {
+                if (s === null) return;
+
+                const sess = this.olmDevice.exportInboundGroupSession(s.senderKey, s.sessionId, s.sessionData!);
+                delete sess.first_known_index;
+                sess.algorithm = olmlib.MEGOLM_ALGORITHM;
+                exportedSessions.push(sess);
+            });
+        });
 
         return exportedSessions;
     }
@@ -2906,20 +2788,26 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             });
         }
 
-        return Promise.all(keys.map((key) => {
-            if (!key.room_id || !key.algorithm) {
-                logger.warn("ignoring room key entry with missing fields", key);
-                failures++;
-                if (opts.progressCallback) { updateProgress(); }
-                return null;
-            }
+        return Promise.all(
+            keys.map((key) => {
+                if (!key.room_id || !key.algorithm) {
+                    logger.warn("ignoring room key entry with missing fields", key);
+                    failures++;
+                    if (opts.progressCallback) {
+                        updateProgress();
+                    }
+                    return null;
+                }
 
-            const alg = this.getRoomDecryptor(key.room_id, key.algorithm);
-            return alg.importRoomKey(key, opts).finally(() => {
-                successes++;
-                if (opts.progressCallback) { updateProgress(); }
-            });
-        })).then();
+                const alg = this.getRoomDecryptor(key.room_id, key.algorithm);
+                return alg.importRoomKey(key, opts).finally(() => {
+                    successes++;
+                    if (opts.progressCallback) {
+                        updateProgress();
+                    }
+                });
+            }),
+        ).then();
     }
 
     /**
@@ -2965,9 +2853,11 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             // MatrixClient has already checked that this room should be encrypted,
             // so this is an unexpected situation.
             throw new Error(
-                "Room " + roomId + " was previously configured to use encryption, but is " +
-                "no longer. Perhaps the homeserver is hiding the " +
-                "configuration event.",
+                "Room " +
+                    roomId +
+                    " was previously configured to use encryption, but is " +
+                    "no longer. Perhaps the homeserver is hiding the " +
+                    "configuration event.",
             );
         }
 
@@ -2977,27 +2867,27 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         let content = event.getContent();
         // If event has an m.relates_to then we need
         // to put this on the wrapping event instead
-        const mRelatesTo = content['m.relates_to'];
+        const mRelatesTo = content["m.relates_to"];
         if (mRelatesTo) {
             // Clone content here so we don't remove `m.relates_to` from the local-echo
             content = Object.assign({}, content);
-            delete content['m.relates_to'];
+            delete content["m.relates_to"];
         }
 
         // Treat element's performance metrics the same as `m.relates_to` (when present)
-        const elementPerfMetrics = content['io.element.performance_metrics'];
+        const elementPerfMetrics = content["io.element.performance_metrics"];
         if (elementPerfMetrics) {
             content = Object.assign({}, content);
-            delete content['io.element.performance_metrics'];
+            delete content["io.element.performance_metrics"];
         }
 
-        const encryptedContent = await alg.encryptMessage(room, event.getType(), content) as IContent;
+        const encryptedContent = (await alg.encryptMessage(room, event.getType(), content)) as IContent;
 
         if (mRelatesTo) {
-            encryptedContent['m.relates_to'] = mRelatesTo;
+            encryptedContent["m.relates_to"] = mRelatesTo;
         }
         if (elementPerfMetrics) {
-            encryptedContent['io.element.performance_metrics'] = elementPerfMetrics;
+            encryptedContent["io.element.performance_metrics"] = elementPerfMetrics;
         }
 
         event.makeEncrypted(
@@ -3081,18 +2971,17 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         recipients: IRoomKeyRequestRecipient[],
         resend = false,
     ): Promise<void> {
-        return this.outgoingRoomKeyRequestManager.queueRoomKeyRequest(
-            requestBody, recipients, resend,
-        ).then(() => {
-            if (this.sendKeyRequestsImmediately) {
-                this.outgoingRoomKeyRequestManager.sendQueuedRequests();
-            }
-        }).catch((e) => {
-            // this normally means we couldn't talk to the store
-            logger.error(
-                'Error requesting key for event', e,
-            );
-        });
+        return this.outgoingRoomKeyRequestManager
+            .queueRoomKeyRequest(requestBody, recipients, resend)
+            .then(() => {
+                if (this.sendKeyRequestsImmediately) {
+                    this.outgoingRoomKeyRequestManager.sendQueuedRequests();
+                }
+            })
+            .catch((e) => {
+                // this normally means we couldn't talk to the store
+                logger.error("Error requesting key for event", e);
+            });
     }
 
     /**
@@ -3101,10 +2990,9 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      * @param requestBody - parameters to match for cancellation
      */
     public cancelRoomKeyRequest(requestBody: IRoomKeyRequestBody): void {
-        this.outgoingRoomKeyRequestManager.cancelRoomKeyRequest(requestBody)
-            .catch((e) => {
-                logger.warn("Error clearing pending room key requests", e);
-            });
+        this.outgoingRoomKeyRequestManager.cancelRoomKeyRequest(requestBody).catch((e) => {
+            logger.warn("Error clearing pending room key requests", e);
+        });
     }
 
     /**
@@ -3260,52 +3148,47 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
      *     userDeviceMap, and returns the `{ contentMap, deviceInfoByDeviceId }`
      *     of the successfully sent messages.
      */
-    public async encryptAndSendToDevices(
-        userDeviceInfoArr: IOlmDevice<DeviceInfo>[],
-        payload: object,
-    ): Promise<void> {
+    public async encryptAndSendToDevices(userDeviceInfoArr: IOlmDevice<DeviceInfo>[], payload: object): Promise<void> {
         const toDeviceBatch: ToDeviceBatch = {
             eventType: EventType.RoomMessageEncrypted,
             batch: [],
         };
 
         try {
-            await Promise.all(userDeviceInfoArr.map(async ({ userId, deviceInfo }) => {
-                const deviceId = deviceInfo.deviceId;
-                const encryptedContent: IEncryptedContent = {
-                    algorithm: olmlib.OLM_ALGORITHM,
-                    sender_key: this.olmDevice.deviceCurve25519Key!,
-                    ciphertext: {},
-                    [ToDeviceMessageId]: uuidv4(),
-                };
+            await Promise.all(
+                userDeviceInfoArr.map(async ({ userId, deviceInfo }) => {
+                    const deviceId = deviceInfo.deviceId;
+                    const encryptedContent: IEncryptedContent = {
+                        algorithm: olmlib.OLM_ALGORITHM,
+                        sender_key: this.olmDevice.deviceCurve25519Key!,
+                        ciphertext: {},
+                        [ToDeviceMessageId]: uuidv4(),
+                    };
 
-                toDeviceBatch.batch.push({
-                    userId,
-                    deviceId,
-                    payload: encryptedContent,
-                });
+                    toDeviceBatch.batch.push({
+                        userId,
+                        deviceId,
+                        payload: encryptedContent,
+                    });
 
-                await olmlib.ensureOlmSessionsForDevices(
-                    this.olmDevice,
-                    this.baseApis,
-                    { [userId]: [deviceInfo] },
-                );
-                await olmlib.encryptMessageForDevice(
-                    encryptedContent.ciphertext,
-                    this.userId,
-                    this.deviceId,
-                    this.olmDevice,
-                    userId,
-                    deviceInfo,
-                    payload,
-                );
-            }));
+                    await olmlib.ensureOlmSessionsForDevices(this.olmDevice, this.baseApis, { [userId]: [deviceInfo] });
+                    await olmlib.encryptMessageForDevice(
+                        encryptedContent.ciphertext,
+                        this.userId,
+                        this.deviceId,
+                        this.olmDevice,
+                        userId,
+                        deviceInfo,
+                        payload,
+                    );
+                }),
+            );
 
             // prune out any devices that encryptMessageForDevice could not encrypt for,
             // in which case it will have just not added anything to the ciphertext object.
             // There's no point sending messages to devices if we couldn't encrypt to them,
             // since that's effectively a blank message.
-            toDeviceBatch.batch = toDeviceBatch.batch.filter(msg => {
+            toDeviceBatch.batch = toDeviceBatch.batch.filter((msg) => {
                 if (Object.keys(msg.payload.ciphertext).length > 0) {
                     return true;
                 } else {
@@ -3336,11 +3219,12 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
     private onToDeviceEvent = (event: MatrixEvent): void => {
         try {
-            logger.log(`received to-device ${event.getType()} from: ` +
-                `${event.getSender()} id: ${event.getContent()[ToDeviceMessageId]}`);
+            logger.log(
+                `received to-device ${event.getType()} from: ` +
+                    `${event.getSender()} id: ${event.getContent()[ToDeviceMessageId]}`,
+            );
 
-            if (event.getType() == "m.room_key"
-                || event.getType() == "m.forwarded_room_key") {
+            if (event.getType() == "m.room_key" || event.getType() == "m.forwarded_room_key") {
                 this.onRoomKeyEvent(event);
             } else if (event.getType() == "m.room_key_request") {
                 this.onRoomKeyRequestEvent(event);
@@ -3401,16 +3285,19 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     private onRoomKeyWithheldEvent(event: MatrixEvent): void {
         const content = event.getContent();
 
-        if ((content.code !== "m.no_olm" && (!content.room_id || !content.session_id))
-            || !content.algorithm || !content.sender_key) {
+        if (
+            (content.code !== "m.no_olm" && (!content.room_id || !content.session_id)) ||
+            !content.algorithm ||
+            !content.sender_key
+        ) {
             logger.error("key withheld event is missing fields");
             return;
         }
 
         logger.info(
-            `Got room key withheld event from ${event.getSender()} `
-            + `for ${content.algorithm} session ${content.sender_key}|${content.session_id} `
-            + `in room ${content.room_id} with code ${content.code} (${content.reason})`,
+            `Got room key withheld event from ${event.getSender()} ` +
+                `for ${content.algorithm} session ${content.sender_key}|${content.session_id} ` +
+                `in room ${content.room_id} with code ${content.code} (${content.reason})`,
         );
 
         const alg = this.getRoomDecryptor(content.room_id, content.algorithm);
@@ -3448,13 +3335,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                 return;
             }
             const userId = event.getSender()!;
-            const channel = new ToDeviceChannel(
-                this.baseApis,
-                userId,
-                [deviceId],
-            );
-            return new VerificationRequest(
-                channel, this.verificationMethods, this.baseApis);
+            const channel = new ToDeviceChannel(this.baseApis, userId, [deviceId]);
+            return new VerificationRequest(channel, this.verificationMethods, this.baseApis);
         };
         this.handleVerificationEvent(event, this.toDeviceVerificationRequests, createRequest);
     }
@@ -3481,8 +3363,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         }
         const createRequest = (event: MatrixEvent): VerificationRequest => {
             const channel = new InRoomChannel(this.baseApis, event.getRoomId()!);
-            return new VerificationRequest(
-                channel, this.verificationMethods, this.baseApis);
+            return new VerificationRequest(channel, this.verificationMethods, this.baseApis);
         };
         this.handleVerificationEvent(event, this.inRoomVerificationRequests, createRequest, liveEvent);
     };
@@ -3522,8 +3403,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             request = createRequest(event);
             // a request could not be made from this event, so ignore event
             if (!request) {
-                logger.log(`Crypto: could not find VerificationRequest for ` +
-                    `${event.getType()}, and could not create one, so ignoring.`);
+                logger.log(
+                    `Crypto: could not find VerificationRequest for ` +
+                        `${event.getType()}, and could not create one, so ignoring.`,
+                );
                 return;
             }
             isNewRequest = true;
@@ -3535,7 +3418,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         } catch (err) {
             logger.error("error while handling verification event", err);
         }
-        const shouldEmit = isNewRequest &&
+        const shouldEmit =
+            isNewRequest &&
             !request.initiatedByMe &&
             !request.invalid && // check it has enough events to pass the UNSENT stage
             !request.observeOnly;
@@ -3576,8 +3460,13 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const lastNewSessionForced = this.lastNewSessionForced[sender][deviceKey] || 0;
         if (lastNewSessionForced + MIN_FORCE_SESSION_INTERVAL_MS > Date.now()) {
             logger.debug(
-                "New session already forced with device " + sender + ":" + deviceKey +
-                " at " + lastNewSessionForced + ": not forcing another",
+                "New session already forced with device " +
+                    sender +
+                    ":" +
+                    deviceKey +
+                    " at " +
+                    lastNewSessionForced +
+                    ": not forcing another",
             );
             await this.olmDevice.recordSessionProblem(deviceKey, "wedged", true);
             retryDecryption();
@@ -3595,10 +3484,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             await this.downloadKeys([sender], false);
             device = this.deviceList.getDeviceByIdentityKey(algorithm, deviceKey);
             if (!device) {
-                logger.info(
-                    "Couldn't find device for identity key " + deviceKey +
-                    ": not re-establishing session",
-                );
+                logger.info("Couldn't find device for identity key " + deviceKey + ": not re-establishing session");
                 await this.olmDevice.recordSessionProblem(deviceKey, "wedged", false);
                 retryDecryption();
                 return;
@@ -3645,8 +3531,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         // we failed to decrypt the message and will be waiting a bit for the key to arrive before sending
         // it. This won't always be the case though so we need to re-send any that have already been sent
         // to avoid races.
-        const requestsToResend =
-            await this.outgoingRoomKeyRequestManager.getOutgoingSentRoomKeyRequest(sender, device.deviceId);
+        const requestsToResend = await this.outgoingRoomKeyRequestManager.getOutgoingSentRoomKeyRequest(
+            sender,
+            device.deviceId,
+        );
         for (const keyReq of requestsToResend) {
             this.requestRoomKey(keyReq.requestBody, keyReq.recipients, true);
         }
@@ -3681,14 +3569,15 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         // the result of anyway, as we'll need to do a query again once all the members are fetched
         // by calling _trackRoomDevices
         if (roomId in this.roomDeviceTrackingState) {
-            if (member.membership == 'join') {
-                logger.log('Join event for ' + member.userId + ' in ' + roomId);
+            if (member.membership == "join") {
+                logger.log("Join event for " + member.userId + " in " + roomId);
                 // make sure we are tracking the deviceList for this user
                 this.deviceList.startTrackingDeviceList(member.userId);
-            } else if (member.membership == 'invite' &&
+            } else if (
+                member.membership == "invite" &&
                 this.clientStore.getRoom(roomId)?.shouldEncryptForInvitedMembers()
             ) {
-                logger.log('Invite event for ' + member.userId + ' in ' + roomId);
+                logger.log("Invite event for " + member.userId + " in " + roomId);
                 this.deviceList.startTrackingDeviceList(member.userId);
             }
         }
@@ -3745,10 +3634,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             // cancellation (and end up with a cancelled request), rather than the
             // cancellation before the request (and end up with an outstanding
             // request which should have been cancelled.)
-            await Promise.all(requests.map((req) =>
-                this.processReceivedRoomKeyRequest(req)));
-            await Promise.all(cancellations.map((cancellation) =>
-                this.processReceivedRoomKeyRequestCancellation(cancellation)));
+            await Promise.all(requests.map((req) => this.processReceivedRoomKeyRequest(req)));
+            await Promise.all(
+                cancellations.map((cancellation) => this.processReceivedRoomKeyRequestCancellation(cancellation)),
+            );
         } catch (e) {
             logger.error(`Error processing room key requsts: ${e}`);
         } finally {
@@ -3768,8 +3657,10 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const roomId = body.room_id;
         const alg = body.algorithm;
 
-        logger.log(`m.room_key_request from ${userId}:${deviceId}` +
-            ` for ${roomId} / ${body.session_id} (id ${req.requestId})`);
+        logger.log(
+            `m.room_key_request from ${userId}:${deviceId}` +
+                ` for ${roomId} / ${body.session_id} (id ${req.requestId})`,
+        );
 
         if (userId !== this.userId) {
             if (!this.roomEncryptors.get(roomId)) {
@@ -3787,8 +3678,13 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
                 await encryptor.reshareKeyWithDevice!(body.sender_key, body.session_id, userId, device);
             } catch (e) {
                 logger.warn(
-                    "Failed to re-share keys for session " + body.session_id +
-                    " with device " + userId + ":" + device.deviceId, e,
+                    "Failed to re-share keys for session " +
+                        body.session_id +
+                        " with device " +
+                        userId +
+                        ":" +
+                        device.deviceId,
+                    e,
                 );
             }
             return;
@@ -3823,11 +3719,8 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
             return;
         }
 
-        if (!await decryptor.hasKeysForKeyRequest(req)) {
-            logger.log(
-                `room key request for unknown session ${roomId} / ` +
-                body.session_id,
-            );
+        if (!(await decryptor.hasKeysForKeyRequest(req))) {
+            logger.log(`room key request for unknown session ${roomId} / ` + body.session_id);
             return;
         }
 
@@ -3837,7 +3730,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
 
         // if the device is verified already, share the keys
         if (this.checkDeviceTrust(userId, deviceId).isVerified()) {
-            logger.log('device is already verified: sharing keys');
+            logger.log("device is already verified: sharing keys");
             req.share();
             return;
         }
@@ -3854,7 +3747,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
     ): Promise<void> {
         logger.log(
             `m.room_key_request cancellation for ${cancellation.userId}:` +
-            `${cancellation.deviceId} (id ${cancellation.requestId})`,
+                `${cancellation.deviceId} (id ${cancellation.requestId})`,
         );
 
         // we should probably only notify the app of cancellations we told it
@@ -3898,7 +3791,7 @@ export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap
         const AlgClass = algorithms.DECRYPTION_CLASSES.get(algorithm);
         if (!AlgClass) {
             throw new algorithms.DecryptionError(
-                'UNKNOWN_ENCRYPTION_ALGORITHM',
+                "UNKNOWN_ENCRYPTION_ALGORITHM",
                 'Unknown encryption algorithm "' + algorithm + '".',
             );
         }
@@ -3968,7 +3861,7 @@ export function fixBackupKey(key?: string): string | null {
     if (typeof key !== "string" || key.indexOf(",") < 0) {
         return null;
     }
-    const fixedKey = Uint8Array.from(key.split(","), x => parseInt(x));
+    const fixedKey = Uint8Array.from(key.split(","), (x) => parseInt(x));
     return olmlib.encodeBase64(fixedKey);
 }
 
diff --git a/src/crypto/key_passphrase.ts b/src/crypto/key_passphrase.ts
index b838fae851b..f6fe7b6b7d7 100644
--- a/src/crypto/key_passphrase.ts
+++ b/src/crypto/key_passphrase.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { randomString } from '../randomstring';
+import { randomString } from "../randomstring";
 import { subtleCrypto, TextEncoder } from "./crypto";
 
 const DEFAULT_ITERATIONS = 500000;
@@ -41,14 +41,12 @@ export function keyFromAuthData(authData: IAuthData, password: string): Promise<
     }
 
     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 deriveKey(
-        password, authData.private_key_salt,
+        password,
+        authData.private_key_salt,
         authData.private_key_iterations,
         authData.private_key_bits || DEFAULT_BITSIZE,
     );
@@ -76,20 +74,16 @@ export async function deriveKey(
         throw new Error("Password-based backup is not available on this platform");
     }
 
-    const key = await subtleCrypto.importKey(
-        'raw',
-        new TextEncoder().encode(password),
-        { name: 'PBKDF2' },
-        false,
-        ['deriveBits'],
-    );
+    const key = await subtleCrypto.importKey("raw", new TextEncoder().encode(password), { name: "PBKDF2" }, false, [
+        "deriveBits",
+    ]);
 
     const keybits = await subtleCrypto.deriveBits(
         {
-            name: 'PBKDF2',
+            name: "PBKDF2",
             salt: new TextEncoder().encode(salt),
             iterations: iterations,
-            hash: 'SHA-512',
+            hash: "SHA-512",
         },
         key,
         numBits,
diff --git a/src/crypto/olmlib.ts b/src/crypto/olmlib.ts
index 4a228e2814a..fc9a2790a9c 100644
--- a/src/crypto/olmlib.ts
+++ b/src/crypto/olmlib.ts
@@ -23,7 +23,7 @@ import anotherjson from "another-json";
 import type { PkSigning } from "@matrix-org/olm";
 import { OlmDevice } from "./OlmDevice";
 import { DeviceInfo } from "./deviceinfo";
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { IOneTimeKey } from "./dehydration";
 import { IClaimOTKsResult, MatrixClient } from "../client";
 import { ISignatures } from "../@types/signed";
@@ -87,14 +87,14 @@ export async function encryptMessageForDevice(
         // we can't encrypt a message for it.
         logger.log(
             `[olmlib.encryptMessageForDevice] Unable to find Olm session for device ` +
-            `${recipientUserId}:${recipientDevice.deviceId}`,
+                `${recipientUserId}:${recipientDevice.deviceId}`,
         );
         return;
     }
 
     logger.log(
         `[olmlib.encryptMessageForDevice] Using Olm session ${sessionId} for device ` +
-        `${recipientUserId}:${recipientDevice.deviceId}`,
+            `${recipientUserId}:${recipientDevice.deviceId}`,
     );
 
     const payload = {
@@ -111,7 +111,7 @@ export async function encryptMessageForDevice(
         // the curve25519 key and the ed25519 key are owned by
         // the same device.
         keys: {
-            "ed25519": olmDevice.deviceEd25519Key,
+            ed25519: olmDevice.deviceEd25519Key,
         },
 
         // include the recipient device details in the payload,
@@ -119,7 +119,7 @@ export async function encryptMessageForDevice(
         // https://github.com/vector-im/vector-web/issues/2483
         recipient: recipientUserId,
         recipient_keys: {
-            "ed25519": recipientDevice.getFingerprint(),
+            ed25519: recipientDevice.getFingerprint(),
         },
         ...payloadFields,
     };
@@ -155,8 +155,8 @@ export async function getExistingOlmSessions(
     baseApis: MatrixClient,
     devicesByUser: Record<string, DeviceInfo[]>,
 ): Promise<[Record<string, DeviceInfo[]>, Record<string, Record<string, IExistingOlmSession>>]> {
-    const devicesWithoutSession: {[userId: string]: DeviceInfo[]} = {};
-    const sessions: {[userId: string]: {[deviceId: string]: IExistingOlmSession}} = {};
+    const devicesWithoutSession: { [userId: string]: DeviceInfo[] } = {};
+    const sessions: { [userId: string]: { [deviceId: string]: IExistingOlmSession } } = {};
 
     const promises: Promise<void>[] = [];
 
@@ -164,21 +164,21 @@ export async function getExistingOlmSessions(
         for (const deviceInfo of devices) {
             const deviceId = deviceInfo.deviceId;
             const key = deviceInfo.getIdentityKey();
-            promises.push((async (): Promise<void> => {
-                const sessionId = await olmDevice.getSessionIdForDevice(
-                    key, true,
-                );
-                if (sessionId === null) {
-                    devicesWithoutSession[userId] = devicesWithoutSession[userId] || [];
-                    devicesWithoutSession[userId].push(deviceInfo);
-                } else {
-                    sessions[userId] = sessions[userId] || {};
-                    sessions[userId][deviceId] = {
-                        device: deviceInfo,
-                        sessionId: sessionId,
-                    };
-                }
-            })());
+            promises.push(
+                (async (): Promise<void> => {
+                    const sessionId = await olmDevice.getSessionIdForDevice(key, true);
+                    if (sessionId === null) {
+                        devicesWithoutSession[userId] = devicesWithoutSession[userId] || [];
+                        devicesWithoutSession[userId].push(deviceInfo);
+                    } else {
+                        sessions[userId] = sessions[userId] || {};
+                        sessions[userId][deviceId] = {
+                            device: deviceInfo,
+                            sessionId: sessionId,
+                        };
+                    }
+                })(),
+            );
         }
     }
 
@@ -219,7 +219,7 @@ export async function ensureOlmSessionsForDevices(
     const devicesWithoutSession: [string, string][] = [
         // [userId, deviceId], ...
     ];
-    const result: {[userId: string]: {[deviceId: string]: IExistingOlmSession}} = {};
+    const result: { [userId: string]: { [deviceId: string]: IExistingOlmSession } } = {};
     const resolveSession: Record<string, (sessionId?: string) => void> = {};
 
     // Mark all sessions this task intends to update as in progress. It is
@@ -241,7 +241,7 @@ export async function ensureOlmSessionsForDevices(
                 // pre-emptively mark the session as in-progress to avoid race
                 // conditions.  If we find that we already have a session, then
                 // we'll resolve
-                olmDevice.sessionsInProgress[key] = new Promise(resolve => {
+                olmDevice.sessionsInProgress[key] = new Promise((resolve) => {
                     resolveSession[key] = (v: any): void => {
                         delete olmDevice.sessionsInProgress[key];
                         resolve(v);
@@ -321,7 +321,7 @@ export async function ensureOlmSessionsForDevices(
         failedServers.push(...Object.keys(res.failures));
     }
 
-    const otkResult = res.one_time_keys || {} as IClaimOTKsResult["one_time_keys"];
+    const otkResult = res.one_time_keys || ({} as IClaimOTKsResult["one_time_keys"]);
     const promises: Promise<void>[] = [];
     for (const [userId, devices] of Object.entries(devicesByUser)) {
         const userRes = otkResult[userId] || {};
@@ -350,10 +350,7 @@ export async function ensureOlmSessionsForDevices(
             }
 
             if (!oneTimeKey) {
-                log.warn(
-                    `No one-time keys (alg=${oneTimeKeyAlgorithm}) ` +
-                    `for device ${userId}:${deviceId}`,
-                );
+                log.warn(`No one-time keys (alg=${oneTimeKeyAlgorithm}) ` + `for device ${userId}:${deviceId}`);
                 if (resolveSession[key]) {
                     resolveSession[key]();
                 }
@@ -361,19 +358,20 @@ export async function ensureOlmSessionsForDevices(
             }
 
             promises.push(
-                _verifyKeyAndStartSession(
-                    olmDevice, oneTimeKey, userId, deviceInfo,
-                ).then((sid) => {
-                    if (resolveSession[key]) {
-                        resolveSession[key](sid ?? undefined);
-                    }
-                    result[userId][deviceId].sessionId = sid;
-                }, (e) => {
-                    if (resolveSession[key]) {
-                        resolveSession[key]();
-                    }
-                    throw e;
-                }),
+                _verifyKeyAndStartSession(olmDevice, oneTimeKey, userId, deviceInfo).then(
+                    (sid) => {
+                        if (resolveSession[key]) {
+                            resolveSession[key](sid ?? undefined);
+                        }
+                        result[userId][deviceId].sessionId = sid;
+                    },
+                    (e) => {
+                        if (resolveSession[key]) {
+                            resolveSession[key]();
+                        }
+                        throw e;
+                    },
+                ),
             );
         }
     }
@@ -393,32 +391,22 @@ async function _verifyKeyAndStartSession(
 ): Promise<string | null> {
     const deviceId = deviceInfo.deviceId;
     try {
-        await verifySignature(
-            olmDevice, oneTimeKey, userId, deviceId,
-            deviceInfo.getFingerprint(),
-        );
+        await verifySignature(olmDevice, oneTimeKey, userId, deviceId, deviceInfo.getFingerprint());
     } catch (e) {
-        logger.error(
-            "Unable to verify signature on one-time key for device " +
-                userId + ":" + deviceId + ":", e,
-        );
+        logger.error("Unable to verify signature on one-time key for device " + userId + ":" + deviceId + ":", e);
         return null;
     }
 
     let sid;
     try {
-        sid = await olmDevice.createOutboundSession(
-            deviceInfo.getIdentityKey(), oneTimeKey.key,
-        );
+        sid = await olmDevice.createOutboundSession(deviceInfo.getIdentityKey(), oneTimeKey.key);
     } catch (e) {
         // possibly a bad key
-        logger.error("Error starting olm session with device " +
-                      userId + ":" + deviceId + ": " + e);
+        logger.error("Error starting olm session with device " + userId + ":" + deviceId + ": " + e);
         return null;
     }
 
-    logger.log("Started new olm sessionid " + sid +
-                " for device " + userId + ":" + deviceId);
+    logger.log("Started new olm sessionid " + sid + " for device " + userId + ":" + deviceId);
     return sid;
 }
 
@@ -466,9 +454,7 @@ export async function verifySignature(
     delete mangledObj.signatures;
     const json = anotherjson.stringify(mangledObj);
 
-    olmDevice.verifySignature(
-        signingKey, json, signature,
-    );
+    olmDevice.verifySignature(signingKey, json, signature);
 }
 
 /**
@@ -497,7 +483,7 @@ export function pkSign(obj: object & IObject, key: Uint8Array | PkSigning, userI
         const mysigs = sigs[userId] || {};
         sigs[userId] = mysigs;
 
-        return mysigs['ed25519:' + pubKey] = key.sign(anotherjson.stringify(obj));
+        return (mysigs["ed25519:" + pubKey] = key.sign(anotherjson.stringify(obj)));
     } finally {
         obj.signatures = sigs;
         if (unsigned) obj.unsigned = unsigned;
@@ -541,8 +527,10 @@ export function isOlmEncrypted(event: MatrixEvent): boolean {
         logger.error("Event has no sender key (not encrypted?)");
         return false;
     }
-    if (event.getWireType() !== EventType.RoomMessageEncrypted ||
-        !(["m.olm.v1.curve25519-aes-sha2"].includes(event.getWireContent().algorithm))) {
+    if (
+        event.getWireType() !== EventType.RoomMessageEncrypted ||
+        !["m.olm.v1.curve25519-aes-sha2"].includes(event.getWireContent().algorithm)
+    ) {
         logger.error("Event was not encrypted using an appropriate algorithm");
         return false;
     }
@@ -564,7 +552,7 @@ export function encodeBase64(uint8Array: ArrayBuffer | Uint8Array): string {
  * @returns The unpadded base64.
  */
 export function encodeUnpaddedBase64(uint8Array: ArrayBuffer | Uint8Array): string {
-    return encodeBase64(uint8Array).replace(/=+$/g, '');
+    return encodeBase64(uint8Array).replace(/=+$/g, "");
 }
 
 /**
diff --git a/src/crypto/recoverykey.ts b/src/crypto/recoverykey.ts
index 449bc218b35..4107b76f5ab 100644
--- a/src/crypto/recoverykey.ts
+++ b/src/crypto/recoverykey.ts
@@ -14,11 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import * as bs58 from 'bs58';
+import * as bs58 from "bs58";
 
 // picked arbitrarily but to try & avoid clashing with any bitcoin ones
 // (which are also base58 encoded, but bitcoin's involve a lot more hashing)
-const OLM_RECOVERY_KEY_PREFIX = [0x8B, 0x01];
+const OLM_RECOVERY_KEY_PREFIX = [0x8b, 0x01];
 
 export function encodeRecoveryKey(key: ArrayLike<number>): string | undefined {
     const buf = Buffer.alloc(OLM_RECOVERY_KEY_PREFIX.length + key.length + 1);
@@ -36,7 +36,7 @@ export function encodeRecoveryKey(key: ArrayLike<number>): string | undefined {
 }
 
 export function decodeRecoveryKey(recoveryKey: string): Uint8Array {
-    const result = bs58.decode(recoveryKey.replace(/ /g, ''));
+    const result = bs58.decode(recoveryKey.replace(/ /g, ""));
 
     let parity = 0;
     for (const b of result) {
@@ -52,15 +52,11 @@ export function decodeRecoveryKey(recoveryKey: string): Uint8Array {
         }
     }
 
-    if (
-        result.length !==
-        OLM_RECOVERY_KEY_PREFIX.length + global.Olm.PRIVATE_KEY_LENGTH + 1
-    ) {
+    if (result.length !== OLM_RECOVERY_KEY_PREFIX.length + global.Olm.PRIVATE_KEY_LENGTH + 1) {
         throw new Error("Incorrect length");
     }
 
-    return Uint8Array.from(result.slice(
-        OLM_RECOVERY_KEY_PREFIX.length,
-        OLM_RECOVERY_KEY_PREFIX.length + global.Olm.PRIVATE_KEY_LENGTH,
-    ));
+    return Uint8Array.from(
+        result.slice(OLM_RECOVERY_KEY_PREFIX.length, OLM_RECOVERY_KEY_PREFIX.length + global.Olm.PRIVATE_KEY_LENGTH),
+    );
 }
diff --git a/src/crypto/store/base.ts b/src/crypto/store/base.ts
index 31ece3b066f..4c88ec2872e 100644
--- a/src/crypto/store/base.ts
+++ b/src/crypto/store/base.ts
@@ -33,7 +33,7 @@ import { IEncryptedPayload } from "../aes";
  */
 
 export interface SecretStorePrivateKeys {
-    dehydration: {
+    "dehydration": {
         keyInfo: DehydrationManager["keyInfo"];
         key: IEncryptedPayload;
         deviceDisplayName: string;
@@ -106,10 +106,7 @@ export interface CryptoStore {
         txn: unknown,
         func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
     ): void;
-    getAllEndToEndInboundGroupSessions(
-        txn: unknown,
-        func: (session: ISession | null) => void,
-    ): void;
+    getAllEndToEndInboundGroupSessions(txn: unknown, func: (session: ISession | null) => void): void;
     addEndToEndInboundGroupSession(
         senderCurve25519Key: string,
         sessionId: string,
@@ -167,12 +164,12 @@ export interface ISessionInfo {
 
 export interface IDeviceData {
     devices: {
-        [ userId: string ]: {
-            [ deviceId: string ]: IDevice;
+        [userId: string]: {
+            [deviceId: string]: IDevice;
         };
     };
     trackingStatus: {
-        [ userId: string ]: TrackingStatus;
+        [userId: string]: TrackingStatus;
     };
     crossSigningInfo?: Record<string, ICrossSigningInfo>;
     syncToken?: string;
diff --git a/src/crypto/store/indexeddb-crypto-store-backend.ts b/src/crypto/store/indexeddb-crypto-store-backend.ts
index 3a0c7711a9a..7827697ec8d 100644
--- a/src/crypto/store/indexeddb-crypto-store-backend.ts
+++ b/src/crypto/store/indexeddb-crypto-store-backend.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger, PrefixedLogger } from '../../logger';
+import { logger, PrefixedLogger } from "../../logger";
 import * as utils from "../../utils";
 import {
     CryptoStore,
@@ -25,7 +25,8 @@ import {
     IWithheld,
     Mode,
     OutgoingRoomKeyRequest,
-    ParkedSharedHistory, SecretStorePrivateKeys,
+    ParkedSharedHistory,
+    SecretStorePrivateKeys,
 } from "./base";
 import { IRoomKeyRequestBody, IRoomKeyRequestRecipient } from "../index";
 import { ICrossSigningKey } from "../../client";
@@ -95,11 +96,10 @@ export class Backend implements CryptoStore {
 
                 // we got to the end of the list without finding a match
                 // - add the new request.
-                logger.log(
-                    `enqueueing key request for ${requestBody.room_id} / ` +
-                        requestBody.session_id,
-                );
-                txn.oncomplete = (): void => {resolve(request);};
+                logger.log(`enqueueing key request for ${requestBody.room_id} / ` + requestBody.session_id);
+                txn.oncomplete = (): void => {
+                    resolve(request);
+                };
                 const store = txn.objectStore("outgoingRoomKeyRequests");
                 store.add(request);
             });
@@ -146,10 +146,7 @@ export class Backend implements CryptoStore {
         const store = txn.objectStore("outgoingRoomKeyRequests");
 
         const idx = store.index("session");
-        const cursorReq = idx.openCursor([
-            requestBody.room_id,
-            requestBody.session_id,
-        ]);
+        const cursorReq = idx.openCursor([requestBody.room_id, requestBody.session_id]);
 
         cursorReq.onsuccess = (): void => {
             const cursor = cursorReq.result;
@@ -253,9 +250,12 @@ export class Backend implements CryptoStore {
             const cursor = this.result;
             if (cursor) {
                 const keyReq = cursor.value;
-                if (keyReq.recipients.some((recipient: IRoomKeyRequestRecipient) =>
-                    recipient.userId === userId && recipient.deviceId === deviceId,
-                )) {
+                if (
+                    keyReq.recipients.some(
+                        (recipient: IRoomKeyRequestRecipient) =>
+                            recipient.userId === userId && recipient.deviceId === deviceId,
+                    )
+                ) {
                     results.push(keyReq);
                 }
                 cursor.continue();
@@ -311,7 +311,7 @@ export class Backend implements CryptoStore {
             if (data.state != expectedState) {
                 logger.warn(
                     `Cannot update room key request from ${expectedState} ` +
-                    `as it was already updated to ${data.state}`,
+                        `as it was already updated to ${data.state}`,
                 );
                 return;
             }
@@ -348,10 +348,7 @@ export class Backend implements CryptoStore {
             }
             const data = cursor.value;
             if (data.state != expectedState) {
-                logger.warn(
-                    `Cannot delete room key request in state ${data.state} `
-                        + `(expected ${expectedState})`,
-                );
+                logger.warn(`Cannot delete room key request in state ${data.state} ` + `(expected ${expectedState})`);
                 return;
             }
             cursor.delete();
@@ -364,7 +361,7 @@ export class Backend implements CryptoStore {
     public getAccount(txn: IDBTransaction, func: (accountPickle: string | null) => void): void {
         const objectStore = txn.objectStore("account");
         const getReq = objectStore.get("-");
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             try {
                 func(getReq.result || null);
             } catch (e) {
@@ -384,7 +381,7 @@ export class Backend implements CryptoStore {
     ): void {
         const objectStore = txn.objectStore("account");
         const getReq = objectStore.get("crossSigningKeys");
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             try {
                 func(getReq.result || null);
             } catch (e) {
@@ -400,7 +397,7 @@ export class Backend implements CryptoStore {
     ): void {
         const objectStore = txn.objectStore("account");
         const getReq = objectStore.get(`ssss_cache:${type}`);
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             try {
                 func(getReq.result || null);
             } catch (e) {
@@ -428,7 +425,7 @@ export class Backend implements CryptoStore {
     public countEndToEndSessions(txn: IDBTransaction, func: (count: number) => void): void {
         const objectStore = txn.objectStore("sessions");
         const countReq = objectStore.count();
-        countReq.onsuccess = function(): void {
+        countReq.onsuccess = function (): void {
             try {
                 func(countReq.result);
             } catch (e) {
@@ -446,7 +443,7 @@ export class Backend implements CryptoStore {
         const idx = objectStore.index("deviceKey");
         const getReq = idx.openCursor(deviceKey);
         const results: Parameters<Parameters<Backend["getEndToEndSessions"]>[2]>[0] = {};
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             const cursor = getReq.result;
             if (cursor) {
                 results[cursor.value.sessionId] = {
@@ -472,7 +469,7 @@ export class Backend implements CryptoStore {
     ): void {
         const objectStore = txn.objectStore("sessions");
         const getReq = objectStore.get([deviceKey, sessionId]);
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             try {
                 if (getReq.result) {
                     func({
@@ -491,7 +488,7 @@ export class Backend implements CryptoStore {
     public getAllEndToEndSessions(txn: IDBTransaction, func: (session: ISessionInfo | null) => void): void {
         const objectStore = txn.objectStore("sessions");
         const getReq = objectStore.openCursor();
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             try {
                 const cursor = getReq.result;
                 if (cursor) {
@@ -572,19 +569,21 @@ export class Backend implements CryptoStore {
 
         const ret: IOlmDevice[] = [];
 
-        await Promise.all(devices.map((device) => {
-            return new Promise<void>((resolve) => {
-                const { userId, deviceInfo } = device;
-                const getReq = objectStore.get([userId, deviceInfo.deviceId]);
-                getReq.onsuccess = function(): void {
-                    if (!getReq.result) {
-                        objectStore.put({ userId, deviceId: deviceInfo.deviceId });
-                        ret.push(device);
-                    }
-                    resolve();
-                };
-            });
-        }));
+        await Promise.all(
+            devices.map((device) => {
+                return new Promise<void>((resolve) => {
+                    const { userId, deviceInfo } = device;
+                    const getReq = objectStore.get([userId, deviceInfo.deviceId]);
+                    getReq.onsuccess = function (): void {
+                        if (!getReq.result) {
+                            objectStore.put({ userId, deviceId: deviceInfo.deviceId });
+                            ret.push(device);
+                        }
+                        resolve();
+                    };
+                });
+            }),
+        );
 
         return ret;
     }
@@ -601,7 +600,7 @@ export class Backend implements CryptoStore {
         let withheld: IWithheld | null | boolean = false;
         const objectStore = txn.objectStore("inbound_group_sessions");
         const getReq = objectStore.get([senderCurve25519Key, sessionId]);
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             try {
                 if (getReq.result) {
                     session = getReq.result.session;
@@ -618,7 +617,7 @@ export class Backend implements CryptoStore {
 
         const withheldObjectStore = txn.objectStore("inbound_group_sessions_withheld");
         const withheldGetReq = withheldObjectStore.get([senderCurve25519Key, sessionId]);
-        withheldGetReq.onsuccess = function(): void {
+        withheldGetReq.onsuccess = function (): void {
             try {
                 if (withheldGetReq.result) {
                     withheld = withheldGetReq.result.session;
@@ -637,7 +636,7 @@ export class Backend implements CryptoStore {
     public getAllEndToEndInboundGroupSessions(txn: IDBTransaction, func: (session: ISession | null) => void): void {
         const objectStore = txn.objectStore("inbound_group_sessions");
         const getReq = objectStore.openCursor();
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             const cursor = getReq.result;
             if (cursor) {
                 try {
@@ -668,22 +667,19 @@ export class Backend implements CryptoStore {
     ): void {
         const objectStore = txn.objectStore("inbound_group_sessions");
         const addReq = objectStore.add({
-            senderCurve25519Key, sessionId, session: sessionData,
+            senderCurve25519Key,
+            sessionId,
+            session: sessionData,
         });
         addReq.onerror = (ev): void => {
-            if (addReq.error?.name === 'ConstraintError') {
+            if (addReq.error?.name === "ConstraintError") {
                 // This stops the error from triggering the txn's onerror
                 ev.stopPropagation();
                 // ...and this stops it from aborting the transaction
                 ev.preventDefault();
-                logger.log(
-                    "Ignoring duplicate inbound group session: " +
-                    senderCurve25519Key + " / " + sessionId,
-                );
+                logger.log("Ignoring duplicate inbound group session: " + senderCurve25519Key + " / " + sessionId);
             } else {
-                abortWithException(txn, new Error(
-                    "Failed to add inbound group session: " + addReq.error,
-                ));
+                abortWithException(txn, new Error("Failed to add inbound group session: " + addReq.error));
             }
         };
     }
@@ -696,7 +692,9 @@ export class Backend implements CryptoStore {
     ): void {
         const objectStore = txn.objectStore("inbound_group_sessions");
         objectStore.put({
-            senderCurve25519Key, sessionId, session: sessionData,
+            senderCurve25519Key,
+            sessionId,
+            session: sessionData,
         });
     }
 
@@ -708,14 +706,16 @@ export class Backend implements CryptoStore {
     ): void {
         const objectStore = txn.objectStore("inbound_group_sessions_withheld");
         objectStore.put({
-            senderCurve25519Key, sessionId, session: sessionData,
+            senderCurve25519Key,
+            sessionId,
+            session: sessionData,
         });
     }
 
     public getEndToEndDeviceData(txn: IDBTransaction, func: (deviceData: IDeviceData | null) => void): void {
         const objectStore = txn.objectStore("device_data");
         const getReq = objectStore.get("-");
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             try {
                 func(getReq.result || null);
             } catch (e) {
@@ -738,7 +738,7 @@ export class Backend implements CryptoStore {
         const rooms: Parameters<Parameters<Backend["getEndToEndRooms"]>[1]>[0] = {};
         const objectStore = txn.objectStore("rooms");
         const getReq = objectStore.openCursor();
-        getReq.onsuccess = function(): void {
+        getReq.onsuccess = function (): void {
             const cursor = getReq.result;
             if (cursor) {
                 rooms[cursor.key as string] = cursor.value;
@@ -759,22 +759,19 @@ export class Backend implements CryptoStore {
         return new Promise((resolve, reject) => {
             const sessions: ISession[] = [];
 
-            const txn = this.db.transaction(
-                ["sessions_needing_backup", "inbound_group_sessions"],
-                "readonly",
-            );
+            const txn = this.db.transaction(["sessions_needing_backup", "inbound_group_sessions"], "readonly");
             txn.onerror = reject;
-            txn.oncomplete = function(): void {
+            txn.oncomplete = function (): void {
                 resolve(sessions);
             };
             const objectStore = txn.objectStore("sessions_needing_backup");
             const sessionStore = txn.objectStore("inbound_group_sessions");
             const getReq = objectStore.openCursor();
-            getReq.onsuccess = function(): void {
+            getReq.onsuccess = function (): void {
                 const cursor = getReq.result;
                 if (cursor) {
                     const sessionGetReq = sessionStore.get(cursor.key);
-                    sessionGetReq.onsuccess = function(): void {
+                    sessionGetReq.onsuccess = function (): void {
                         sessions.push({
                             senderKey: sessionGetReq.result.senderCurve25519Key,
                             sessionId: sessionGetReq.result.sessionId,
@@ -806,13 +803,15 @@ export class Backend implements CryptoStore {
             txn = this.db.transaction("sessions_needing_backup", "readwrite");
         }
         const objectStore = txn.objectStore("sessions_needing_backup");
-        await Promise.all(sessions.map((session) => {
-            return new Promise((resolve, reject) => {
-                const req = objectStore.delete([session.senderKey, session.sessionId]);
-                req.onsuccess = resolve;
-                req.onerror = reject;
-            });
-        }));
+        await Promise.all(
+            sessions.map((session) => {
+                return new Promise((resolve, reject) => {
+                    const req = objectStore.delete([session.senderKey, session.sessionId]);
+                    req.onsuccess = resolve;
+                    req.onerror = reject;
+                });
+            }),
+        );
     }
 
     public async markSessionsNeedingBackup(sessions: ISession[], txn?: IDBTransaction): Promise<void> {
@@ -820,16 +819,18 @@ export class Backend implements CryptoStore {
             txn = this.db.transaction("sessions_needing_backup", "readwrite");
         }
         const objectStore = txn.objectStore("sessions_needing_backup");
-        await Promise.all(sessions.map((session) => {
-            return new Promise((resolve, reject) => {
-                const req = objectStore.put({
-                    senderCurve25519Key: session.senderKey,
-                    sessionId: session.sessionId,
+        await Promise.all(
+            sessions.map((session) => {
+                return new Promise((resolve, reject) => {
+                    const req = objectStore.put({
+                        senderCurve25519Key: session.senderKey,
+                        sessionId: session.sessionId,
+                    });
+                    req.onsuccess = resolve;
+                    req.onerror = reject;
                 });
-                req.onsuccess = resolve;
-                req.onerror = reject;
-            });
-        }));
+            }),
+        );
     }
 
     public addSharedHistoryInboundGroupSession(
@@ -839,9 +840,7 @@ export class Backend implements CryptoStore {
         txn?: IDBTransaction,
     ): void {
         if (!txn) {
-            txn = this.db.transaction(
-                "shared_history_inbound_group_sessions", "readwrite",
-            );
+            txn = this.db.transaction("shared_history_inbound_group_sessions", "readwrite");
         }
         const objectStore = txn.objectStore("shared_history_inbound_group_sessions");
         const req = objectStore.get([roomId]);
@@ -857,9 +856,7 @@ export class Backend implements CryptoStore {
         txn?: IDBTransaction,
     ): Promise<[senderKey: string, sessionId: string][]> {
         if (!txn) {
-            txn = this.db.transaction(
-                "shared_history_inbound_group_sessions", "readonly",
-            );
+            txn = this.db.transaction("shared_history_inbound_group_sessions", "readonly");
         }
         const objectStore = txn.objectStore("shared_history_inbound_group_sessions");
         const req = objectStore.get([roomId]);
@@ -872,15 +869,9 @@ export class Backend implements CryptoStore {
         });
     }
 
-    public addParkedSharedHistory(
-        roomId: string,
-        parkedData: ParkedSharedHistory,
-        txn?: IDBTransaction,
-    ): void {
+    public addParkedSharedHistory(roomId: string, parkedData: ParkedSharedHistory, txn?: IDBTransaction): void {
         if (!txn) {
-            txn = this.db.transaction(
-                "parked_shared_history", "readwrite",
-            );
+            txn = this.db.transaction("parked_shared_history", "readwrite");
         }
         const objectStore = txn.objectStore("parked_shared_history");
         const req = objectStore.get([roomId]);
@@ -891,14 +882,9 @@ export class Backend implements CryptoStore {
         };
     }
 
-    public takeParkedSharedHistory(
-        roomId: string,
-        txn?: IDBTransaction,
-    ): Promise<ParkedSharedHistory[]> {
+    public takeParkedSharedHistory(roomId: string, txn?: IDBTransaction): Promise<ParkedSharedHistory[]> {
         if (!txn) {
-            txn = this.db.transaction(
-                "parked_shared_history", "readwrite",
-            );
+            txn = this.db.transaction("parked_shared_history", "readwrite");
         }
         const cursorReq = txn.objectStore("parked_shared_history").openCursor(roomId);
         return new Promise((resolve, reject) => {
@@ -934,13 +920,16 @@ export class Backend implements CryptoStore {
         const promise = promiseifyTxn(txn);
         const result = func(txn);
         if (PROFILE_TRANSACTIONS) {
-            promise.then(() => {
-                const elapsedTime = Date.now() - startTime;
-                log.debug(`Finished ${description}, took ${elapsedTime} ms`);
-            }, () => {
-                const elapsedTime = Date.now() - startTime;
-                log.error(`Failed ${description}, took ${elapsedTime} ms`);
-            });
+            promise.then(
+                () => {
+                    const elapsedTime = Date.now() - startTime;
+                    log.debug(`Finished ${description}, took ${elapsedTime} ms`);
+                },
+                () => {
+                    const elapsedTime = Date.now() - startTime;
+                    log.error(`Failed ${description}, took ${elapsedTime} ms`);
+                },
+            );
         }
         return promise.then(() => {
             return result;
@@ -950,8 +939,12 @@ export class Backend implements CryptoStore {
 
 type DbMigration = (db: IDBDatabase) => void;
 const DB_MIGRATIONS: DbMigration[] = [
-    (db): void => { createDatabase(db); },
-    (db): void => { db.createObjectStore("account"); },
+    (db): void => {
+        createDatabase(db);
+    },
+    (db): void => {
+        db.createObjectStore("account");
+    },
     (db): void => {
         const sessionsStore = db.createObjectStore("sessions", {
             keyPath: ["deviceKey", "sessionId"],
@@ -963,8 +956,12 @@ const DB_MIGRATIONS: DbMigration[] = [
             keyPath: ["senderCurve25519Key", "sessionId"],
         });
     },
-    (db): void => { db.createObjectStore("device_data"); },
-    (db): void => { db.createObjectStore("rooms"); },
+    (db): void => {
+        db.createObjectStore("device_data");
+    },
+    (db): void => {
+        db.createObjectStore("rooms");
+    },
     (db): void => {
         db.createObjectStore("sessions_needing_backup", {
             keyPath: ["senderCurve25519Key", "sessionId"],
@@ -1000,24 +997,18 @@ 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);
     });
 }
 
 function createDatabase(db: IDBDatabase): void {
-    const outgoingRoomKeyRequestsStore =
-        db.createObjectStore("outgoingRoomKeyRequests", { keyPath: "requestId" });
+    const outgoingRoomKeyRequestsStore = db.createObjectStore("outgoingRoomKeyRequests", { keyPath: "requestId" });
 
     // we assume that the RoomKeyRequestBody will have room_id and session_id
     // properties, to make the index efficient.
-    outgoingRoomKeyRequestsStore.createIndex("session",
-        ["requestBody.room_id", "requestBody.session_id"],
-    );
+    outgoingRoomKeyRequestsStore.createIndex("session", ["requestBody.room_id", "requestBody.session_id"]);
 
     outgoingRoomKeyRequestsStore.createIndex("state", "state");
 }
diff --git a/src/crypto/store/indexeddb-crypto-store.ts b/src/crypto/store/indexeddb-crypto-store.ts
index ac2964d12af..320235fbf63 100644
--- a/src/crypto/store/indexeddb-crypto-store.ts
+++ b/src/crypto/store/indexeddb-crypto-store.ts
@@ -14,11 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger, PrefixedLogger } from '../../logger';
-import { LocalStorageCryptoStore } from './localStorage-crypto-store';
-import { MemoryCryptoStore } from './memory-crypto-store';
-import * as IndexedDBCryptoStoreBackend from './indexeddb-crypto-store-backend';
-import { InvalidCryptoStoreError, InvalidCryptoStoreState } from '../../errors';
+import { logger, PrefixedLogger } from "../../logger";
+import { LocalStorageCryptoStore } from "./localStorage-crypto-store";
+import { MemoryCryptoStore } from "./memory-crypto-store";
+import * as IndexedDBCryptoStoreBackend from "./indexeddb-crypto-store-backend";
+import { InvalidCryptoStoreError, InvalidCryptoStoreState } from "../../errors";
 import * as IndexedDBHelpers from "../../indexeddb-helpers";
 import {
     CryptoStore,
@@ -29,7 +29,8 @@ import {
     IWithheld,
     Mode,
     OutgoingRoomKeyRequest,
-    ParkedSharedHistory, SecretStorePrivateKeys,
+    ParkedSharedHistory,
+    SecretStorePrivateKeys,
 } from "./base";
 import { IRoomKeyRequestBody } from "../index";
 import { ICrossSigningKey } from "../../client";
@@ -46,15 +47,15 @@ import { InboundGroupSessionData } from "../OlmDevice";
  * but with fallback to MemoryCryptoStore.
  */
 export class IndexedDBCryptoStore implements CryptoStore {
-    public static STORE_ACCOUNT = 'account';
-    public static STORE_SESSIONS = 'sessions';
-    public static STORE_INBOUND_GROUP_SESSIONS = 'inbound_group_sessions';
-    public static STORE_INBOUND_GROUP_SESSIONS_WITHHELD = 'inbound_group_sessions_withheld';
-    public static STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS = 'shared_history_inbound_group_sessions';
-    public static STORE_PARKED_SHARED_HISTORY = 'parked_shared_history';
-    public static STORE_DEVICE_DATA = 'device_data';
-    public static STORE_ROOMS = 'rooms';
-    public static STORE_BACKUP = 'sessions_needing_backup';
+    public static STORE_ACCOUNT = "account";
+    public static STORE_SESSIONS = "sessions";
+    public static STORE_INBOUND_GROUP_SESSIONS = "inbound_group_sessions";
+    public static STORE_INBOUND_GROUP_SESSIONS_WITHHELD = "inbound_group_sessions_withheld";
+    public static STORE_SHARED_HISTORY_INBOUND_GROUP_SESSIONS = "shared_history_inbound_group_sessions";
+    public static STORE_PARKED_SHARED_HISTORY = "parked_shared_history";
+    public static STORE_DEVICE_DATA = "device_data";
+    public static STORE_ROOMS = "rooms";
+    public static STORE_BACKUP = "sessions_needing_backup";
 
     public static exists(indexedDB: IDBFactory, dbName: string): Promise<boolean> {
         return IndexedDBHelpers.exists(indexedDB, dbName);
@@ -87,7 +88,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
 
         this.backendPromise = new Promise<CryptoStore>((resolve, reject) => {
             if (!this.indexedDB) {
-                reject(new Error('no indexeddb support available'));
+                reject(new Error("no indexeddb support available"));
                 return;
             }
 
@@ -102,9 +103,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
             };
 
             req.onblocked = (): void => {
-                logger.log(
-                    `can't yet open IndexedDBCryptoStore because it is open elsewhere`,
-                );
+                logger.log(`can't yet open IndexedDBCryptoStore because it is open elsewhere`);
             };
 
             req.onerror = (ev): void => {
@@ -118,44 +117,46 @@ export class IndexedDBCryptoStore implements CryptoStore {
                 logger.log(`connected to indexeddb ${this.dbName}`);
                 resolve(new IndexedDBCryptoStoreBackend.Backend(db));
             };
-        }).then((backend) => {
-            // Edge has IndexedDB but doesn't support compund keys which we use fairly extensively.
-            // Try a dummy query which will fail if the browser doesn't support compund keys, so
-            // we can fall back to a different backend.
-            return backend.doTxn(
-                'readonly',
-                [
-                    IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
-                    IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,
-                ],
-                (txn) => {
-                    backend.getEndToEndInboundGroupSession('', '', txn, () => {});
-                }).then(() => backend,
-            );
-        }).catch((e) => {
-            if (e.name === 'VersionError') {
-                logger.warn("Crypto DB is too new for us to use!", e);
-                // don't fall back to a different store: the user has crypto data
-                // 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}`,
-            );
-
-            try {
-                return new LocalStorageCryptoStore(global.localStorage);
-            } catch (e) {
+        })
+            .then((backend) => {
+                // Edge has IndexedDB but doesn't support compund keys which we use fairly extensively.
+                // Try a dummy query which will fail if the browser doesn't support compund keys, so
+                // we can fall back to a different backend.
+                return backend
+                    .doTxn(
+                        "readonly",
+                        [
+                            IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS,
+                            IndexedDBCryptoStore.STORE_INBOUND_GROUP_SESSIONS_WITHHELD,
+                        ],
+                        (txn) => {
+                            backend.getEndToEndInboundGroupSession("", "", txn, () => {});
+                        },
+                    )
+                    .then(() => backend);
+            })
+            .catch((e) => {
+                if (e.name === "VersionError") {
+                    logger.warn("Crypto DB is too new for us to use!", e);
+                    // don't fall back to a different store: the user has crypto data
+                    // in this db so we should use it or nothing at all.
+                    throw new InvalidCryptoStoreError(InvalidCryptoStoreState.TooNew);
+                }
                 logger.warn(
-                    `unable to open localStorage: falling back to in-memory store: ${e}`,
+                    `unable to connect to indexeddb ${this.dbName}` + `: falling back to localStorage store: ${e}`,
                 );
-                return new MemoryCryptoStore();
-            }
-        }).then(backend => {
-            this.backend = backend;
-            return backend;
-        });
+
+                try {
+                    return new LocalStorageCryptoStore(global.localStorage);
+                } catch (e) {
+                    logger.warn(`unable to open localStorage: falling back to in-memory store: ${e}`);
+                    return new MemoryCryptoStore();
+                }
+            })
+            .then((backend) => {
+                this.backend = backend;
+                return backend;
+            });
 
         return this.backendPromise;
     }
@@ -168,7 +169,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
     public deleteAllData(): Promise<void> {
         return new Promise<void>((resolve, reject) => {
             if (!this.indexedDB) {
-                reject(new Error('no indexeddb support available'));
+                reject(new Error("no indexeddb support available"));
                 return;
             }
 
@@ -176,9 +177,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
             const req = this.indexedDB.deleteDatabase(this.dbName);
 
             req.onblocked = (): void => {
-                logger.log(
-                    `can't yet delete IndexedDBCryptoStore because it is open elsewhere`,
-                );
+                logger.log(`can't yet delete IndexedDBCryptoStore because it is open elsewhere`);
             };
 
             req.onerror = (ev): void => {
@@ -263,9 +262,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
         deviceId: string,
         wantedStates: number[],
     ): Promise<OutgoingRoomKeyRequest[]> {
-        return this.backend!.getOutgoingRoomKeyRequestsByTarget(
-            userId, deviceId, wantedStates,
-        );
+        return this.backend!.getOutgoingRoomKeyRequestsByTarget(userId, deviceId, wantedStates);
     }
 
     /**
@@ -285,9 +282,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
         expectedState: number,
         updates: Partial<OutgoingRoomKeyRequest>,
     ): Promise<OutgoingRoomKeyRequest | null> {
-        return this.backend!.updateOutgoingRoomKeyRequest(
-            requestId, expectedState, updates,
-        );
+        return this.backend!.updateOutgoingRoomKeyRequest(requestId, expectedState, updates);
     }
 
     /**
@@ -500,10 +495,7 @@ export class IndexedDBCryptoStore implements CryptoStore {
      *     in the store with an object having keys `{senderKey, sessionId, sessionData}`,
      *     then once with null to indicate the end of the list.
      */
-    public getAllEndToEndInboundGroupSessions(
-        txn: IDBTransaction,
-        func: (session: ISession | null) => void,
-    ): void {
+    public getAllEndToEndInboundGroupSessions(txn: IDBTransaction, func: (session: ISession | null) => void): void {
         this.backend!.getAllEndToEndInboundGroupSessions(txn, func);
     }
 
@@ -672,21 +664,14 @@ export class IndexedDBCryptoStore implements CryptoStore {
     /**
      * Park a shared-history group session for a room we may be invited to later.
      */
-    public addParkedSharedHistory(
-        roomId: string,
-        parkedData: ParkedSharedHistory,
-        txn?: IDBTransaction,
-    ): void {
+    public addParkedSharedHistory(roomId: string, parkedData: ParkedSharedHistory, txn?: IDBTransaction): void {
         this.backend!.addParkedSharedHistory(roomId, parkedData, txn);
     }
 
     /**
      * Pop out all shared-history group sessions for a room.
      */
-    public takeParkedSharedHistory(
-        roomId: string,
-        txn?: IDBTransaction,
-    ): Promise<ParkedSharedHistory[]> {
+    public takeParkedSharedHistory(roomId: string, txn?: IDBTransaction): Promise<ParkedSharedHistory[]> {
         return this.backend!.takeParkedSharedHistory(roomId, txn);
     }
 
diff --git a/src/crypto/store/localStorage-crypto-store.ts b/src/crypto/store/localStorage-crypto-store.ts
index 04815cf1576..1a9adfb25d1 100644
--- a/src/crypto/store/localStorage-crypto-store.ts
+++ b/src/crypto/store/localStorage-crypto-store.ts
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from '../../logger';
-import { MemoryCryptoStore } from './memory-crypto-store';
+import { logger } from "../../logger";
+import { MemoryCryptoStore } from "./memory-crypto-store";
 import { IDeviceData, IProblem, ISession, ISessionInfo, IWithheld, Mode, SecretStorePrivateKeys } from "./base";
 import { IOlmDevice } from "../algorithms/megolm";
 import { IRoomEncryption } from "../RoomList";
@@ -80,7 +80,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
     public countEndToEndSessions(txn: unknown, func: (count: number) => void): void {
         let count = 0;
         for (let i = 0; i < this.store.length; ++i) {
-            if (this.store.key(i)?.startsWith(keyEndToEndSessions(''))) ++count;
+            if (this.store.key(i)?.startsWith(keyEndToEndSessions(""))) ++count;
         }
         func(count);
     }
@@ -92,7 +92,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
 
         // fix up any old sessions to be objects rather than just the base64 pickle
         for (const [sid, val] of Object.entries(sessions || {})) {
-            if (typeof val === 'string') {
+            if (typeof val === "string") {
                 fixedSessions[sid] = {
                     session: val,
                 };
@@ -124,8 +124,8 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
 
     public getAllEndToEndSessions(txn: unknown, func: (session: ISessionInfo) => void): void {
         for (let i = 0; i < this.store.length; ++i) {
-            if (this.store.key(i)?.startsWith(keyEndToEndSessions(''))) {
-                const deviceKey = this.store.key(i)!.split('/')[1];
+            if (this.store.key(i)?.startsWith(keyEndToEndSessions(""))) {
+                const deviceKey = this.store.key(i)!.split("/")[1];
                 for (const sess of Object.values(this._getEndToEndSessions(deviceKey))) {
                     func(sess);
                 }
@@ -169,9 +169,8 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
     }
 
     public async filterOutNotifiedErrorDevices(devices: IOlmDevice[]): Promise<IOlmDevice[]> {
-        const notifiedErrorDevices = getJsonItem<MemoryCryptoStore["notifiedErrorDevices"]>(
-            this.store, KEY_NOTIFIED_ERROR_DEVICES,
-        ) || {};
+        const notifiedErrorDevices =
+            getJsonItem<MemoryCryptoStore["notifiedErrorDevices"]>(this.store, KEY_NOTIFIED_ERROR_DEVICES) || {};
         const ret: IOlmDevice[] = [];
 
         for (const device of devices) {
@@ -201,14 +200,8 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
         func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
     ): void {
         func(
-            getJsonItem(
-                this.store,
-                keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId),
-            ),
-            getJsonItem(
-                this.store,
-                keyEndToEndInboundGroupSessionWithheld(senderCurve25519Key, sessionId),
-            ),
+            getJsonItem(this.store, keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId)),
+            getJsonItem(this.store, keyEndToEndInboundGroupSessionWithheld(senderCurve25519Key, sessionId)),
         );
     }
 
@@ -237,14 +230,9 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
         sessionData: InboundGroupSessionData,
         txn: unknown,
     ): void {
-        const existing = getJsonItem(
-            this.store,
-            keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId),
-        );
+        const existing = getJsonItem(this.store, keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId));
         if (!existing) {
-            this.storeEndToEndInboundGroupSession(
-                senderCurve25519Key, sessionId, sessionData, txn,
-            );
+            this.storeEndToEndInboundGroupSession(senderCurve25519Key, sessionId, sessionData, txn);
         }
     }
 
@@ -254,11 +242,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
         sessionData: InboundGroupSessionData,
         txn: unknown,
     ): void {
-        setJsonItem(
-            this.store,
-            keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId),
-            sessionData,
-        );
+        setJsonItem(this.store, keyEndToEndInboundGroupSession(senderCurve25519Key, sessionId), sessionData);
     }
 
     public storeEndToEndInboundGroupSessionWithheld(
@@ -267,11 +251,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
         sessionData: IWithheld,
         txn: unknown,
     ): void {
-        setJsonItem(
-            this.store,
-            keyEndToEndInboundGroupSessionWithheld(senderCurve25519Key, sessionId),
-            sessionData,
-        );
+        setJsonItem(this.store, keyEndToEndInboundGroupSessionWithheld(senderCurve25519Key, sessionId), sessionData);
     }
 
     public getEndToEndDeviceData(txn: unknown, func: (deviceData: IDeviceData | null) => void): void {
@@ -288,7 +268,7 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
 
     public getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void {
         const result: Record<string, IRoomEncryption> = {};
-        const prefix = keyEndToEndRoomsPrefix('');
+        const prefix = keyEndToEndRoomsPrefix("");
 
         for (let i = 0; i < this.store.length; ++i) {
             const key = this.store.key(i);
@@ -309,16 +289,13 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
                 // see getAllEndToEndInboundGroupSessions for the magic number explanations
                 const senderKey = session.slice(0, 43);
                 const sessionId = session.slice(44);
-                this.getEndToEndInboundGroupSession(
-                    senderKey, sessionId, null,
-                    (sessionData) => {
-                        sessions.push({
-                            senderKey: senderKey,
-                            sessionId: sessionId,
-                            sessionData: sessionData!,
-                        });
-                    },
-                );
+                this.getEndToEndInboundGroupSession(senderKey, sessionId, null, (sessionData) => {
+                    sessions.push({
+                        senderKey: senderKey,
+                        sessionId: sessionId,
+                        sessionData: sessionData!,
+                    });
+                });
                 if (limit && sessions.length >= limit) {
                     break;
                 }
@@ -333,26 +310,26 @@ export class LocalStorageCryptoStore extends MemoryCryptoStore {
     }
 
     public unmarkSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
-        const sessionsNeedingBackup = getJsonItem<{
-            [senderKeySessionId: string]: string;
-        }>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
+        const sessionsNeedingBackup =
+            getJsonItem<{
+                [senderKeySessionId: string]: string;
+            }>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
         for (const session of sessions) {
-            delete sessionsNeedingBackup[session.senderKey + '/' + session.sessionId];
+            delete sessionsNeedingBackup[session.senderKey + "/" + session.sessionId];
         }
         setJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP, sessionsNeedingBackup);
         return Promise.resolve();
     }
 
     public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
-        const sessionsNeedingBackup = getJsonItem<{
-            [senderKeySessionId: string]: boolean;
-        }>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
+        const sessionsNeedingBackup =
+            getJsonItem<{
+                [senderKeySessionId: string]: boolean;
+            }>(this.store, KEY_SESSIONS_NEEDING_BACKUP) || {};
         for (const session of sessions) {
-            sessionsNeedingBackup[session.senderKey + '/' + session.sessionId] = true;
+            sessionsNeedingBackup[session.senderKey + "/" + session.sessionId] = true;
         }
-        setJsonItem(
-            this.store, KEY_SESSIONS_NEEDING_BACKUP, sessionsNeedingBackup,
-        );
+        setJsonItem(this.store, KEY_SESSIONS_NEEDING_BACKUP, sessionsNeedingBackup);
         return Promise.resolve();
     }
 
diff --git a/src/crypto/store/memory-crypto-store.ts b/src/crypto/store/memory-crypto-store.ts
index 701f85fc30a..ad779ca993b 100644
--- a/src/crypto/store/memory-crypto-store.ts
+++ b/src/crypto/store/memory-crypto-store.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from '../../logger';
+import { logger } from "../../logger";
 import * as utils from "../../utils";
 import {
     CryptoStore,
@@ -25,7 +25,8 @@ import {
     IWithheld,
     Mode,
     OutgoingRoomKeyRequest,
-    ParkedSharedHistory, SecretStorePrivateKeys,
+    ParkedSharedHistory,
+    SecretStorePrivateKeys,
 } from "./base";
 import { IRoomKeyRequestBody } from "../index";
 import { ICrossSigningKey } from "../../client";
@@ -96,18 +97,15 @@ export class MemoryCryptoStore implements CryptoStore {
                 // this entry matches the request - return it.
                 logger.log(
                     `already have key request outstanding for ` +
-                    `${requestBody.room_id} / ${requestBody.session_id}: ` +
-                    `not sending another`,
+                        `${requestBody.room_id} / ${requestBody.session_id}: ` +
+                        `not sending another`,
                 );
                 return existing;
             }
 
             // we got to the end of the list without finding a match
             // - add the new request.
-            logger.log(
-                `enqueueing key request for ${requestBody.room_id} / ` +
-                requestBody.session_id,
-            );
+            logger.log(`enqueueing key request for ${requestBody.room_id} / ` + requestBody.session_id);
             this.outgoingRoomKeyRequests.push(request);
             return request;
         });
@@ -171,11 +169,7 @@ export class MemoryCryptoStore implements CryptoStore {
      * @returns All OutgoingRoomKeyRequests in state
      */
     public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
-        return Promise.resolve(
-            this.outgoingRoomKeyRequests.filter(
-                (r) => r.state == wantedState,
-            ),
-        );
+        return Promise.resolve(this.outgoingRoomKeyRequests.filter((r) => r.state == wantedState));
     }
 
     public getOutgoingRoomKeyRequestsByTarget(
@@ -187,9 +181,10 @@ export class MemoryCryptoStore implements CryptoStore {
 
         for (const req of this.outgoingRoomKeyRequests) {
             for (const state of wantedStates) {
-                if (req.state === state && req.recipients.some(
-                    (recipient) => recipient.userId === userId && recipient.deviceId === deviceId,
-                )) {
+                if (
+                    req.state === state &&
+                    req.recipients.some((recipient) => recipient.userId === userId && recipient.deviceId === deviceId)
+                ) {
                     results.push(req);
                 }
             }
@@ -222,7 +217,7 @@ export class MemoryCryptoStore implements CryptoStore {
             if (req.state !== expectedState) {
                 logger.warn(
                     `Cannot update room key request from ${expectedState} ` +
-                    `as it was already updated to ${req.state}`,
+                        `as it was already updated to ${req.state}`,
                 );
                 return Promise.resolve(null);
             }
@@ -254,10 +249,7 @@ export class MemoryCryptoStore implements CryptoStore {
             }
 
             if (req.state != expectedState) {
-                logger.warn(
-                    `Cannot delete room key request in state ${req.state} `
-                    + `(expected ${expectedState})`,
-                );
+                logger.warn(`Cannot delete room key request in state ${req.state} ` + `(expected ${expectedState})`);
                 return Promise.resolve(null);
             }
 
@@ -349,7 +341,7 @@ export class MemoryCryptoStore implements CryptoStore {
     }
 
     public async storeEndToEndSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void> {
-        const problems = this.sessionProblems[deviceKey] = this.sessionProblems[deviceKey] || [];
+        const problems = (this.sessionProblems[deviceKey] = this.sessionProblems[deviceKey] || []);
         problems.push({ type, fixed, time: Date.now() });
         problems.sort((a, b) => {
             return a.time - b.time;
@@ -402,17 +394,11 @@ export class MemoryCryptoStore implements CryptoStore {
         txn: unknown,
         func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
     ): void {
-        const k = senderCurve25519Key+'/'+sessionId;
-        func(
-            this.inboundGroupSessions[k] || null,
-            this.inboundGroupSessionsWithheld[k] || null,
-        );
+        const k = senderCurve25519Key + "/" + sessionId;
+        func(this.inboundGroupSessions[k] || null, this.inboundGroupSessionsWithheld[k] || null);
     }
 
-    public getAllEndToEndInboundGroupSessions(
-        txn: unknown,
-        func: (session: ISession | null) => void,
-    ): void {
+    public getAllEndToEndInboundGroupSessions(txn: unknown, func: (session: ISession | null) => void): void {
         for (const key of Object.keys(this.inboundGroupSessions)) {
             // we can't use split, as the components we are trying to split out
             // might themselves contain '/' characters. We rely on the
@@ -434,7 +420,7 @@ export class MemoryCryptoStore implements CryptoStore {
         sessionData: InboundGroupSessionData,
         txn: unknown,
     ): void {
-        const k = senderCurve25519Key+'/'+sessionId;
+        const k = senderCurve25519Key + "/" + sessionId;
         if (this.inboundGroupSessions[k] === undefined) {
             this.inboundGroupSessions[k] = sessionData;
         }
@@ -446,7 +432,7 @@ export class MemoryCryptoStore implements CryptoStore {
         sessionData: InboundGroupSessionData,
         txn: unknown,
     ): void {
-        this.inboundGroupSessions[senderCurve25519Key+'/'+sessionId] = sessionData;
+        this.inboundGroupSessions[senderCurve25519Key + "/" + sessionId] = sessionData;
     }
 
     public storeEndToEndInboundGroupSessionWithheld(
@@ -455,7 +441,7 @@ export class MemoryCryptoStore implements CryptoStore {
         sessionData: IWithheld,
         txn: unknown,
     ): void {
-        const k = senderCurve25519Key+'/'+sessionId;
+        const k = senderCurve25519Key + "/" + sessionId;
         this.inboundGroupSessionsWithheld[k] = sessionData;
     }
 
@@ -502,7 +488,7 @@ export class MemoryCryptoStore implements CryptoStore {
 
     public unmarkSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
         for (const session of sessions) {
-            const sessionKey = session.senderKey + '/' + session.sessionId;
+            const sessionKey = session.senderKey + "/" + session.sessionId;
             delete this.sessionsNeedingBackup[sessionKey];
         }
         return Promise.resolve();
@@ -510,7 +496,7 @@ export class MemoryCryptoStore implements CryptoStore {
 
     public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
         for (const session of sessions) {
-            const sessionKey = session.senderKey + '/' + session.sessionId;
+            const sessionKey = session.senderKey + "/" + session.sessionId;
             this.sessionsNeedingBackup[sessionKey] = true;
         }
         return Promise.resolve();
diff --git a/src/crypto/verification/Base.ts b/src/crypto/verification/Base.ts
index f2644b55708..89c700c231c 100644
--- a/src/crypto/verification/Base.ts
+++ b/src/crypto/verification/Base.ts
@@ -19,10 +19,10 @@ limitations under the License.
  * Base class for verification methods.
  */
 
-import { MatrixEvent } from '../../models/event';
-import { EventType } from '../../@types/event';
-import { logger } from '../../logger';
-import { DeviceInfo } from '../deviceinfo';
+import { MatrixEvent } from "../../models/event";
+import { EventType } from "../../@types/event";
+import { logger } from "../../logger";
+import { DeviceInfo } from "../deviceinfo";
 import { newTimeoutError } from "./Error";
 import { KeysDuringVerification, requestKeysDuringVerification } from "../CrossSigning";
 import { IVerificationChannel } from "./request/Channel";
@@ -108,8 +108,7 @@ export class VerificationBase<
         }
         const sender = this.startEvent.getSender();
         const content = this.startEvent.getContent();
-        return sender === this.baseApis.getUserId() &&
-            content.from_device === this.baseApis.getDeviceId();
+        return sender === this.baseApis.getUserId() && content.from_device === this.baseApis.getDeviceId();
     }
 
     public get hasBeenCancelled(): boolean {
@@ -162,8 +161,7 @@ export class VerificationBase<
 
     public switchStartEvent(event: MatrixEvent): void {
         if (this.canSwitchStartEvent(event)) {
-            logger.log("Verification Base: switching verification start event",
-                { restartingFlow: !!this.rejectEvent });
+            logger.log("Verification Base: switching verification start event", { restartingFlow: !!this.rejectEvent });
             if (this.rejectEvent) {
                 const reject = this.rejectEvent;
                 this.rejectEvent = undefined;
@@ -193,8 +191,7 @@ export class VerificationBase<
             if (reject) {
                 const content = e.getContent();
                 const { reason, code } = content;
-                reject(new Error(`Other side cancelled verification ` +
-                    `because ${reason} (${code})`));
+                reject(new Error(`Other side cancelled verification ` + `because ${reason} (${code})`));
             }
         } else if (this.expectedEvent) {
             // only cancel if there is an event expected.
@@ -202,8 +199,7 @@ export class VerificationBase<
             // and we're just replaying the timeline events when syncing
             // after a refresh when the events haven't been stored in the cache yet.
             const exception = new Error(
-                "Unexpected message: expecting " + this.expectedEvent
-                    + " but got " + e.getType(),
+                "Unexpected message: expecting " + this.expectedEvent + " but got " + e.getType(),
             );
             this.expectedEvent = undefined;
             if (this.rejectEvent) {
@@ -241,8 +237,7 @@ export class VerificationBase<
                         const content = e.getContent();
                         if (e.getType() === EventType.KeyVerificationCancel) {
                             content.code = content.code || "m.unknown";
-                            content.reason = content.reason || content.body
-                                || "Unknown reason";
+                            content.reason = content.reason || content.body || "Unknown reason";
                             this.send(EventType.KeyVerificationCancel, content);
                         } else {
                             this.send(EventType.KeyVerificationCancel, {
@@ -303,7 +298,9 @@ export class VerificationBase<
                     reject(new Error("Device ID is the same as the cross-signing ID"));
                 }
                 resolve();
-            }).then(() => this.doVerification!()).then(this.done.bind(this), this.cancel.bind(this));
+            })
+                .then(() => this.doVerification!())
+                .then(this.done.bind(this), this.cancel.bind(this));
         }
         return this.promise;
     }
@@ -317,7 +314,7 @@ export class VerificationBase<
         const verifiedDevices: [string, string, string][] = [];
 
         for (const [keyId, keyInfo] of Object.entries(keys)) {
-            const deviceId = keyId.split(':', 2)[1];
+            const deviceId = keyId.split(":", 2)[1];
             const device = this.baseApis.getStoredDevice(userId, deviceId);
             if (device) {
                 verifier(keyId, device, keyInfo);
@@ -325,16 +322,21 @@ export class VerificationBase<
             } else {
                 const crossSigningInfo = this.baseApis.crypto!.deviceList.getStoredCrossSigningForUser(userId);
                 if (crossSigningInfo && crossSigningInfo.getId() === deviceId) {
-                    verifier(keyId, DeviceInfo.fromStorage({
-                        keys: {
-                            [keyId]: deviceId,
-                        },
-                    }, deviceId), keyInfo);
+                    verifier(
+                        keyId,
+                        DeviceInfo.fromStorage(
+                            {
+                                keys: {
+                                    [keyId]: deviceId,
+                                },
+                            },
+                            deviceId,
+                        ),
+                        keyInfo,
+                    );
                     verifiedDevices.push([deviceId, keyId, deviceId]);
                 } else {
-                    logger.warn(
-                        `verification: Could not find device ${deviceId} to verify`,
-                    );
+                    logger.warn(`verification: Could not find device ${deviceId} to verify`);
                 }
             }
         }
@@ -345,10 +347,7 @@ export class VerificationBase<
             throw new Error("No devices could be verified");
         }
 
-        logger.info(
-            "Verification completed! Marking devices verified: ",
-            verifiedDevices,
-        );
+        logger.info("Verification completed! Marking devices verified: ", verifiedDevices);
         // TODO: There should probably be a batch version of this, otherwise it's going
         // to upload each signature in a separate API call which is silly because the
         // API supports as many signatures as you like.
diff --git a/src/crypto/verification/Error.ts b/src/crypto/verification/Error.ts
index 0ad50b2ff26..da73ebb847e 100644
--- a/src/crypto/verification/Error.ts
+++ b/src/crypto/verification/Error.ts
@@ -19,7 +19,7 @@ limitations under the License.
  */
 
 import { MatrixEvent } from "../../models/event";
-import { EventType } from '../../@types/event';
+import { EventType } from "../../@types/event";
 
 export function newVerificationError(code: string, reason: string, extraData?: Record<string, any>): MatrixEvent {
     const content = Object.assign({}, { code, reason }, extraData);
@@ -30,7 +30,7 @@ export function newVerificationError(code: string, reason: string, extraData?: R
 }
 
 export function errorFactory(code: string, reason: string): (extraData?: Record<string, any>) => MatrixEvent {
-    return function(extraData?: Record<string, any>) {
+    return function (extraData?: Record<string, any>) {
         return newVerificationError(code, reason, extraData);
     };
 }
@@ -53,25 +53,19 @@ export const newUnknownMethodError = errorFactory("m.unknown_method", "Unknown m
 /**
  * An unexpected message was sent.
  */
-export const newUnexpectedMessageError = errorFactory(
-    "m.unexpected_message", "Unexpected message",
-);
+export const newUnexpectedMessageError = errorFactory("m.unexpected_message", "Unexpected message");
 
 /**
  * The key does not match.
  */
-export const newKeyMismatchError = errorFactory(
-    "m.key_mismatch", "Key mismatch",
-);
+export const newKeyMismatchError = errorFactory("m.key_mismatch", "Key mismatch");
 
 /**
  * An invalid message was sent.
  */
-export const newInvalidMessageError = errorFactory(
-    "m.invalid_message", "Invalid message",
-);
+export const newInvalidMessageError = errorFactory("m.invalid_message", "Invalid message");
 
-export function errorFromEvent(event: MatrixEvent): { code: string, reason: string } {
+export function errorFromEvent(event: MatrixEvent): { code: string; reason: string } {
     const content = event.getContent();
     if (content) {
         const { code, reason } = content;
diff --git a/src/crypto/verification/QRCode.ts b/src/crypto/verification/QRCode.ts
index c5c2735bc58..bfb532e4223 100644
--- a/src/crypto/verification/QRCode.ts
+++ b/src/crypto/verification/QRCode.ts
@@ -19,9 +19,9 @@ limitations under the License.
  */
 
 import { VerificationBase as Base, VerificationEventHandlerMap } from "./Base";
-import { newKeyMismatchError, newUserCancelledError } from './Error';
+import { newKeyMismatchError, newUserCancelledError } from "./Error";
 import { decodeBase64, encodeUnpaddedBase64 } from "../olmlib";
-import { logger } from '../../logger';
+import { logger } from "../../logger";
 import { VerificationRequest } from "./request/VerificationRequest";
 import { MatrixClient } from "../../client";
 import { IVerificationChannel } from "./request/Channel";
@@ -65,13 +65,12 @@ export class ReciprocateQRCode extends Base<QrCodeEvent, EventHandlerMap> {
     protected doVerification = async (): Promise<void> => {
         if (!this.startEvent) {
             // TODO: Support scanning QR codes
-            throw new Error("It is not currently possible to start verification" +
-                "with this method yet.");
+            throw new Error("It is not currently possible to start verification" + "with this method yet.");
         }
 
         const { qrCodeData } = this.request;
         // 1. check the secret
-        if (this.startEvent.getContent()['secret'] !== qrCodeData?.encodedSharedSecret) {
+        if (this.startEvent.getContent()["secret"] !== qrCodeData?.encodedSharedSecret) {
             throw newKeyMismatchError();
         }
 
@@ -250,8 +249,8 @@ export class QRCodeData {
             version: CODE_VERSION,
             mode,
             transactionId,
-            firstKeyB64: '', // worked out shortly
-            secondKeyB64: '', // worked out shortly
+            firstKeyB64: "", // worked out shortly
+            secondKeyB64: "", // worked out shortly
             secretB64: encodedSharedSecret,
         };
 
diff --git a/src/crypto/verification/SAS.ts b/src/crypto/verification/SAS.ts
index 9d831f5c668..4c05f53549d 100644
--- a/src/crypto/verification/SAS.ts
+++ b/src/crypto/verification/SAS.ts
@@ -18,7 +18,7 @@ limitations under the License.
  * Short Authentication String (SAS) verification.
  */
 
-import anotherjson from 'another-json';
+import anotherjson from "another-json";
 import { Utility, SAS as OlmSAS } from "@matrix-org/olm";
 
 import { VerificationBase as Base, SwitchStartEventError, VerificationEventHandlerMap } from "./Base";
@@ -28,109 +28,101 @@ import {
     newKeyMismatchError,
     newUnknownMethodError,
     newUserCancelledError,
-} from './Error';
-import { logger } from '../../logger';
+} from "./Error";
+import { logger } from "../../logger";
 import { IContent, MatrixEvent } from "../../models/event";
-import { generateDecimalSas } from './SASDecimal';
-import { EventType } from '../../@types/event';
+import { generateDecimalSas } from "./SASDecimal";
+import { EventType } from "../../@types/event";
 
 const START_TYPE = EventType.KeyVerificationStart;
 
-const EVENTS = [
-    EventType.KeyVerificationAccept,
-    EventType.KeyVerificationKey,
-    EventType.KeyVerificationMac,
-];
+const EVENTS = [EventType.KeyVerificationAccept, EventType.KeyVerificationKey, EventType.KeyVerificationMac];
 
 let olmutil: Utility;
 
-const newMismatchedSASError = errorFactory(
-    "m.mismatched_sas", "Mismatched short authentication string",
-);
+const newMismatchedSASError = errorFactory("m.mismatched_sas", "Mismatched short authentication string");
 
-const newMismatchedCommitmentError = errorFactory(
-    "m.mismatched_commitment", "Mismatched commitment",
-);
+const newMismatchedCommitmentError = errorFactory("m.mismatched_commitment", "Mismatched commitment");
 
 type EmojiMapping = [emoji: string, name: string];
 
 const emojiMapping: EmojiMapping[] = [
-    ["🐶", "dog"],        //  0
-    ["🐱", "cat"],        //  1
-    ["🦁", "lion"],       //  2
-    ["🐎", "horse"],      //  3
-    ["🦄", "unicorn"],    //  4
-    ["🐷", "pig"],        //  5
-    ["🐘", "elephant"],   //  6
-    ["🐰", "rabbit"],     //  7
-    ["🐼", "panda"],      //  8
-    ["🐓", "rooster"],    //  9
-    ["🐧", "penguin"],    // 10
-    ["🐢", "turtle"],     // 11
-    ["🐟", "fish"],       // 12
-    ["🐙", "octopus"],    // 13
-    ["🦋", "butterfly"],  // 14
-    ["🌷", "flower"],     // 15
-    ["🌳", "tree"],       // 16
-    ["🌵", "cactus"],     // 17
-    ["🍄", "mushroom"],   // 18
-    ["🌏", "globe"],      // 19
-    ["🌙", "moon"],       // 20
-    ["☁️", "cloud"],       // 21
-    ["🔥", "fire"],       // 22
-    ["🍌", "banana"],     // 23
-    ["🍎", "apple"],      // 24
+    ["🐶", "dog"], //  0
+    ["🐱", "cat"], //  1
+    ["🦁", "lion"], //  2
+    ["🐎", "horse"], //  3
+    ["🦄", "unicorn"], //  4
+    ["🐷", "pig"], //  5
+    ["🐘", "elephant"], //  6
+    ["🐰", "rabbit"], //  7
+    ["🐼", "panda"], //  8
+    ["🐓", "rooster"], //  9
+    ["🐧", "penguin"], // 10
+    ["🐢", "turtle"], // 11
+    ["🐟", "fish"], // 12
+    ["🐙", "octopus"], // 13
+    ["🦋", "butterfly"], // 14
+    ["🌷", "flower"], // 15
+    ["🌳", "tree"], // 16
+    ["🌵", "cactus"], // 17
+    ["🍄", "mushroom"], // 18
+    ["🌏", "globe"], // 19
+    ["🌙", "moon"], // 20
+    ["☁️", "cloud"], // 21
+    ["🔥", "fire"], // 22
+    ["🍌", "banana"], // 23
+    ["🍎", "apple"], // 24
     ["🍓", "strawberry"], // 25
-    ["🌽", "corn"],       // 26
-    ["🍕", "pizza"],      // 27
-    ["🎂", "cake"],       // 28
-    ["❤️", "heart"],      // 29
-    ["🙂", "smiley"],      // 30
-    ["🤖", "robot"],      // 31
-    ["🎩", "hat"],        // 32
-    ["👓", "glasses"],    // 33
-    ["🔧", "spanner"],     // 34
-    ["🎅", "santa"],      // 35
-    ["👍", "thumbs up"],  // 36
-    ["☂️", "umbrella"],    // 37
-    ["⌛", "hourglass"],   // 38
-    ["⏰", "clock"],      // 39
-    ["🎁", "gift"],       // 40
+    ["🌽", "corn"], // 26
+    ["🍕", "pizza"], // 27
+    ["🎂", "cake"], // 28
+    ["❤️", "heart"], // 29
+    ["🙂", "smiley"], // 30
+    ["🤖", "robot"], // 31
+    ["🎩", "hat"], // 32
+    ["👓", "glasses"], // 33
+    ["🔧", "spanner"], // 34
+    ["🎅", "santa"], // 35
+    ["👍", "thumbs up"], // 36
+    ["☂️", "umbrella"], // 37
+    ["⌛", "hourglass"], // 38
+    ["⏰", "clock"], // 39
+    ["🎁", "gift"], // 40
     ["💡", "light bulb"], // 41
-    ["📕", "book"],       // 42
-    ["✏️", "pencil"],     // 43
-    ["📎", "paperclip"],  // 44
-    ["✂️", "scissors"],    // 45
-    ["🔒", "lock"],       // 46
-    ["🔑", "key"],        // 47
-    ["🔨", "hammer"],     // 48
-    ["☎️", "telephone"],  // 49
-    ["🏁", "flag"],       // 50
-    ["🚂", "train"],      // 51
-    ["🚲", "bicycle"],    // 52
-    ["✈️", "aeroplane"],   // 53
-    ["🚀", "rocket"],     // 54
-    ["🏆", "trophy"],     // 55
-    ["⚽", "ball"],       // 56
-    ["🎸", "guitar"],     // 57
-    ["🎺", "trumpet"],    // 58
-    ["🔔", "bell"],       // 59
-    ["⚓️", "anchor"],     // 60
+    ["📕", "book"], // 42
+    ["✏️", "pencil"], // 43
+    ["📎", "paperclip"], // 44
+    ["✂️", "scissors"], // 45
+    ["🔒", "lock"], // 46
+    ["🔑", "key"], // 47
+    ["🔨", "hammer"], // 48
+    ["☎️", "telephone"], // 49
+    ["🏁", "flag"], // 50
+    ["🚂", "train"], // 51
+    ["🚲", "bicycle"], // 52
+    ["✈️", "aeroplane"], // 53
+    ["🚀", "rocket"], // 54
+    ["🏆", "trophy"], // 55
+    ["⚽", "ball"], // 56
+    ["🎸", "guitar"], // 57
+    ["🎺", "trumpet"], // 58
+    ["🔔", "bell"], // 59
+    ["⚓️", "anchor"], // 60
     ["🎧", "headphones"], // 61
-    ["📁", "folder"],     // 62
-    ["📌", "pin"],        // 63
+    ["📁", "folder"], // 62
+    ["📌", "pin"], // 63
 ];
 
 function generateEmojiSas(sasBytes: number[]): EmojiMapping[] {
     const emojis = [
         // just like base64 encoding
         sasBytes[0] >> 2,
-        (sasBytes[0] & 0x3) << 4 | sasBytes[1] >> 4,
-        (sasBytes[1] & 0xf) << 2 | sasBytes[2] >> 6,
+        ((sasBytes[0] & 0x3) << 4) | (sasBytes[1] >> 4),
+        ((sasBytes[1] & 0xf) << 2) | (sasBytes[2] >> 6),
         sasBytes[2] & 0x3f,
         sasBytes[3] >> 2,
-        (sasBytes[3] & 0x3) << 4 | sasBytes[4] >> 4,
-        (sasBytes[4] & 0xf) << 2 | sasBytes[5] >> 6,
+        ((sasBytes[3] & 0x3) << 4) | (sasBytes[4] >> 4),
+        ((sasBytes[4] & 0xf) << 2) | (sasBytes[5] >> 6),
     ];
 
     return emojis.map((num) => emojiMapping[num]);
@@ -173,7 +165,7 @@ const macMethods = {
 type MacMethod = keyof typeof macMethods;
 
 function calculateMAC(olmSAS: OlmSAS, method: MacMethod) {
-    return function(input: string, info: string): string {
+    return function (input: string, info: string): string {
         const mac = olmSAS[macMethods[method]](input, info);
         logger.log("SAS calculateMAC:", method, [input, info], mac);
         return mac;
@@ -182,23 +174,22 @@ function calculateMAC(olmSAS: OlmSAS, method: MacMethod) {
 
 const calculateKeyAgreement = {
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    "curve25519-hkdf-sha256": function(sas: SAS, olmSAS: OlmSAS, bytes: number): Uint8Array {
-        const ourInfo = `${sas.baseApis.getUserId()}|${sas.baseApis.deviceId}|`
-              + `${sas.ourSASPubKey}|`;
+    "curve25519-hkdf-sha256": function (sas: SAS, olmSAS: OlmSAS, bytes: number): Uint8Array {
+        const ourInfo = `${sas.baseApis.getUserId()}|${sas.baseApis.deviceId}|` + `${sas.ourSASPubKey}|`;
         const theirInfo = `${sas.userId}|${sas.deviceId}|${sas.theirSASPubKey}|`;
         const sasInfo =
-            "MATRIX_KEY_VERIFICATION_SAS|"
-              + (sas.initiatedByMe ? ourInfo + theirInfo : theirInfo + ourInfo)
-              + sas.channel.transactionId;
+            "MATRIX_KEY_VERIFICATION_SAS|" +
+            (sas.initiatedByMe ? ourInfo + theirInfo : theirInfo + ourInfo) +
+            sas.channel.transactionId;
         return olmSAS.generate_bytes(sasInfo, bytes);
     },
-    "curve25519": function(sas: SAS, olmSAS: OlmSAS, bytes: number): Uint8Array {
+    "curve25519": function (sas: SAS, olmSAS: OlmSAS, bytes: number): Uint8Array {
         const ourInfo = `${sas.baseApis.getUserId()}${sas.baseApis.deviceId}`;
         const theirInfo = `${sas.userId}${sas.deviceId}`;
         const sasInfo =
-            "MATRIX_KEY_VERIFICATION_SAS"
-              + (sas.initiatedByMe ? ourInfo + theirInfo : theirInfo + ourInfo)
-              + sas.channel.transactionId;
+            "MATRIX_KEY_VERIFICATION_SAS" +
+            (sas.initiatedByMe ? ourInfo + theirInfo : theirInfo + ourInfo) +
+            sas.channel.transactionId;
         return olmSAS.generate_bytes(sasInfo, bytes);
     },
 } as const;
@@ -220,7 +211,7 @@ const MAC_SET = new Set(MAC_LIST);
 const SAS_SET = new Set(SAS_LIST);
 
 function intersection<T>(anArray: T[], aSet: Set<T>): T[] {
-    return Array.isArray(anArray) ? anArray.filter(x => aSet.has(x)) : [];
+    return Array.isArray(anArray) ? anArray.filter((x) => aSet.has(x)) : [];
 }
 
 export enum SasEvent {
@@ -320,14 +311,13 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
         });
 
         const [e] = await Promise.all([
-            this.waitForEvent(EventType.KeyVerificationMac)
-                .then((e) => {
-                    // we don't expect any more messages from the other
-                    // party, and they may send a m.key.verification.done
-                    // when they're done on their end
-                    this.expectedEvent = EventType.KeyVerificationDone;
-                    return e;
-                }),
+            this.waitForEvent(EventType.KeyVerificationMac).then((e) => {
+                // we don't expect any more messages from the other
+                // party, and they may send a m.key.verification.done
+                // when they're done on their end
+                this.expectedEvent = EventType.KeyVerificationDone;
+                return e;
+            }),
             verifySAS,
         ]);
         const content = e.getContent();
@@ -358,12 +348,15 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
             this.waitingForAccept = false;
         }
         let content = e.getContent();
-        const sasMethods
-              = intersection(content.short_authentication_string, SAS_SET);
-        if (!(KEY_AGREEMENT_SET.has(content.key_agreement_protocol)
-              && HASHES_SET.has(content.hash)
-              && MAC_SET.has(content.message_authentication_code)
-              && sasMethods.length)) {
+        const sasMethods = intersection(content.short_authentication_string, SAS_SET);
+        if (
+            !(
+                KEY_AGREEMENT_SET.has(content.key_agreement_protocol) &&
+                HASHES_SET.has(content.hash) &&
+                MAC_SET.has(content.message_authentication_code) &&
+                sasMethods.length
+            )
+        ) {
             throw newUnknownMethodError();
         }
         if (typeof content.commitment !== "string") {
@@ -445,53 +438,47 @@ export class SAS extends Base<SasEvent, EventHandlerMap> {
     private sendMAC(olmSAS: OlmSAS, method: MacMethod): Promise<void> {
         const mac: Record<string, string> = {};
         const keyList: string[] = [];
-        const baseInfo = "MATRIX_KEY_VERIFICATION_MAC"
-              + this.baseApis.getUserId() + this.baseApis.deviceId
-              + this.userId + this.deviceId
-              + this.channel.transactionId;
+        const baseInfo =
+            "MATRIX_KEY_VERIFICATION_MAC" +
+            this.baseApis.getUserId() +
+            this.baseApis.deviceId +
+            this.userId +
+            this.deviceId +
+            this.channel.transactionId;
 
         const deviceKeyId = `ed25519:${this.baseApis.deviceId}`;
-        mac[deviceKeyId] = calculateMAC(olmSAS, method)(
-            this.baseApis.getDeviceEd25519Key()!,
-            baseInfo + deviceKeyId,
-        );
+        mac[deviceKeyId] = calculateMAC(olmSAS, method)(this.baseApis.getDeviceEd25519Key()!, baseInfo + deviceKeyId);
         keyList.push(deviceKeyId);
 
         const crossSigningId = this.baseApis.getCrossSigningId();
         if (crossSigningId) {
             const crossSigningKeyId = `ed25519:${crossSigningId}`;
-            mac[crossSigningKeyId] = calculateMAC(olmSAS, method)(
-                crossSigningId,
-                baseInfo + crossSigningKeyId,
-            );
+            mac[crossSigningKeyId] = calculateMAC(olmSAS, method)(crossSigningId, baseInfo + crossSigningKeyId);
             keyList.push(crossSigningKeyId);
         }
 
-        const keys = calculateMAC(olmSAS, method)(
-            keyList.sort().join(","),
-            baseInfo + "KEY_IDS",
-        );
+        const keys = calculateMAC(olmSAS, method)(keyList.sort().join(","), baseInfo + "KEY_IDS");
         return this.send(EventType.KeyVerificationMac, { mac, keys });
     }
 
     private async checkMAC(olmSAS: OlmSAS, content: IContent, method: MacMethod): Promise<void> {
-        const baseInfo = "MATRIX_KEY_VERIFICATION_MAC"
-              + this.userId + this.deviceId
-              + this.baseApis.getUserId() + this.baseApis.deviceId
-              + this.channel.transactionId;
-
-        if (content.keys !== calculateMAC(olmSAS, method)(
-            Object.keys(content.mac).sort().join(","),
-            baseInfo + "KEY_IDS",
-        )) {
+        const baseInfo =
+            "MATRIX_KEY_VERIFICATION_MAC" +
+            this.userId +
+            this.deviceId +
+            this.baseApis.getUserId() +
+            this.baseApis.deviceId +
+            this.channel.transactionId;
+
+        if (
+            content.keys !==
+            calculateMAC(olmSAS, method)(Object.keys(content.mac).sort().join(","), baseInfo + "KEY_IDS")
+        ) {
             throw newKeyMismatchError();
         }
 
         await this.verifyKeys(this.userId, content.mac, (keyId, device, keyInfo) => {
-            if (keyInfo !== calculateMAC(olmSAS, method)(
-                device.keys[keyId],
-                baseInfo + keyId,
-            )) {
+            if (keyInfo !== calculateMAC(olmSAS, method)(device.keys[keyId], baseInfo + keyId)) {
                 throw newKeyMismatchError();
             }
         });
diff --git a/src/crypto/verification/SASDecimal.ts b/src/crypto/verification/SASDecimal.ts
index 26dc8d2a087..0cb4630c2a8 100644
--- a/src/crypto/verification/SASDecimal.ts
+++ b/src/crypto/verification/SASDecimal.ts
@@ -30,8 +30,8 @@ export function generateDecimalSas(sasBytes: number[]): [number, number, number]
      *         1st number    2nd number     3rd number
      */
     return [
-        (sasBytes[0] << 5 | sasBytes[1] >> 3) + 1000,
-        ((sasBytes[1] & 0x7) << 10 | sasBytes[2] << 2 | sasBytes[3] >> 6) + 1000,
-        ((sasBytes[3] & 0x3f) << 7 | sasBytes[4] >> 1) + 1000,
+        ((sasBytes[0] << 5) | (sasBytes[1] >> 3)) + 1000,
+        (((sasBytes[1] & 0x7) << 10) | (sasBytes[2] << 2) | (sasBytes[3] >> 6)) + 1000,
+        (((sasBytes[3] & 0x3f) << 7) | (sasBytes[4] >> 1)) + 1000,
     ];
 }
diff --git a/src/crypto/verification/request/InRoomChannel.ts b/src/crypto/verification/request/InRoomChannel.ts
index edbf31f635b..ff11bf192bb 100644
--- a/src/crypto/verification/request/InRoomChannel.ts
+++ b/src/crypto/verification/request/InRoomChannel.ts
@@ -15,13 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {
-    VerificationRequest,
-    REQUEST_TYPE,
-    READY_TYPE,
-    START_TYPE,
-} from "./VerificationRequest";
-import { logger } from '../../../logger';
+import { VerificationRequest, REQUEST_TYPE, READY_TYPE, START_TYPE } from "./VerificationRequest";
+import { logger } from "../../../logger";
 import { IVerificationChannel } from "./Channel";
 import { EventType } from "../../../@types/event";
 import { MatrixClient } from "../../../client";
@@ -44,12 +39,7 @@ export class InRoomChannel implements IVerificationChannel {
      * @param roomId - id of the room where verification events should be posted in, should be a DM with the given user.
      * @param userId - id of user that the verification request is directed at, should be present in the room.
      */
-    public constructor(
-        private readonly client: MatrixClient,
-        public readonly roomId: string,
-        public userId?: string,
-    ) {
-    }
+    public constructor(private readonly client: MatrixClient, public readonly roomId: string, public userId?: string) {}
 
     public get receiveStartFromOtherDevices(): boolean {
         return true;
@@ -135,16 +125,17 @@ export class InRoomChannel implements IVerificationChannel {
         // part of a verification request, so be noisy when rejecting something
         if (type === REQUEST_TYPE) {
             if (!content || typeof content.to !== "string" || !content.to.length) {
-                logger.log("InRoomChannel: validateEvent: " +
-                    "no valid to " + (content && content.to));
+                logger.log("InRoomChannel: validateEvent: " + "no valid to " + (content && content.to));
                 return false;
             }
 
             // ignore requests that are not direct to or sent by the syncing user
             if (!InRoomChannel.getOtherPartyUserId(event, client)) {
-                logger.log("InRoomChannel: validateEvent: " +
-                    `not directed to or sent by me: ${event.getSender()}` +
-                    `, ${content && content.to}`);
+                logger.log(
+                    "InRoomChannel: validateEvent: " +
+                        `not directed to or sent by me: ${event.getSender()}` +
+                        `, ${content && content.to}`,
+                );
                 return false;
             }
         }
@@ -256,7 +247,9 @@ export class InRoomChannel implements IVerificationChannel {
         if (type === REQUEST_TYPE) {
             // type is mapped to m.room.message in the send method
             content = {
-                body: this.client.getUserId() + " is requesting to verify " +
+                body:
+                    this.client.getUserId() +
+                    " is requesting to verify " +
                     "your key, but your client does not support in-chat key " +
                     "verification.  You will need to use legacy key " +
                     "verification to verify keys.",
diff --git a/src/crypto/verification/request/ToDeviceChannel.ts b/src/crypto/verification/request/ToDeviceChannel.ts
index 5d92c3ed12c..cb9066457e6 100644
--- a/src/crypto/verification/request/ToDeviceChannel.ts
+++ b/src/crypto/verification/request/ToDeviceChannel.ts
@@ -15,8 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { randomString } from '../../../randomstring';
-import { logger } from '../../../logger';
+import { randomString } from "../../../randomstring";
+import { logger } from "../../../logger";
 import {
     CANCEL_TYPE,
     PHASE_STARTED,
@@ -30,7 +30,7 @@ import { errorFromEvent, newUnexpectedMessageError } from "../Error";
 import { MatrixEvent } from "../../../models/event";
 import { IVerificationChannel } from "./Channel";
 import { MatrixClient } from "../../../client";
-import { IRequestsMap } from '../..';
+import { IRequestsMap } from "../..";
 
 export type Request = VerificationRequest<ToDeviceChannel>;
 
@@ -101,8 +101,7 @@ export class ToDeviceChannel implements IVerificationChannel {
      */
     public static validateEvent(event: MatrixEvent, client: MatrixClient): boolean {
         if (event.isCancelled()) {
-            logger.warn("Ignoring flagged verification request from "
-                 + event.getSender());
+            logger.warn("Ignoring flagged verification request from " + event.getSender());
             return false;
         }
         const content = event.getContent();
@@ -123,9 +122,7 @@ export class ToDeviceChannel implements IVerificationChannel {
                 logger.warn("ToDeviceChannel.validateEvent: invalid: no timestamp");
                 return false;
             }
-            if (event.getSender() === client.getUserId() &&
-                    content.from_device == client.getDeviceId()
-            ) {
+            if (event.getSender() === client.getUserId() && content.from_device == client.getDeviceId()) {
                 // ignore requests from ourselves, because it doesn't make sense for a
                 // device to verify itself
                 logger.warn("ToDeviceChannel.validateEvent: invalid: from own device");
@@ -182,9 +179,7 @@ export class ToDeviceChannel implements IVerificationChannel {
         const isAcceptingEvent = type === START_TYPE || type === READY_TYPE;
         // the request has picked a ready or start event, tell the other devices about it
         if (isAcceptingEvent && !wasStarted && isStarted && this.deviceId) {
-            const nonChosenDevices = this.devices.filter(
-                d => d !== this.deviceId && d !== this.client.getDeviceId(),
-            );
+            const nonChosenDevices = this.devices.filter((d) => d !== this.deviceId && d !== this.client.getDeviceId());
             if (nonChosenDevices.length) {
                 const message = this.completeContent(CANCEL_TYPE, {
                     code: "m.accepted",
@@ -265,9 +260,9 @@ export class ToDeviceChannel implements IVerificationChannel {
         await this.request!.handleEvent(
             type,
             remoteEchoEvent,
-            /*isLiveEvent=*/true,
-            /*isRemoteEcho=*/true,
-            /*isSentByUs=*/true,
+            /*isLiveEvent=*/ true,
+            /*isRemoteEcho=*/ true,
+            /*isSentByUs=*/ true,
         );
         return result;
     }
@@ -296,10 +291,7 @@ export class ToDeviceRequests implements IRequestsMap {
     private requestsByUserId = new Map<string, Map<string, Request>>();
 
     public getRequest(event: MatrixEvent): Request | undefined {
-        return this.getRequestBySenderAndTxnId(
-            event.getSender()!,
-            ToDeviceChannel.getTransactionId(event),
-        );
+        return this.getRequestBySenderAndTxnId(event.getSender()!, ToDeviceChannel.getTransactionId(event));
     }
 
     public getRequestByChannel(channel: ToDeviceChannel): Request | undefined {
@@ -355,7 +347,7 @@ export class ToDeviceRequests implements IRequestsMap {
     public getRequestsInProgress(userId: string): Request[] {
         const requestsByTxnId = this.requestsByUserId.get(userId);
         if (requestsByTxnId) {
-            return Array.from(requestsByTxnId.values()).filter(r => r.pending);
+            return Array.from(requestsByTxnId.values()).filter((r) => r.pending);
         }
         return [];
     }
diff --git a/src/crypto/verification/request/VerificationRequest.ts b/src/crypto/verification/request/VerificationRequest.ts
index 05f0cd75ca5..617432ecb78 100644
--- a/src/crypto/verification/request/VerificationRequest.ts
+++ b/src/crypto/verification/request/VerificationRequest.ts
@@ -14,18 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from '../../../logger';
-import {
-    errorFactory,
-    errorFromEvent,
-    newUnexpectedMessageError,
-    newUnknownMethodError,
-} from "../Error";
+import { logger } from "../../../logger";
+import { errorFactory, errorFromEvent, newUnexpectedMessageError, newUnknownMethodError } from "../Error";
 import { QRCodeData, SCAN_QR_CODE_METHOD } from "../QRCode";
 import { IVerificationChannel } from "./Channel";
 import { MatrixClient } from "../../../client";
 import { MatrixEvent } from "../../../models/event";
-import { EventType } from '../../../@types/event';
+import { EventType } from "../../../@types/event";
 import { VerificationBase } from "../Base";
 import { VerificationMethod } from "../../index";
 import { TypedEventEmitter } from "../../../models/typed-event-emitter";
@@ -92,9 +87,10 @@ type EventHandlerMap = {
  * Things that differ based on what channel is used to
  * send and receive verification events are put in `InRoomChannel` or `ToDeviceChannel`.
  */
-export class VerificationRequest<
-    C extends IVerificationChannel = IVerificationChannel,
-> extends TypedEventEmitter<VerificationRequestEvent, EventHandlerMap> {
+export class VerificationRequest<C extends IVerificationChannel = IVerificationChannel> extends TypedEventEmitter<
+    VerificationRequestEvent,
+    EventHandlerMap
+> {
     private eventsByUs = new Map<string, MatrixEvent>();
     private eventsByThem = new Map<string, MatrixEvent>();
     private _observeOnly = false;
@@ -152,18 +148,14 @@ export class VerificationRequest<
 
         if (type === REQUEST_TYPE || type === READY_TYPE) {
             if (!Array.isArray(content.methods)) {
-                logger.log("VerificationRequest: validateEvent: " +
-                    "fail because methods");
+                logger.log("VerificationRequest: validateEvent: " + "fail because methods");
                 return false;
             }
         }
 
         if (type === REQUEST_TYPE || type === READY_TYPE || type === START_TYPE) {
-            if (typeof content.from_device !== "string" ||
-                content.from_device.length === 0
-            ) {
-                logger.log("VerificationRequest: validateEvent: "+
-                    "fail because from_device");
+            if (typeof content.from_device !== "string" || content.from_device.length === 0) {
+                logger.log("VerificationRequest: validateEvent: " + "fail because from_device");
                 return false;
             }
         }
@@ -211,14 +203,10 @@ export class VerificationRequest<
     }
 
     public calculateEventTimeout(event: MatrixEvent): number {
-        let effectiveExpiresAt = this.channel.getTimestamp(event)
-            + TIMEOUT_FROM_EVENT_TS;
-
-        if (this.requestReceivedAt && !this.initiatedByMe &&
-            this.phase <= PHASE_REQUESTED
-        ) {
-            const expiresAtByReceipt = this.requestReceivedAt
-                + TIMEOUT_FROM_EVENT_RECEIPT;
+        let effectiveExpiresAt = this.channel.getTimestamp(event) + TIMEOUT_FROM_EVENT_TS;
+
+        if (this.requestReceivedAt && !this.initiatedByMe && this.phase <= PHASE_REQUESTED) {
+            const expiresAtByReceipt = this.requestReceivedAt + TIMEOUT_FROM_EVENT_RECEIPT;
             effectiveExpiresAt = Math.min(effectiveExpiresAt, expiresAtByReceipt);
         }
 
@@ -266,9 +254,7 @@ export class VerificationRequest<
 
     /** whether this request has sent it's initial event and needs more events to complete */
     public get pending(): boolean {
-        return !this.observeOnly &&
-            this._phase !== PHASE_DONE &&
-            this._phase !== PHASE_CANCELLED;
+        return !this.observeOnly && this._phase !== PHASE_DONE && this._phase !== PHASE_CANCELLED;
     }
 
     /** Only set after a .ready if the other party can scan a QR code */
@@ -287,8 +273,7 @@ export class VerificationRequest<
         if (!force && !this.ready && !this.started) {
             return false;
         }
-        const theirMethodEvent = this.eventsByThem.get(REQUEST_TYPE) ||
-            this.eventsByThem.get(READY_TYPE);
+        const theirMethodEvent = this.eventsByThem.get(REQUEST_TYPE) || this.eventsByThem.get(READY_TYPE);
         if (!theirMethodEvent) {
             // if we started straight away with .start event,
             // we are assuming that the other side will support the
@@ -319,7 +304,7 @@ export class VerificationRequest<
      */
     public get initiatedByMe(): boolean {
         // event created by us but no remote echo has been received yet
-        const noEventsYet = (this.eventsByUs.size + this.eventsByThem.size) === 0;
+        const noEventsYet = this.eventsByUs.size + this.eventsByThem.size === 0;
         if (this._phase === PHASE_UNSENT && noEventsYet) {
             return true;
         }
@@ -561,9 +546,8 @@ export class VerificationRequest<
             const ourStartEvent = this.eventsByUs.get(START_TYPE);
             // any party can send .start after a .ready or unsent
             if (theirStartEvent && ourStartEvent) {
-                startEvent = theirStartEvent.getSender()! < ourStartEvent.getSender()!
-                    ? theirStartEvent
-                    : ourStartEvent;
+                startEvent =
+                    theirStartEvent.getSender()! < ourStartEvent.getSender()! ? theirStartEvent : ourStartEvent;
             } else {
                 startEvent = theirStartEvent ? theirStartEvent : ourStartEvent;
             }
@@ -571,9 +555,8 @@ export class VerificationRequest<
             startEvent = this.getEventBy(START_TYPE, !hasRequestByThem);
         }
         if (startEvent) {
-            const fromRequestPhase = (
-                phase() === PHASE_REQUESTED && requestEvent?.getSender() !== startEvent.getSender()
-            );
+            const fromRequestPhase =
+                phase() === PHASE_REQUESTED && requestEvent?.getSender() !== startEvent.getSender();
             const fromUnsentPhase = phase() === PHASE_UNSENT && this.channel.canCreateRequest(START_TYPE);
             if (fromRequestPhase || phase() === PHASE_READY || fromUnsentPhase) {
                 transitions.push({ phase: PHASE_STARTED, event: startEvent });
@@ -602,17 +585,13 @@ export class VerificationRequest<
                 const content = event!.getContent<{
                     methods: string[];
                 }>();
-                this.commonMethods =
-                    content.methods.filter(m => this.verificationMethods.has(m));
+                this.commonMethods = content.methods.filter((m) => this.verificationMethods.has(m));
             }
         }
         // detect if we're not a party in the request, and we should just observe
         if (!this.observeOnly) {
             // if requested or accepted by one of my other devices
-            if (phase === PHASE_REQUESTED ||
-                phase === PHASE_STARTED ||
-                phase === PHASE_READY
-            ) {
+            if (phase === PHASE_REQUESTED || phase === PHASE_STARTED || phase === PHASE_READY) {
                 if (
                     this.channel.receiveStartFromOtherDevices &&
                     this.wasSentByOwnUser(event) &&
@@ -641,7 +620,7 @@ export class VerificationRequest<
 
     private applyPhaseTransitions(): ITransition[] {
         const transitions = this.calculatePhaseTransitions();
-        const existingIdx = transitions.findIndex(t => t.phase === this.phase);
+        const existingIdx = transitions.findIndex((t) => t.phase === this.phase);
         // trim off phases we already went through, if any
         const newTransitions = transitions.slice(existingIdx + 1);
         // transition to all new phases
@@ -737,9 +716,7 @@ export class VerificationRequest<
         // This is true for QR and SAS verification, and was
         // added here to prevent verification getting cancelled
         // when the server duplicates an event (https://github.com/matrix-org/synapse/issues/3365)
-        const isDuplicateEvent = isSentByUs ?
-            this.eventsByUs.has(type) :
-            this.eventsByThem.has(type);
+        const isDuplicateEvent = isSentByUs ? this.eventsByUs.has(type) : this.eventsByThem.has(type);
         if (isDuplicateEvent) {
             return;
         }
@@ -770,9 +747,8 @@ export class VerificationRequest<
                 // We only do this for live events because it is important that
                 // we sign the keys that were in the QR code, and not the keys
                 // we happen to have at some later point in time.
-                if (isLiveEvent && newTransitions.some(t => t.phase === PHASE_READY)) {
-                    const shouldGenerateQrCode =
-                        this.otherPartySupportsMethod(SCAN_QR_CODE_METHOD, true);
+                if (isLiveEvent && newTransitions.some((t) => t.phase === PHASE_READY)) {
+                    const shouldGenerateQrCode = this.otherPartySupportsMethod(SCAN_QR_CODE_METHOD, true);
                     if (shouldGenerateQrCode) {
                         this._qrCodeData = await QRCodeData.create(this, this.client);
                     }
@@ -789,14 +765,16 @@ export class VerificationRequest<
             }
         } finally {
             // log events we processed so we can see from rageshakes what events were added to a request
-            logger.log(`Verification request ${this.channel.transactionId}: ` +
-                `${type} event with id:${event.getId()}, ` +
-                `content:${JSON.stringify(event.getContent())} ` +
-                `deviceId:${this.channel.deviceId}, ` +
-                `sender:${event.getSender()}, isSentByUs:${isSentByUs}, ` +
-                `isLiveEvent:${isLiveEvent}, isRemoteEcho:${isRemoteEcho}, ` +
-                `phase:${oldPhase}=>${this.phase}, ` +
-                `observeOnly:${wasObserveOnly}=>${this._observeOnly}`);
+            logger.log(
+                `Verification request ${this.channel.transactionId}: ` +
+                    `${type} event with id:${event.getId()}, ` +
+                    `content:${JSON.stringify(event.getContent())} ` +
+                    `deviceId:${this.channel.deviceId}, ` +
+                    `sender:${event.getSender()}, isSentByUs:${isSentByUs}, ` +
+                    `isLiveEvent:${isLiveEvent}, isRemoteEcho:${isRemoteEcho}, ` +
+                    `phase:${oldPhase}=>${this.phase}, ` +
+                    `observeOnly:${wasObserveOnly}=>${this._observeOnly}`,
+            );
         }
     }
 
@@ -807,10 +785,8 @@ export class VerificationRequest<
             this.timeoutTimer = setTimeout(this.cancelOnTimeout, this.timeout);
         }
         if (this.timeoutTimer) {
-            const shouldClear = phase === PHASE_STARTED ||
-                phase === PHASE_READY ||
-                phase === PHASE_DONE ||
-                phase === PHASE_CANCELLED;
+            const shouldClear =
+                phase === PHASE_STARTED || phase === PHASE_READY || phase === PHASE_DONE || phase === PHASE_CANCELLED;
             if (shouldClear) {
                 clearTimeout(this.timeoutTimer);
                 this.timeoutTimer = null;
@@ -853,8 +829,7 @@ export class VerificationRequest<
         // Before that, we could be looking at somebody else's verification request and we just
         // happen to be in the room
         if (this.phase !== PHASE_UNSENT && (isUnexpectedRequest || isUnexpectedReady)) {
-            logger.warn(`Cancelling, unexpected ${type} verification ` +
-                `event from ${event.getSender()}`);
+            logger.warn(`Cancelling, unexpected ${type} verification ` + `event from ${event.getSender()}`);
             const reason = `Unexpected ${type} event in phase ${this.phase}`;
             await this.cancel(errorFromEvent(newUnexpectedMessageError({ reason })));
             return true;
diff --git a/src/embedded.ts b/src/embedded.ts
index c5cbab80d14..2c1617ecbaf 100644
--- a/src/embedded.ts
+++ b/src/embedded.ts
@@ -97,7 +97,7 @@ export interface ICapabilities {
  */
 export class RoomWidgetClient extends MatrixClient {
     private room?: Room;
-    private widgetApiReady = new Promise<void>(resolve => this.widgetApi.once("ready", resolve));
+    private widgetApiReady = new Promise<void>((resolve) => this.widgetApi.once("ready", resolve));
     private lifecycle?: AbortController;
     private syncState: SyncState | null = null;
 
@@ -111,36 +111,28 @@ export class RoomWidgetClient extends MatrixClient {
 
         // Request capabilities for the functionality this client needs to support
         if (
-            capabilities.sendEvent?.length
-            || capabilities.receiveEvent?.length
-            || capabilities.sendMessage === true
-            || (Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length)
-            || capabilities.receiveMessage === true
-            || (Array.isArray(capabilities.receiveMessage) && capabilities.receiveMessage.length)
-            || capabilities.sendState?.length
-            || capabilities.receiveState?.length
+            capabilities.sendEvent?.length ||
+            capabilities.receiveEvent?.length ||
+            capabilities.sendMessage === true ||
+            (Array.isArray(capabilities.sendMessage) && capabilities.sendMessage.length) ||
+            capabilities.receiveMessage === true ||
+            (Array.isArray(capabilities.receiveMessage) && capabilities.receiveMessage.length) ||
+            capabilities.sendState?.length ||
+            capabilities.receiveState?.length
         ) {
             widgetApi.requestCapabilityForRoomTimeline(roomId);
         }
-        capabilities.sendEvent?.forEach(eventType =>
-            widgetApi.requestCapabilityToSendEvent(eventType),
-        );
-        capabilities.receiveEvent?.forEach(eventType =>
-            widgetApi.requestCapabilityToReceiveEvent(eventType),
-        );
+        capabilities.sendEvent?.forEach((eventType) => widgetApi.requestCapabilityToSendEvent(eventType));
+        capabilities.receiveEvent?.forEach((eventType) => widgetApi.requestCapabilityToReceiveEvent(eventType));
         if (capabilities.sendMessage === true) {
             widgetApi.requestCapabilityToSendMessage();
         } else if (Array.isArray(capabilities.sendMessage)) {
-            capabilities.sendMessage.forEach(msgType =>
-                widgetApi.requestCapabilityToSendMessage(msgType),
-            );
+            capabilities.sendMessage.forEach((msgType) => widgetApi.requestCapabilityToSendMessage(msgType));
         }
         if (capabilities.receiveMessage === true) {
             widgetApi.requestCapabilityToReceiveMessage();
         } else if (Array.isArray(capabilities.receiveMessage)) {
-            capabilities.receiveMessage.forEach(msgType =>
-                widgetApi.requestCapabilityToReceiveMessage(msgType),
-            );
+            capabilities.receiveMessage.forEach((msgType) => widgetApi.requestCapabilityToReceiveMessage(msgType));
         }
         capabilities.sendState?.forEach(({ eventType, stateKey }) =>
             widgetApi.requestCapabilityToSendState(eventType, stateKey),
@@ -148,12 +140,8 @@ export class RoomWidgetClient extends MatrixClient {
         capabilities.receiveState?.forEach(({ eventType, stateKey }) =>
             widgetApi.requestCapabilityToReceiveState(eventType, stateKey),
         );
-        capabilities.sendToDevice?.forEach(eventType =>
-            widgetApi.requestCapabilityToSendToDevice(eventType),
-        );
-        capabilities.receiveToDevice?.forEach(eventType =>
-            widgetApi.requestCapabilityToReceiveToDevice(eventType),
-        );
+        capabilities.sendToDevice?.forEach((eventType) => widgetApi.requestCapabilityToSendToDevice(eventType));
+        capabilities.receiveToDevice?.forEach((eventType) => widgetApi.requestCapabilityToReceiveToDevice(eventType));
         if (capabilities.turnServers) {
             widgetApi.requestCapability(MatrixCapabilities.MSC3846TurnServers);
         }
@@ -195,10 +183,10 @@ export class RoomWidgetClient extends MatrixClient {
         await Promise.all(
             this.capabilities.receiveState?.map(async ({ eventType, stateKey }) => {
                 const rawEvents = await this.widgetApi.readStateEvents(eventType, undefined, stateKey, [this.roomId]);
-                const events = rawEvents.map(rawEvent => new MatrixEvent(rawEvent as Partial<IEvent>));
+                const events = rawEvents.map((rawEvent) => new MatrixEvent(rawEvent as Partial<IEvent>));
 
                 await this.syncApi!.injectRoomEvents(this.room!, [], events);
-                events.forEach(event => {
+                events.forEach((event) => {
                     this.emit(ClientEvent.Event, event);
                     logger.info(`Backfilled event ${event.getId()} ${event.getType()} ${event.getStateKey()}`);
                 });
@@ -264,12 +252,12 @@ export class RoomWidgetClient extends MatrixClient {
         await this.widgetApi.sendToDevice(eventType, false, contentMap);
     }
 
-    public async encryptAndSendToDevices(
-        userDeviceInfoArr: IOlmDevice<DeviceInfo>[],
-        payload: object,
-    ): Promise<void> {
+    public async encryptAndSendToDevices(userDeviceInfoArr: IOlmDevice<DeviceInfo>[], payload: object): Promise<void> {
         const contentMap: { [userId: string]: { [deviceId: string]: object } } = {};
-        for (const { userId, deviceInfo: { deviceId } } of userDeviceInfoArr) {
+        for (const {
+            userId,
+            deviceInfo: { deviceId },
+        } of userDeviceInfoArr) {
             if (!contentMap[userId]) contentMap[userId] = {};
             contentMap[userId][deviceId] = payload;
         }
@@ -342,11 +330,13 @@ export class RoomWidgetClient extends MatrixClient {
 
         try {
             for await (const server of servers) {
-                this.turnServers = [{
-                    urls: server.uris,
-                    username: server.username,
-                    credential: server.password,
-                }];
+                this.turnServers = [
+                    {
+                        urls: server.uris,
+                        username: server.username,
+                        credential: server.password,
+                    },
+                ];
                 this.emit(ClientEvent.TurnServers, this.turnServers);
                 logger.log(`Received TURN server: ${server.uris}`);
             }
diff --git a/src/errors.ts b/src/errors.ts
index f58c839ce60..9d2465131f7 100644
--- a/src/errors.ts
+++ b/src/errors.ts
@@ -22,7 +22,8 @@ export class InvalidStoreError extends Error {
     public static TOGGLED_LAZY_LOADING = InvalidStoreState.ToggledLazyLoading;
 
     public constructor(public readonly reason: InvalidStoreState, public readonly value: any) {
-        const message = `Store is invalid because ${reason}, ` +
+        const message =
+            `Store is invalid because ${reason}, ` +
             `please stop the client, delete all data and start the client again`;
         super(message);
         this.name = "InvalidStoreError";
@@ -37,10 +38,11 @@ export class InvalidCryptoStoreError extends Error {
     public static TOO_NEW = InvalidCryptoStoreState.TooNew;
 
     public constructor(public readonly reason: InvalidCryptoStoreState) {
-        const message = `Crypto store is invalid because ${reason}, ` +
+        const message =
+            `Crypto store is invalid because ${reason}, ` +
             `please stop the client, delete all data and start the client again`;
         super(message);
-        this.name = 'InvalidCryptoStoreError';
+        this.name = "InvalidCryptoStoreError";
     }
 }
 
diff --git a/src/event-mapper.ts b/src/event-mapper.ts
index d40f579b5d7..81d3d772a59 100644
--- a/src/event-mapper.ts
+++ b/src/event-mapper.ts
@@ -62,9 +62,7 @@ export function eventMapperFor(client: MatrixClient, options: MapperOpts): Event
 
         if (event.isEncrypted()) {
             if (!preventReEmit) {
-                client.reEmitter.reEmit(event, [
-                    MatrixEventEvent.Decrypted,
-                ]);
+                client.reEmitter.reEmit(event, [MatrixEventEvent.Decrypted]);
             }
             if (decrypt) {
                 client.decryptEventIfNeeded(event);
@@ -72,13 +70,8 @@ export function eventMapperFor(client: MatrixClient, options: MapperOpts): Event
         }
 
         if (!preventReEmit) {
-            client.reEmitter.reEmit(event, [
-                MatrixEventEvent.Replaced,
-                MatrixEventEvent.VisibilityChange,
-            ]);
-            room?.reEmitter.reEmit(event, [
-                MatrixEventEvent.BeforeRedaction,
-            ]);
+            client.reEmitter.reEmit(event, [MatrixEventEvent.Replaced, MatrixEventEvent.VisibilityChange]);
+            room?.reEmitter.reEmit(event, [MatrixEventEvent.BeforeRedaction]);
         }
         return event;
     }
diff --git a/src/feature.ts b/src/feature.ts
index d617093961e..d555a860bd9 100644
--- a/src/feature.ts
+++ b/src/feature.ts
@@ -19,7 +19,7 @@ import { IServerVersions } from "./client";
 export enum ServerSupport {
     Stable,
     Unstable,
-    Unsupported
+    Unsupported,
 }
 
 export enum Feature {
@@ -51,9 +51,10 @@ export async function buildFeatureSupportMap(versions: IServerVersions): Promise
     const supportMap = new Map<Feature, ServerSupport>();
     for (const [feature, supportCondition] of Object.entries(featureSupportResolver)) {
         const supportMatrixVersion = versions.versions?.includes(supportCondition.matrixVersion || "") ?? false;
-        const supportUnstablePrefixes = supportCondition.unstablePrefixes?.every(unstablePrefix => {
-            return versions.unstable_features?.[unstablePrefix] === true;
-        }) ?? false;
+        const supportUnstablePrefixes =
+            supportCondition.unstablePrefixes?.every((unstablePrefix) => {
+                return versions.unstable_features?.[unstablePrefix] === true;
+            }) ?? false;
         if (supportMatrixVersion) {
             supportMap.set(feature as Feature, ServerSupport.Stable);
         } else if (supportUnstablePrefixes) {
diff --git a/src/filter-component.ts b/src/filter-component.ts
index 5a4601258f2..e28571d640d 100644
--- a/src/filter-component.ts
+++ b/src/filter-component.ts
@@ -16,11 +16,7 @@ limitations under the License.
 
 import { RelationType } from "./@types/event";
 import { MatrixEvent } from "./models/event";
-import {
-    FILTER_RELATED_BY_REL_TYPES,
-    FILTER_RELATED_BY_SENDERS,
-    THREAD_RELATION_TYPE,
-} from "./models/thread";
+import { FILTER_RELATED_BY_REL_TYPES, FILTER_RELATED_BY_SENDERS, THREAD_RELATION_TYPE } from "./models/thread";
 
 /**
  * Checks if a value matches a given field value, which may be a * terminated
@@ -40,16 +36,16 @@ function matchesWildcard(actualValue: string, filterValue: string): boolean {
 
 /* eslint-disable camelcase */
 export interface IFilterComponent {
-    types?: string[];
-    not_types?: string[];
-    rooms?: string[];
-    not_rooms?: string[];
-    senders?: string[];
-    not_senders?: string[];
-    contains_url?: boolean;
-    limit?: number;
-    related_by_senders?: Array<RelationType | string>;
-    related_by_rel_types?: string[];
+    "types"?: string[];
+    "not_types"?: string[];
+    "rooms"?: string[];
+    "not_rooms"?: string[];
+    "senders"?: string[];
+    "not_senders"?: string[];
+    "contains_url"?: boolean;
+    "limit"?: number;
+    "related_by_senders"?: Array<RelationType | string>;
+    "related_by_rel_types"?: string[];
 
     // Unstable values
     "io.element.relation_senders"?: Array<RelationType | string>;
@@ -101,13 +97,13 @@ export class FilterComponent {
      */
     public toJSON(): object {
         return {
-            "types": this.filterJson.types || null,
-            "not_types": this.filterJson.not_types || [],
-            "rooms": this.filterJson.rooms || null,
-            "not_rooms": this.filterJson.not_rooms || [],
-            "senders": this.filterJson.senders || null,
-            "not_senders": this.filterJson.not_senders || [],
-            "contains_url": this.filterJson.contains_url || null,
+            types: this.filterJson.types || null,
+            not_types: this.filterJson.not_types || [],
+            rooms: this.filterJson.rooms || null,
+            not_rooms: this.filterJson.not_rooms || [],
+            senders: this.filterJson.senders || null,
+            not_senders: this.filterJson.not_senders || [],
+            contains_url: this.filterJson.contains_url || null,
             [FILTER_RELATED_BY_SENDERS.name]: this.filterJson[FILTER_RELATED_BY_SENDERS.name] || [],
             [FILTER_RELATED_BY_REL_TYPES.name]: this.filterJson[FILTER_RELATED_BY_REL_TYPES.name] || [],
         };
@@ -132,13 +128,13 @@ export class FilterComponent {
         relationSenders: string[],
     ): boolean {
         const literalKeys = {
-            "rooms": function(v: string): boolean {
+            rooms: function (v: string): boolean {
                 return roomId === v;
             },
-            "senders": function(v: string): boolean {
+            senders: function (v: string): boolean {
                 return sender === v;
             },
-            "types": function(v: string): boolean {
+            types: function (v: string): boolean {
                 return matchesWildcard(eventType, v);
             },
         } as const;
@@ -180,9 +176,12 @@ export class FilterComponent {
     }
 
     private arrayMatchesFilter(filter: any[], values: any[]): boolean {
-        return values.length > 0 && filter.every(value => {
-            return values.includes(value);
-        });
+        return (
+            values.length > 0 &&
+            filter.every((value) => {
+                return values.includes(value);
+            })
+        );
     }
 
     /**
diff --git a/src/filter.ts b/src/filter.ts
index b5dc7140bdc..4d74c8c3e08 100644
--- a/src/filter.ts
+++ b/src/filter.ts
@@ -14,10 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {
-    EventType,
-    RelationType,
-} from "./@types/event";
+import { EventType, RelationType } from "./@types/event";
 import { UNREAD_THREAD_NOTIFICATIONS } from "./@types/sync";
 import { FilterComponent, IFilterComponent } from "./filter-component";
 import { MatrixEvent } from "./models/event";
@@ -27,7 +24,7 @@ import { MatrixEvent } from "./models/event";
 function setProp(obj: Record<string, any>, keyNesting: string, val: any): void {
     const nestedKeys = keyNesting.split(".") as [keyof typeof obj];
     let currentObj = obj;
-    for (let i = 0; i < (nestedKeys.length - 1); i++) {
+    for (let i = 0; i < nestedKeys.length - 1; i++) {
         if (!currentObj[nestedKeys[i]]) {
             currentObj[nestedKeys[i]] = {};
         }
@@ -46,12 +43,12 @@ export interface IFilterDefinition {
 }
 
 export interface IRoomEventFilter extends IFilterComponent {
-    lazy_load_members?: boolean;
-    include_redundant_members?: boolean;
-    types?: Array<EventType | string>;
-    related_by_senders?: Array<RelationType | string>;
-    related_by_rel_types?: string[];
-    unread_thread_notifications?: boolean;
+    "lazy_load_members"?: boolean;
+    "include_redundant_members"?: boolean;
+    "types"?: Array<EventType | string>;
+    "related_by_senders"?: Array<RelationType | string>;
+    "related_by_rel_types"?: string[];
+    "unread_thread_notifications"?: boolean;
     "org.matrix.msc3773.unread_thread_notifications"?: boolean;
 
     // Unstable values
@@ -63,7 +60,8 @@ interface IStateFilter extends IRoomEventFilter {}
 
 interface IRoomFilter {
     not_rooms?: string[];
-    rooms?: string[];ephemeral?: IRoomEventFilter;
+    rooms?: string[];
+    ephemeral?: IRoomEventFilter;
     include_leave?: boolean;
     state?: IStateFilter;
     timeline?: IRoomEventFilter;
diff --git a/src/http-api/fetch.ts b/src/http-api/fetch.ts
index 0c966d30d08..1267fcc7611 100644
--- a/src/http-api/fetch.ts
+++ b/src/http-api/fetch.ts
@@ -32,10 +32,11 @@ interface TypedResponse<T> extends Response {
     json(): Promise<T>;
 }
 
-export type ResponseType<T, O extends IHttpOpts> =
-    O extends undefined ? T :
-        O extends { onlyData: true } ? T :
-            TypedResponse<T>;
+export type ResponseType<T, O extends IHttpOpts> = O extends undefined
+    ? T
+    : O extends { onlyData: true }
+    ? T
+    : TypedResponse<T>;
 
 export class FetchHttpApi<O extends IHttpOpts> {
     private abortController = new AbortController();
@@ -155,9 +156,9 @@ export class FetchHttpApi<O extends IHttpOpts> {
         const requestPromise = this.request<T>(method, path, queryParams, body, opts);
 
         requestPromise.catch((err: MatrixError) => {
-            if (err.errcode == 'M_UNKNOWN_TOKEN' && !opts?.inhibitLogoutEmit) {
+            if (err.errcode == "M_UNKNOWN_TOKEN" && !opts?.inhibitLogoutEmit) {
                 this.eventEmitter.emit(HttpApiEvent.SessionLoggedOut, err);
-            } else if (err.errcode == 'M_CONSENT_NOT_GIVEN') {
+            } else if (err.errcode == "M_CONSENT_NOT_GIVEN") {
                 this.eventEmitter.emit(HttpApiEvent.NoConsent, err.message, err.data.consent_uri);
             }
         });
@@ -241,9 +242,7 @@ export class FetchHttpApi<O extends IHttpOpts> {
 
         const timeout = opts.localTimeoutMs ?? this.opts.localTimeoutMs;
         const keepAlive = opts.keepAlive ?? false;
-        const signals = [
-            this.abortController.signal,
-        ];
+        const signals = [this.abortController.signal];
         if (timeout !== undefined) {
             signals.push(timeoutSignal(timeout));
         }
@@ -302,12 +301,7 @@ export class FetchHttpApi<O extends IHttpOpts> {
      * @param baseUrl - The baseUrl to use e.g. "https://matrix.org/", defaulting to this.opts.baseUrl.
      * @returns URL
      */
-    public getUrl(
-        path: string,
-        queryParams?: QueryDict,
-        prefix?: string,
-        baseUrl?: string,
-    ): URL {
+    public getUrl(path: string, queryParams?: QueryDict, prefix?: string, baseUrl?: string): URL {
         const url = new URL((baseUrl ?? this.opts.baseUrl) + (prefix ?? this.opts.prefix) + path);
         if (queryParams) {
             utils.encodeParams(queryParams, url.searchParams);
diff --git a/src/http-api/index.ts b/src/http-api/index.ts
index 3574f539e7f..c5e8e2a3a9a 100644
--- a/src/http-api/index.ts
+++ b/src/http-api/index.ts
@@ -50,7 +50,7 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
         const abortController = opts.abortController ?? new AbortController();
 
         // If the file doesn't have a mime type, use a default since the HS errors if we don't supply one.
-        const contentType = opts.type ?? (file as File).type ?? 'application/octet-stream';
+        const contentType = opts.type ?? (file as File).type ?? "application/octet-stream";
         const fileName = opts.name ?? (file as File).name;
 
         const upload = {
@@ -63,7 +63,7 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
         if (global.XMLHttpRequest) {
             const xhr = new global.XMLHttpRequest();
 
-            const timeoutFn = function(): void {
+            const timeoutFn = function (): void {
                 xhr.abort();
                 defer.reject(new Error("Timeout"));
             };
@@ -71,7 +71,7 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
             // set an initial timeout of 30s; we'll advance it each time we get a progress notification
             let timeoutTimer = callbacks.setTimeout(timeoutFn, 30000);
 
-            xhr.onreadystatechange = function(): void {
+            xhr.onreadystatechange = function (): void {
                 switch (xhr.readyState) {
                     case global.XMLHttpRequest.DONE:
                         callbacks.clearTimeout(timeoutTimer);
@@ -80,7 +80,7 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
                                 throw new DOMException(xhr.statusText, "AbortError"); // mimic fetch API
                             }
                             if (!xhr.responseText) {
-                                throw new Error('No response body.');
+                                throw new Error("No response body.");
                             }
 
                             if (xhr.status >= 400) {
@@ -138,23 +138,23 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
 
             const headers: Record<string, string> = { "Content-Type": contentType };
 
-            this.authedRequest<UploadResponse>(
-                Method.Post, "/upload", queryParams, file, {
-                    prefix: MediaPrefix.R0,
-                    headers,
-                    abortSignal: abortController.signal,
-                },
-            ).then(response => {
-                return this.opts.onlyData ? <UploadResponse>response : response.json();
-            }).then(defer.resolve, defer.reject);
+            this.authedRequest<UploadResponse>(Method.Post, "/upload", queryParams, file, {
+                prefix: MediaPrefix.R0,
+                headers,
+                abortSignal: abortController.signal,
+            })
+                .then((response) => {
+                    return this.opts.onlyData ? <UploadResponse>response : response.json();
+                })
+                .then(defer.resolve, defer.reject);
         }
 
         // remove the upload from the list on completion
         upload.promise = defer.promise.finally(() => {
-            utils.removeElement(this.uploads, elem => elem === upload);
+            utils.removeElement(this.uploads, (elem) => elem === upload);
         });
         abortController.signal.addEventListener("abort", () => {
-            utils.removeElement(this.uploads, elem => elem === upload);
+            utils.removeElement(this.uploads, (elem) => elem === upload);
             defer.reject(new DOMException("Aborted", "AbortError"));
         });
         this.uploads.push(upload);
@@ -162,7 +162,7 @@ export class MatrixHttpApi<O extends IHttpOpts> extends FetchHttpApi<O> {
     }
 
     public cancelUpload(promise: Promise<UploadResponse>): boolean {
-        const upload = this.uploads.find(u => u.promise === promise);
+        const upload = this.uploads.find((u) => u.promise === promise);
         if (upload) {
             upload.abortController.abort();
             return true;
diff --git a/src/index.ts b/src/index.ts
index a93c2714dfa..c9a5dcf65c0 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -23,4 +23,3 @@ global.__js_sdk_entrypoint = true;
 
 export * from "./matrix";
 export default matrixcs;
-
diff --git a/src/indexeddb-worker.ts b/src/indexeddb-worker.ts
index 78e87b37329..68dcf0f8006 100644
--- a/src/indexeddb-worker.ts
+++ b/src/indexeddb-worker.ts
@@ -22,4 +22,3 @@ limitations under the License.
 
 /** The {@link IndexedDBStoreWorker} class. */
 export { IndexedDBStoreWorker } from "./store/indexeddb-store-worker";
-
diff --git a/src/interactive-auth.ts b/src/interactive-auth.ts
index 219569e6148..e4baefa6df2 100644
--- a/src/interactive-auth.ts
+++ b/src/interactive-auth.ts
@@ -16,7 +16,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from './logger';
+import { logger } from "./logger";
 import { MatrixClient } from "./client";
 import { defer, IDeferred } from "./utils";
 import { MatrixError } from "./http-api";
@@ -240,9 +240,7 @@ export class InteractiveAuth {
         if (!this.data?.flows) {
             this.busyChangedCallback?.(true);
             // use the existing sessionId, if one is present.
-            const auth = this.data.session
-                ? { session: this.data.session }
-                : null;
+            const auth = this.data.session ? { session: this.data.session } : null;
             this.doRequest(auth).finally(() => {
                 this.busyChangedCallback?.(false);
             });
@@ -355,8 +353,7 @@ export class InteractiveAuth {
         while (this.submitPromise) {
             try {
                 await this.submitPromise;
-            } catch (e) {
-            }
+            } catch (e) {}
         }
 
         // use the sessionid from the last request, if one is present.
@@ -472,7 +469,8 @@ export class InteractiveAuth {
             // any UI auth data (eg. when polling for email validation, if the email
             // has not yet been validated). This appears to be a Synapse bug, which
             // we workaround here.
-            if (!(<MatrixError>error).data.flows &&
+            if (
+                !(<MatrixError>error).data.flows &&
                 !(<MatrixError>error).data.completed &&
                 !(<MatrixError>error).data.session
             ) {
@@ -527,7 +525,7 @@ export class InteractiveAuth {
 
         if (nextStage === AuthType.Dummy) {
             this.submitAuthDict({
-                type: 'm.login.dummy',
+                type: "m.login.dummy",
             });
             return;
         }
@@ -540,9 +538,7 @@ export class InteractiveAuth {
             return;
         }
 
-        this.stateUpdatedCallback(nextStage, nextStage === EMAIL_STAGE_TYPE
-            ? { emailSid: this.emailSid }
-            : {});
+        this.stateUpdatedCallback(nextStage, nextStage === EMAIL_STAGE_TYPE ? { emailSid: this.emailSid } : {});
     }
 
     /**
@@ -582,10 +578,7 @@ export class InteractiveAuth {
 
         // we've been given an email or we've already done an email part
         const haveEmail = Boolean(this.inputs.emailAddress) || Boolean(this.emailSid);
-        const haveMsisdn = (
-            Boolean(this.inputs.phoneCountry) &&
-            Boolean(this.inputs.phoneNumber)
-        );
+        const haveMsisdn = Boolean(this.inputs.phoneCountry) && Boolean(this.inputs.phoneNumber);
 
         for (const flow of flows) {
             let flowHasEmail = false;
@@ -619,6 +612,6 @@ export class InteractiveAuth {
      */
     private firstUncompletedStage(flow: IFlow): AuthType | undefined {
         const completed = this.data.completed || [];
-        return flow.stages.find(stageType => !completed.includes(stageType));
+        return flow.stages.find((stageType) => !completed.includes(stageType));
     }
 }
diff --git a/src/logger.ts b/src/logger.ts
index 7077dee02e2..ba7f7421039 100644
--- a/src/logger.ts
+++ b/src/logger.ts
@@ -30,17 +30,15 @@ const DEFAULT_NAMESPACE = "matrix";
 // to avoid the issue, we override the methodFactory of loglevel that binds to the
 // console methods at initialization time by a factory that looks up the console methods
 // when logging so we always get the current value of console methods.
-log.methodFactory = function(methodName, logLevel, loggerName) {
-    return function(this: PrefixedLogger, ...args): void {
+log.methodFactory = function (methodName, logLevel, loggerName) {
+    return function (this: PrefixedLogger, ...args): void {
         /* eslint-disable @typescript-eslint/no-invalid-this */
         if (this.prefix) {
             args.unshift(this.prefix);
         }
         /* eslint-enable @typescript-eslint/no-invalid-this */
-        const supportedByConsole = methodName === "error" ||
-            methodName === "warn" ||
-            methodName === "trace" ||
-            methodName === "info";
+        const supportedByConsole =
+            methodName === "error" || methodName === "warn" || methodName === "trace" || methodName === "info";
         /* eslint-disable no-console */
         if (supportedByConsole) {
             return console[methodName](...args);
@@ -64,7 +62,7 @@ export interface PrefixedLogger extends Logger {
 }
 
 function extendLogger(logger: Logger): void {
-    (<PrefixedLogger>logger).withPrefix = function(prefix: string): PrefixedLogger {
+    (<PrefixedLogger>logger).withPrefix = function (prefix: string): PrefixedLogger {
         const existingPrefix = this.prefix || "";
         return getPrefixedLogger(existingPrefix + prefix);
     };
diff --git a/src/matrix.ts b/src/matrix.ts
index d075c098e64..6e8b8bdace2 100644
--- a/src/matrix.ts
+++ b/src/matrix.ts
@@ -47,25 +47,20 @@ export * from "./store/indexeddb";
 export * from "./crypto/store/memory-crypto-store";
 export * from "./crypto/store/indexeddb-crypto-store";
 export * from "./content-repo";
-export * from './@types/event';
-export * from './@types/PushRules';
-export * from './@types/partials';
-export * from './@types/requests';
-export * from './@types/search';
-export * from './models/room-summary';
+export * from "./@types/event";
+export * from "./@types/PushRules";
+export * from "./@types/partials";
+export * from "./@types/requests";
+export * from "./@types/search";
+export * from "./models/room-summary";
 export * as ContentHelpers from "./content-helpers";
 export type { ICryptoCallbacks } from "./crypto"; // used to be located here
 export { createNewMatrixCall } from "./webrtc/call";
 export type { MatrixCall } from "./webrtc/call";
-export {
-    GroupCallEvent,
-    GroupCallIntent,
-    GroupCallState,
-    GroupCallType,
-} from "./webrtc/groupCall";
+export { GroupCallEvent, GroupCallIntent, GroupCallState, GroupCallType } from "./webrtc/groupCall";
 export type { GroupCall } from "./webrtc/groupCall";
 
-let cryptoStoreFactory = (): CryptoStore => new MemoryCryptoStore;
+let cryptoStoreFactory = (): CryptoStore => new MemoryCryptoStore();
 
 /**
  * Configure a different factory to be used for creating crypto stores
@@ -77,9 +72,11 @@ export function setCryptoStoreFactory(fac: () => CryptoStore): void {
 }
 
 function amendClientOpts(opts: ICreateClientOpts): ICreateClientOpts {
-    opts.store = opts.store ?? new MemoryStore({
-        localStorage: global.localStorage,
-    });
+    opts.store =
+        opts.store ??
+        new MemoryStore({
+            localStorage: global.localStorage,
+        });
     opts.scheduler = opts.scheduler ?? new MatrixScheduler();
     opts.cryptoStore = opts.cryptoStore ?? cryptoStoreFactory();
 
diff --git a/src/models/MSC3089Branch.ts b/src/models/MSC3089Branch.ts
index e4c0eb2870a..27be4b87bc1 100644
--- a/src/models/MSC3089Branch.ts
+++ b/src/models/MSC3089Branch.ts
@@ -82,7 +82,7 @@ export class MSC3089Branch {
      * @returns The name, or "Unnamed File" if unknown.
      */
     public getName(): string {
-        return this.indexEvent.getContent()['name'] || "Unnamed File";
+        return this.indexEvent.getContent()["name"] || "Unnamed File";
     }
 
     /**
@@ -91,10 +91,15 @@ export class MSC3089Branch {
      * @returns Promise which resolves when complete.
      */
     public async setName(name: string): Promise<void> {
-        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
-            ...this.indexEvent.getContent(),
-            name: name,
-        }, this.id);
+        await this.client.sendStateEvent(
+            this.roomId,
+            UNSTABLE_MSC3089_BRANCH.name,
+            {
+                ...this.indexEvent.getContent(),
+                name: name,
+            },
+            this.id,
+        );
     }
 
     /**
@@ -102,7 +107,7 @@ export class MSC3089Branch {
      * @returns True if locked, false otherwise.
      */
     public isLocked(): boolean {
-        return this.indexEvent.getContent()['locked'] || false;
+        return this.indexEvent.getContent()["locked"] || false;
     }
 
     /**
@@ -111,24 +116,29 @@ export class MSC3089Branch {
      * @returns Promise which resolves when complete.
      */
     public async setLocked(locked: boolean): Promise<void> {
-        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
-            ...this.indexEvent.getContent(),
-            locked: locked,
-        }, this.id);
+        await this.client.sendStateEvent(
+            this.roomId,
+            UNSTABLE_MSC3089_BRANCH.name,
+            {
+                ...this.indexEvent.getContent(),
+                locked: locked,
+            },
+            this.id,
+        );
     }
 
     /**
      * Gets information about the file needed to download it.
      * @returns Information about the file.
      */
-    public async getFileInfo(): Promise<{ info: IEncryptedFile, httpUrl: string }> {
+    public async getFileInfo(): Promise<{ info: IEncryptedFile; httpUrl: string }> {
         const event = await this.getFileEvent();
 
-        const file = event.getOriginalContent()['file'];
-        const httpUrl = this.client.mxcUrlToHttp(file['url']);
+        const file = event.getOriginalContent()["file"];
+        const httpUrl = this.client.mxcUrlToHttp(file["url"]);
 
         if (!httpUrl) {
-            throw new Error(`No HTTP URL available for ${file['url']}`);
+            throw new Error(`No HTTP URL available for ${file["url"]}`);
         }
 
         return { info: file, httpUrl: httpUrl };
@@ -177,23 +187,33 @@ export class MSC3089Branch {
             ...(additionalContent ?? {}),
             "m.new_content": true,
             "m.relates_to": {
-                "rel_type": RelationType.Replace,
-                "event_id": this.id,
+                rel_type: RelationType.Replace,
+                event_id: this.id,
             },
         });
 
         // Update the version of the new event
-        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
-            active: true,
-            name: name,
-            version: this.version + 1,
-        }, fileEventResponse['event_id']);
+        await this.client.sendStateEvent(
+            this.roomId,
+            UNSTABLE_MSC3089_BRANCH.name,
+            {
+                active: true,
+                name: name,
+                version: this.version + 1,
+            },
+            fileEventResponse["event_id"],
+        );
 
         // Deprecate ourselves
-        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
-            ...(this.indexEvent.getContent()),
-            active: false,
-        }, this.id);
+        await this.client.sendStateEvent(
+            this.roomId,
+            UNSTABLE_MSC3089_BRANCH.name,
+            {
+                ...this.indexEvent.getContent(),
+                active: false,
+            },
+            this.id,
+        );
 
         return fileEventResponse;
     }
@@ -221,7 +241,7 @@ export class MSC3089Branch {
         let childEvent: MatrixEvent | undefined;
         let parentEvent = await this.getFileEvent();
         do {
-            childEvent = timelineEvents.find(e => e.replacingEventId() === parentEvent.getId());
+            childEvent = timelineEvents.find((e) => e.replacingEventId() === parentEvent.getId());
             if (childEvent) {
                 const branch = this.directory.getFile(childEvent.getId()!);
                 if (branch) {
diff --git a/src/models/MSC3089TreeSpace.ts b/src/models/MSC3089TreeSpace.ts
index 76c733996c1..b0e71d97123 100644
--- a/src/models/MSC3089TreeSpace.ts
+++ b/src/models/MSC3089TreeSpace.ts
@@ -106,7 +106,7 @@ export class MSC3089TreeSpace {
         // but is safe for a managed usecase like we offer in the SDK.
         const parentEvents = this.room.currentState.getStateEvents(EventType.SpaceParent);
         if (!parentEvents?.length) return true;
-        return parentEvents.every(e => !e.getContent()?.['via']);
+        return parentEvents.every((e) => !e.getContent()?.["via"]);
     }
 
     /**
@@ -134,7 +134,7 @@ export class MSC3089TreeSpace {
     public async invite(userId: string, andSubspaces = true, shareHistoryKeys = true): Promise<void> {
         const promises: Promise<void>[] = [this.retryInvite(userId)];
         if (andSubspaces) {
-            promises.push(...this.getDirectories().map(d => d.invite(userId, andSubspaces, shareHistoryKeys)));
+            promises.push(...this.getDirectories().map((d) => d.invite(userId, andSubspaces, shareHistoryKeys)));
         }
         return Promise.all(promises).then(() => {
             // Note: key sharing is default on because for file trees it is relatively important that the invite
@@ -150,7 +150,7 @@ export class MSC3089TreeSpace {
 
     private retryInvite(userId: string): Promise<void> {
         return simpleRetryOperation(async () => {
-            await this.client.invite(this.roomId, userId).catch(e => {
+            await this.client.invite(this.roomId, userId).catch((e) => {
                 // We don't want to retry permission errors forever...
                 if (e?.errcode === "M_FORBIDDEN") {
                     throw new promiseRetry.AbortError(e);
@@ -173,11 +173,11 @@ export class MSC3089TreeSpace {
         if (Array.isArray(currentPls)) throw new Error("Unexpected return type for power levels");
 
         const pls = currentPls?.getContent() || {};
-        const viewLevel = pls['users_default'] || 0;
-        const editLevel = pls['events_default'] || 50;
-        const adminLevel = pls['events']?.[EventType.RoomPowerLevels] || 100;
+        const viewLevel = pls["users_default"] || 0;
+        const editLevel = pls["events_default"] || 50;
+        const adminLevel = pls["events"]?.[EventType.RoomPowerLevels] || 100;
 
-        const users = pls['users'] || {};
+        const users = pls["users"] || {};
         switch (role) {
             case TreePermissions.Viewer:
                 users[userId] = viewLevel;
@@ -191,7 +191,7 @@ export class MSC3089TreeSpace {
             default:
                 throw new Error("Invalid role: " + role);
         }
-        pls['users'] = users;
+        pls["users"] = users;
 
         await this.client.sendStateEvent(this.roomId, EventType.RoomPowerLevels, pls, "");
     }
@@ -208,11 +208,11 @@ export class MSC3089TreeSpace {
         if (Array.isArray(currentPls)) throw new Error("Unexpected return type for power levels");
 
         const pls = currentPls?.getContent() || {};
-        const viewLevel = pls['users_default'] || 0;
-        const editLevel = pls['events_default'] || 50;
-        const adminLevel = pls['events']?.[EventType.RoomPowerLevels] || 100;
+        const viewLevel = pls["users_default"] || 0;
+        const editLevel = pls["events_default"] || 50;
+        const adminLevel = pls["events"]?.[EventType.RoomPowerLevels] || 100;
 
-        const userLevel = pls['users']?.[userId] || viewLevel;
+        const userLevel = pls["users"]?.[userId] || viewLevel;
         if (userLevel >= adminLevel) return TreePermissions.Owner;
         if (userLevel >= editLevel) return TreePermissions.Editor;
         return TreePermissions.Viewer;
@@ -226,13 +226,23 @@ export class MSC3089TreeSpace {
     public async createDirectory(name: string): Promise<MSC3089TreeSpace> {
         const directory = await this.client.unstableCreateFileTree(name);
 
-        await this.client.sendStateEvent(this.roomId, EventType.SpaceChild, {
-            via: [this.client.getDomain()],
-        }, directory.roomId);
-
-        await this.client.sendStateEvent(directory.roomId, EventType.SpaceParent, {
-            via: [this.client.getDomain()],
-        }, this.roomId);
+        await this.client.sendStateEvent(
+            this.roomId,
+            EventType.SpaceChild,
+            {
+                via: [this.client.getDomain()],
+            },
+            directory.roomId,
+        );
+
+        await this.client.sendStateEvent(
+            directory.roomId,
+            EventType.SpaceParent,
+            {
+                via: [this.client.getDomain()],
+            },
+            this.roomId,
+        );
 
         return directory;
     }
@@ -265,7 +275,7 @@ export class MSC3089TreeSpace {
      * @returns The directory, or undefined if not found.
      */
     public getDirectory(roomId: string): MSC3089TreeSpace | undefined {
-        return this.getDirectories().find(r => r.roomId === roomId);
+        return this.getDirectories().find((r) => r.roomId === roomId);
     }
 
     /**
@@ -294,10 +304,10 @@ export class MSC3089TreeSpace {
         await this.client.leave(this.roomId);
     }
 
-    private getOrderedChildren(children: MatrixEvent[]): { roomId: string, order: string }[] {
-        const ordered: { roomId: string, order: string }[] = children
-            .map(c => ({ roomId: c.getStateKey(), order: c.getContent()['order'] }))
-            .filter(c => c.roomId) as { roomId: string, order: string }[];
+    private getOrderedChildren(children: MatrixEvent[]): { roomId: string; order: string }[] {
+        const ordered: { roomId: string; order: string }[] = children
+            .map((c) => ({ roomId: c.getStateKey(), order: c.getContent()["order"] }))
+            .filter((c) => c.roomId) as { roomId: string; order: string }[];
         ordered.sort((a, b) => {
             if (a.order && !b.order) {
                 return -1;
@@ -306,7 +316,8 @@ export class MSC3089TreeSpace {
             } else if (!a.order && !b.order) {
                 const roomA = this.client.getRoom(a.roomId);
                 const roomB = this.client.getRoom(b.roomId);
-                if (!roomA || !roomB) { // just don't bother trying to do more partial sorting
+                if (!roomA || !roomB) {
+                    // just don't bother trying to do more partial sorting
                     return lexicographicCompare(a.roomId, b.roomId);
                 }
 
@@ -316,7 +327,8 @@ export class MSC3089TreeSpace {
                     return lexicographicCompare(a.roomId, b.roomId);
                 }
                 return createTsA - createTsB;
-            } else { // both not-null orders
+            } else {
+                // both not-null orders
                 return lexicographicCompare(a.order, b.order);
             }
         });
@@ -350,7 +362,7 @@ export class MSC3089TreeSpace {
         const children = parentRoom.currentState.getStateEvents(EventType.SpaceChild);
         const ordered = this.getOrderedChildren(children);
 
-        return ordered.findIndex(c => c.roomId === this.roomId);
+        return ordered.findIndex((c) => c.roomId === this.roomId);
     }
 
     /**
@@ -371,14 +383,14 @@ export class MSC3089TreeSpace {
 
         const currentIndex = this.getOrder();
         const movingUp = currentIndex < index;
-        if (movingUp && index === (ordered.length - 1)) {
+        if (movingUp && index === ordered.length - 1) {
             index--;
         } else if (!movingUp && index === 0) {
             index++;
         }
 
-        const prev = ordered[movingUp ? index : (index - 1)];
-        const next = ordered[movingUp ? (index + 1) : index];
+        const prev = ordered[movingUp ? index : index - 1];
+        const next = ordered[movingUp ? index + 1 : index];
 
         let newOrder = DEFAULT_ALPHABET[0];
         let ensureBeforeIsSane = false;
@@ -387,7 +399,7 @@ export class MSC3089TreeSpace {
             if (next?.order) {
                 newOrder = prevString(next.order);
             }
-        } else if (index === (ordered.length - 1)) {
+        } else if (index === ordered.length - 1) {
             // Move to back
             if (next?.order) {
                 newOrder = nextString(next.order);
@@ -435,10 +447,15 @@ export class MSC3089TreeSpace {
                     lastOrder = lastOrder ? nextString(lastOrder) : DEFAULT_ALPHABET[0];
                     const currentChild = parentRoom.currentState.getStateEvents(EventType.SpaceChild, target.roomId);
                     const content = currentChild?.getContent() ?? { via: [this.client.getDomain()] };
-                    await this.client.sendStateEvent(parentRoom.roomId, EventType.SpaceChild, {
-                        ...content,
-                        order: lastOrder,
-                    }, target.roomId);
+                    await this.client.sendStateEvent(
+                        parentRoom.roomId,
+                        EventType.SpaceChild,
+                        {
+                            ...content,
+                            order: lastOrder,
+                        },
+                        target.roomId,
+                    );
                 } else {
                     lastOrder = target.order;
                 }
@@ -453,12 +470,17 @@ export class MSC3089TreeSpace {
         // Now we can finally update our own order state
         const currentChild = parentRoom.currentState.getStateEvents(EventType.SpaceChild, this.roomId);
         const content = currentChild?.getContent() ?? { via: [this.client.getDomain()] };
-        await this.client.sendStateEvent(parentRoom.roomId, EventType.SpaceChild, {
-            ...content,
-
-            // TODO: Safely constrain to 50 character limit required by spaces.
-            order: newOrder,
-        }, this.roomId);
+        await this.client.sendStateEvent(
+            parentRoom.roomId,
+            EventType.SpaceChild,
+            {
+                ...content,
+
+                // TODO: Safely constrain to 50 character limit required by spaces.
+                order: newOrder,
+            },
+            this.roomId,
+        );
     }
 
     /**
@@ -502,10 +524,15 @@ export class MSC3089TreeSpace {
             [UNSTABLE_MSC3089_LEAF.name]: {},
         });
 
-        await this.client.sendStateEvent(this.roomId, UNSTABLE_MSC3089_BRANCH.name, {
-            active: true,
-            name: name,
-        }, res['event_id']);
+        await this.client.sendStateEvent(
+            this.roomId,
+            UNSTABLE_MSC3089_BRANCH.name,
+            {
+                active: true,
+                name: name,
+            },
+            res["event_id"],
+        );
 
         return res;
     }
@@ -525,7 +552,7 @@ export class MSC3089TreeSpace {
      * @returns The known files. May be empty, but not null.
      */
     public listFiles(): MSC3089Branch[] {
-        return this.listAllFiles().filter(b => b.isActive);
+        return this.listAllFiles().filter((b) => b.isActive);
     }
 
     /**
@@ -534,6 +561,6 @@ export class MSC3089TreeSpace {
      */
     public listAllFiles(): MSC3089Branch[] {
         const branches = this.room.currentState.getStateEvents(UNSTABLE_MSC3089_BRANCH.name) ?? [];
-        return branches.map(e => new MSC3089Branch(this.client, e, this));
+        return branches.map((e) => new MSC3089Branch(this.client, e, this));
     }
 }
diff --git a/src/models/beacon.ts b/src/models/beacon.ts
index 6e20b229bd5..6a1bb57c766 100644
--- a/src/models/beacon.ts
+++ b/src/models/beacon.ts
@@ -36,11 +36,8 @@ export type BeaconEventHandlerMap = {
     [BeaconEvent.Destroy]: (beaconIdentifier: string) => void;
 };
 
-export const isTimestampInDuration = (
-    startTimestamp: number,
-    durationMs: number,
-    timestamp: number,
-): boolean => timestamp >= startTimestamp && startTimestamp + durationMs >= timestamp;
+export const isTimestampInDuration = (startTimestamp: number, durationMs: number, timestamp: number): boolean =>
+    timestamp >= startTimestamp && startTimestamp + durationMs >= timestamp;
 
 // beacon info events are uniquely identified by
 // `<roomId>_<state_key>`
@@ -56,9 +53,7 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
     private livenessWatchTimeout?: ReturnType<typeof setTimeout>;
     private _latestLocationEvent?: MatrixEvent;
 
-    public constructor(
-        private rootEvent: MatrixEvent,
-    ) {
+    public constructor(private rootEvent: MatrixEvent) {
         super();
         this.setBeaconInfo(this.rootEvent);
         this.roomId = this.rootEvent.getRoomId()!;
@@ -98,7 +93,7 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
 
     public update(beaconInfoEvent: MatrixEvent): void {
         if (getBeaconInfoIdentifier(beaconInfoEvent) !== this.identifier) {
-            throw new Error('Invalid updating event');
+            throw new Error("Invalid updating event");
         }
         // don't update beacon with an older event
         if (beaconInfoEvent.getTs() < this.rootEvent.getTs()) {
@@ -132,20 +127,18 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
         this.checkLiveness();
         if (!this.beaconInfo) return;
         if (this.isLive) {
-            const expiryInMs = (this.beaconInfo.timestamp! + this.beaconInfo.timeout) - Date.now();
+            const expiryInMs = this.beaconInfo.timestamp! + this.beaconInfo.timeout - Date.now();
             if (expiryInMs > 1) {
-                this.livenessWatchTimeout = setTimeout(
-                    () => { this.monitorLiveness(); },
-                    expiryInMs,
-                );
+                this.livenessWatchTimeout = setTimeout(() => {
+                    this.monitorLiveness();
+                }, expiryInMs);
             }
         } else if (this.beaconInfo.timestamp! > Date.now()) {
             // beacon start timestamp is in the future
             // check liveness again then
-            this.livenessWatchTimeout = setTimeout(
-                () => { this.monitorLiveness(); },
-                this.beaconInfo.timestamp! - Date.now(),
-            );
+            this.livenessWatchTimeout = setTimeout(() => {
+                this.monitorLiveness();
+            }, this.beaconInfo.timestamp! - Date.now());
         }
     }
 
@@ -159,7 +152,7 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
             return;
         }
 
-        const validLocationEvents = beaconLocationEvents.filter(event => {
+        const validLocationEvents = beaconLocationEvents.filter((event) => {
             const content = event.getContent<MBeaconEventContent>();
             const parsed = parseBeaconContent(content);
             if (!parsed.uri || !parsed.timestamp) return false; // we won't be able to process these
@@ -198,10 +191,13 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
         // may have a start timestamp in the future from Bob's POV
         // handle this by adding 6min of leniency to the start timestamp when it is in the future
         if (!this.beaconInfo) return;
-        const startTimestamp = this.beaconInfo.timestamp! > Date.now() ?
-            this.beaconInfo.timestamp! - 360000 /* 6min */ :
-            this.beaconInfo.timestamp;
-        this._isLive = !!this._beaconInfo?.live && !!startTimestamp &&
+        const startTimestamp =
+            this.beaconInfo.timestamp! > Date.now()
+                ? this.beaconInfo.timestamp! - 360000 /* 6min */
+                : this.beaconInfo.timestamp;
+        this._isLive =
+            !!this._beaconInfo?.live &&
+            !!startTimestamp &&
             isTimestampInDuration(startTimestamp, this._beaconInfo?.timeout, Date.now());
 
         if (prevLiveness !== this.isLive) {
diff --git a/src/models/event-timeline-set.ts b/src/models/event-timeline-set.ts
index e1da746c993..5cb04997e8b 100644
--- a/src/models/event-timeline-set.ts
+++ b/src/models/event-timeline-set.ts
@@ -16,7 +16,7 @@ limitations under the License.
 
 import { EventTimeline, IAddEventOptions } from "./event-timeline";
 import { MatrixEvent } from "./event";
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { Room, RoomEvent } from "./room";
 import { Filter } from "../filter";
 import { RoomState } from "./room-state";
@@ -34,7 +34,7 @@ if (DEBUG) {
     debuglog = logger.log.bind(logger);
 } else {
     /* istanbul ignore next */
-    debuglog = function(): void {};
+    debuglog = function (): void {};
 }
 
 interface IOpts {
@@ -58,13 +58,13 @@ export interface IRoomTimelineData {
 }
 
 export interface IAddEventToTimelineOptions
-    extends Pick<IAddEventOptions, 'toStartOfTimeline' | 'roomState' | 'timelineWasEmpty'> {
+    extends Pick<IAddEventOptions, "toStartOfTimeline" | "roomState" | "timelineWasEmpty"> {
     /** Whether the sync response came from cache */
     fromCache?: boolean;
 }
 
 export interface IAddLiveEventOptions
-    extends Pick<IAddEventToTimelineOptions, 'fromCache' | 'roomState' | 'timelineWasEmpty'> {
+    extends Pick<IAddEventToTimelineOptions, "fromCache" | "roomState" | "timelineWasEmpty"> {
     /** Applies to events in the timeline only. If this is 'replace' then if a
      * duplicate is encountered, the event passed to this function will replace
      * the existing event in the timeline. If this is not specified, or is
@@ -291,9 +291,9 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         const resetAllTimelines = !this.timelineSupport || !forwardPaginationToken;
 
         const oldTimeline = this.liveTimeline;
-        const newTimeline = resetAllTimelines ?
-            oldTimeline.forkLive(EventTimeline.FORWARDS) :
-            oldTimeline.fork(EventTimeline.FORWARDS);
+        const newTimeline = resetAllTimelines
+            ? oldTimeline.forkLive(EventTimeline.FORWARDS)
+            : oldTimeline.fork(EventTimeline.FORWARDS);
 
         if (resetAllTimelines) {
             this.timelines = [newTimeline];
@@ -326,9 +326,11 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * the given event, or null if unknown
      */
     public getTimelineForEvent(eventId?: string): EventTimeline | null {
-        if (eventId === null || eventId === undefined) { return null; }
+        if (eventId === null || eventId === undefined) {
+            return null;
+        }
         const res = this._eventIdToTimeline.get(eventId);
-        return (res === undefined) ? null : res;
+        return res === undefined ? null : res;
     }
 
     /**
@@ -342,7 +344,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         if (!tl) {
             return undefined;
         }
-        return tl.getEvents().find(function(ev) {
+        return tl.getEvents().find(function (ev) {
             return ev.getId() == eventId;
         });
     }
@@ -354,9 +356,11 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      */
     public addTimeline(): EventTimeline {
         if (!this.timelineSupport) {
-            throw new Error("timeline support is disabled. Set the 'timelineSupport'" +
-                " parameter to true when creating MatrixClient to enable" +
-                " it.");
+            throw new Error(
+                "timeline support is disabled. Set the 'timelineSupport'" +
+                    " parameter to true when creating MatrixClient to enable" +
+                    " it.",
+            );
         }
 
         const timeline = new EventTimeline(this);
@@ -391,15 +395,13 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         paginationToken?: string | null,
     ): void {
         if (!timeline) {
-            throw new Error(
-                "'timeline' not specified for EventTimelineSet.addEventsToTimeline",
-            );
+            throw new Error("'timeline' not specified for EventTimelineSet.addEventsToTimeline");
         }
 
         if (!toStartOfTimeline && timeline == this.liveTimeline) {
             throw new Error(
                 "EventTimelineSet.addEventsToTimeline cannot be used for adding events to " +
-                "the live timeline - use Room.addLiveEvents instead",
+                    "the live timeline - use Room.addLiveEvents instead",
             );
         }
 
@@ -410,10 +412,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             }
         }
 
-        const direction = toStartOfTimeline ? EventTimeline.BACKWARDS :
-            EventTimeline.FORWARDS;
-        const inverseDirection = toStartOfTimeline ? EventTimeline.FORWARDS :
-            EventTimeline.BACKWARDS;
+        const direction = toStartOfTimeline ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS;
+        const inverseDirection = toStartOfTimeline ? EventTimeline.FORWARDS : EventTimeline.BACKWARDS;
 
         // Adding events to timelines can be quite complicated. The following
         // illustrates some of the corner-cases.
@@ -520,20 +520,18 @@ 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;
             }
 
             // time to join the timelines.
-            logger.info("Already have timeline for " + eventId +
-                " - joining timeline " + timeline + " to " +
-                existingTimeline);
+            logger.info(
+                "Already have timeline for " + eventId + " - joining timeline " + timeline + " to " + existingTimeline,
+            );
 
             // Variables to keep the line length limited below.
             const existingIsLive = existingTimeline === this.liveTimeline;
@@ -548,13 +546,17 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
                 if (backwardsIsLive) {
                     logger.warn(
                         "Refusing to set a preceding existingTimeLine on our " +
-                        "timeline as the existingTimeLine is live (" + existingTimeline + ")",
+                            "timeline as the existingTimeLine is live (" +
+                            existingTimeline +
+                            ")",
                     );
                 }
                 if (forwardsIsLive) {
                     logger.warn(
                         "Refusing to set our preceding timeline on a existingTimeLine " +
-                        "as our timeline is live (" + timeline + ")",
+                            "as our timeline is live (" +
+                            timeline +
+                            ")",
                     );
                 }
                 continue; // abort splicing - try next event
@@ -574,8 +576,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;
             }
@@ -591,12 +592,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      */
     public addLiveEvent(
         event: MatrixEvent,
-        {
-            duplicateStrategy,
-            fromCache,
-            roomState,
-            timelineWasEmpty,
-        }: IAddLiveEventOptions,
+        { duplicateStrategy, fromCache, roomState, timelineWasEmpty }: IAddLiveEventOptions,
     ): void;
     /**
      * @deprecated In favor of the overload with `IAddLiveEventOptions`
@@ -613,9 +609,9 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         fromCache = false,
         roomState?: RoomState,
     ): void {
-        let duplicateStrategy = duplicateStrategyOrOpts as DuplicateStrategy || DuplicateStrategy.Ignore;
+        let duplicateStrategy = (duplicateStrategyOrOpts as DuplicateStrategy) || DuplicateStrategy.Ignore;
         let timelineWasEmpty: boolean | undefined;
-        if (typeof (duplicateStrategyOrOpts) === 'object') {
+        if (typeof duplicateStrategyOrOpts === "object") {
             ({
                 duplicateStrategy = DuplicateStrategy.Ignore,
                 fromCache = false,
@@ -626,10 +622,10 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             // Deprecation warning
             // FIXME: Remove after 2023-06-01 (technical debt)
             logger.warn(
-                'Overload deprecated: ' +
-                '`EventTimelineSet.addLiveEvent(event, duplicateStrategy?, fromCache?, roomState?)` ' +
-                'is deprecated in favor of the overload with ' +
-                '`EventTimelineSet.addLiveEvent(event, IAddLiveEventOptions)`',
+                "Overload deprecated: " +
+                    "`EventTimelineSet.addLiveEvent(event, duplicateStrategy?, fromCache?, roomState?)` " +
+                    "is deprecated in favor of the overload with " +
+                    "`EventTimelineSet.addLiveEvent(event, IAddLiveEventOptions)`",
             );
         }
 
@@ -651,11 +647,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
                         if (!roomState) {
                             roomState = timeline.getState(EventTimeline.FORWARDS);
                         }
-                        EventTimeline.setEventMetadata(
-                            event,
-                            roomState!,
-                            false,
-                        );
+                        EventTimeline.setEventMetadata(event, roomState!, false);
                         tlEvents[j] = event;
 
                         // XXX: we need to fire an event when this happens.
@@ -690,12 +682,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     public addEventToTimeline(
         event: MatrixEvent,
         timeline: EventTimeline,
-        {
-            toStartOfTimeline,
-            fromCache,
-            roomState,
-            timelineWasEmpty,
-        }: IAddEventToTimelineOptions,
+        { toStartOfTimeline, fromCache, roomState, timelineWasEmpty }: IAddEventToTimelineOptions,
     ): void;
     /**
      * @deprecated In favor of the overload with `IAddEventToTimelineOptions`
@@ -716,16 +703,16 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     ): void {
         let toStartOfTimeline = !!toStartOfTimelineOrOpts;
         let timelineWasEmpty: boolean | undefined;
-        if (typeof (toStartOfTimelineOrOpts) === 'object') {
+        if (typeof toStartOfTimelineOrOpts === "object") {
             ({ toStartOfTimeline, fromCache = false, roomState, timelineWasEmpty } = toStartOfTimelineOrOpts);
         } else if (toStartOfTimelineOrOpts !== undefined) {
             // Deprecation warning
             // FIXME: Remove after 2023-06-01 (technical debt)
             logger.warn(
-                'Overload deprecated: ' +
-                '`EventTimelineSet.addEventToTimeline(event, timeline, toStartOfTimeline, fromCache?, roomState?)` ' +
-                'is deprecated in favor of the overload with ' +
-                '`EventTimelineSet.addEventToTimeline(event, timeline, IAddEventToTimelineOptions)`',
+                "Overload deprecated: " +
+                    "`EventTimelineSet.addEventToTimeline(event, timeline, toStartOfTimeline, fromCache?, roomState?)` " +
+                    "is deprecated in favor of the overload with " +
+                    "`EventTimelineSet.addEventToTimeline(event, timeline, IAddEventToTimelineOptions)`",
             );
         }
 
@@ -746,7 +733,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             }
             logger.warn(
                 `EventTimelineSet.addEventToTimeline: Ignoring ${eventDebugString} that does not belong ` +
-                `in timeline=${timeline.toString()} timelineSet(threadId=${this.thread?.id})`,
+                    `in timeline=${timeline.toString()} timelineSet(threadId=${this.thread?.id})`,
             );
             return;
         }
@@ -780,11 +767,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * @remarks
      * Fires {@link RoomEvent.Timeline}
      */
-    public handleRemoteEcho(
-        localEvent: MatrixEvent,
-        oldEventId: string,
-        newEventId: string,
-    ): void {
+    public handleRemoteEcho(localEvent: MatrixEvent, oldEventId: string, newEventId: string): void {
         // XXX: why don't we infer newEventId from localEvent?
         const existingTimeline = this._eventIdToTimeline.get(oldEventId);
         if (existingTimeline) {
@@ -855,8 +838,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             let idx1: number | undefined = undefined;
             let idx2: number | undefined = undefined;
             const events = timeline1.getEvents();
-            for (let idx = 0; idx < events.length &&
-            (idx1 === undefined || idx2 === undefined); idx++) {
+            for (let idx = 0; idx < events.length && (idx1 === undefined || idx2 === undefined); idx++) {
                 const evId = events[idx].getId();
                 if (evId == eventId1) {
                     idx1 = idx;
@@ -908,8 +890,10 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      */
     public canContain(event: MatrixEvent): boolean {
         if (!this.room) {
-            throw new Error("Cannot call `EventTimelineSet::canContain without a `room` set. " +
-                "Set the room when creating the EventTimelineSet to call this method.");
+            throw new Error(
+                "Cannot call `EventTimelineSet::canContain without a `room` set. " +
+                    "Set the room when creating the EventTimelineSet to call this method.",
+            );
         }
 
         const { threadId, shouldLiveInRoom } = this.room.eventShouldLiveIn(event);
diff --git a/src/models/event-timeline.ts b/src/models/event-timeline.ts
index ad97a4ef27a..d1ba3210365 100644
--- a/src/models/event-timeline.ts
+++ b/src/models/event-timeline.ts
@@ -14,14 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { IMarkerFoundOptions, RoomState } from "./room-state";
 import { EventTimelineSet } from "./event-timeline-set";
 import { MatrixEvent } from "./event";
 import { Filter } from "../filter";
 import { EventType } from "../@types/event";
 
-export interface IInitialiseStateOptions extends Pick<IMarkerFoundOptions, 'timelineWasEmpty'> {
+export interface IInitialiseStateOptions extends Pick<IMarkerFoundOptions, "timelineWasEmpty"> {
     // This is a separate interface without any extra stuff currently added on
     // top of `IMarkerFoundOptions` just because it feels like they have
     // different concerns. One shouldn't necessarily look to add to
@@ -29,7 +29,7 @@ export interface IInitialiseStateOptions extends Pick<IMarkerFoundOptions, 'time
     // `initialiseState`.
 }
 
-export interface IAddEventOptions extends Pick<IMarkerFoundOptions, 'timelineWasEmpty'> {
+export interface IAddEventOptions extends Pick<IMarkerFoundOptions, "timelineWasEmpty"> {
     /** Whether to insert the new event at the start of the timeline where the
      * oldest events are (timeline is in chronological order, oldest to most
      * recent) */
@@ -133,7 +133,7 @@ export class EventTimeline {
         }
 
         // this is used by client.js
-        this.paginationRequests = { 'b': null, 'f': null };
+        this.paginationRequests = { b: null, f: null };
 
         this.name = this.roomId + ":" + new Date().toISOString();
     }
@@ -335,8 +335,12 @@ export class EventTimeline {
      */
     public setNeighbouringTimeline(neighbour: EventTimeline, direction: Direction): void {
         if (this.getNeighbouringTimeline(direction)) {
-            throw new Error("timeline already has a neighbouring timeline - " +
-                "cannot reset neighbour (direction: " + direction + ")");
+            throw new Error(
+                "timeline already has a neighbouring timeline - " +
+                    "cannot reset neighbour (direction: " +
+                    direction +
+                    ")",
+            );
         }
 
         if (direction == EventTimeline.BACKWARDS) {
@@ -357,22 +361,11 @@ export class EventTimeline {
      * @param event - new event
      * @param options - addEvent options
      */
-    public addEvent(
-        event: MatrixEvent,
-        {
-            toStartOfTimeline,
-            roomState,
-            timelineWasEmpty,
-        }: IAddEventOptions,
-    ): void;
+    public addEvent(event: MatrixEvent, { toStartOfTimeline, roomState, timelineWasEmpty }: IAddEventOptions): void;
     /**
      * @deprecated In favor of the overload with `IAddEventOptions`
      */
-    public addEvent(
-        event: MatrixEvent,
-        toStartOfTimeline: boolean,
-        roomState?: RoomState
-    ): void;
+    public addEvent(event: MatrixEvent, toStartOfTimeline: boolean, roomState?: RoomState): void;
     public addEvent(
         event: MatrixEvent,
         toStartOfTimelineOrOpts: boolean | IAddEventOptions,
@@ -380,15 +373,15 @@ export class EventTimeline {
     ): void {
         let toStartOfTimeline = !!toStartOfTimelineOrOpts;
         let timelineWasEmpty: boolean | undefined;
-        if (typeof (toStartOfTimelineOrOpts) === 'object') {
+        if (typeof toStartOfTimelineOrOpts === "object") {
             ({ toStartOfTimeline, roomState, timelineWasEmpty } = toStartOfTimelineOrOpts);
         } else if (toStartOfTimelineOrOpts !== undefined) {
             // Deprecation warning
             // FIXME: Remove after 2023-06-01 (technical debt)
             logger.warn(
-                'Overload deprecated: ' +
-                '`EventTimeline.addEvent(event, toStartOfTimeline, roomState?)` ' +
-                'is deprecated in favor of the overload with `EventTimeline.addEvent(event, IAddEventOptions)`',
+                "Overload deprecated: " +
+                    "`EventTimeline.addEvent(event, toStartOfTimeline, roomState?)` " +
+                    "is deprecated in favor of the overload with `EventTimeline.addEvent(event, IAddEventOptions)`",
             );
         }
 
@@ -402,10 +395,7 @@ export class EventTimeline {
             EventTimeline.setEventMetadata(event, roomState!, toStartOfTimeline);
 
             // modify state but only on unfiltered timelineSets
-            if (
-                event.isState() &&
-                timelineSet.room.getUnfilteredTimelineSet() === timelineSet
-            ) {
+            if (event.isState() && timelineSet.room.getUnfilteredTimelineSet() === timelineSet) {
                 roomState?.setStateEvents([event], { timelineWasEmpty });
                 // it is possible that the act of setting the state event means we
                 // can set more metadata (specifically sender/target props), so try
diff --git a/src/models/event.ts b/src/models/event.ts
index 2b082f9b6dc..c4910e752c1 100644
--- a/src/models/event.ts
+++ b/src/models/event.ts
@@ -21,15 +21,15 @@ limitations under the License.
 
 import { ExtensibleEvent, ExtensibleEvents, Optional } from "matrix-events-sdk";
 
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { VerificationRequest } from "../crypto/verification/request/VerificationRequest";
 import { EVENT_VISIBILITY_CHANGE_TYPE, EventType, MsgType, RelationType } from "../@types/event";
 import { Crypto, IEventDecryptionResult } from "../crypto";
 import { deepSortedObjectEntries, internaliseString } from "../utils";
 import { RoomMember } from "./room-member";
 import { Thread, ThreadEvent, EventHandlerMap as ThreadEventHandlerMap, THREAD_RELATION_TYPE } from "./thread";
-import { IActionsObject } from '../pushprocessor';
-import { TypedReEmitter } from '../ReEmitter';
+import { IActionsObject } from "../pushprocessor";
+import { TypedReEmitter } from "../ReEmitter";
 import { MatrixError } from "../http-api";
 import { TypedEventEmitter } from "./typed-event-emitter";
 import { EventStatus } from "./event-status";
@@ -40,22 +40,22 @@ export { EventStatus } from "./event-status";
 /* eslint-disable camelcase */
 export interface IContent {
     [key: string]: any;
-    msgtype?: MsgType | string;
-    membership?: string;
-    avatar_url?: string;
-    displayname?: string;
+    "msgtype"?: MsgType | string;
+    "membership"?: string;
+    "avatar_url"?: string;
+    "displayname"?: string;
     "m.relates_to"?: IEventRelation;
 }
 
 type StrippedState = Required<Pick<IEvent, "content" | "state_key" | "type" | "sender">>;
 
 export interface IUnsigned {
-    age?: number;
-    prev_sender?: string;
-    prev_content?: IContent;
-    redacted_because?: IEvent;
-    transaction_id?: string;
-    invite_room_state?: StrippedState[];
+    "age"?: number;
+    "prev_sender"?: string;
+    "prev_content"?: IContent;
+    "redacted_because"?: IEvent;
+    "transaction_id"?: string;
+    "invite_room_state"?: StrippedState[];
     "m.relations"?: Record<RelationType | string, any>; // No common pattern for aggregated relations
 }
 
@@ -102,13 +102,13 @@ export interface IAggregatedRelation {
 }
 
 export interface IEventRelation {
-    rel_type?: RelationType | string;
-    event_id?: string;
-    is_falling_back?: boolean;
+    "rel_type"?: RelationType | string;
+    "event_id"?: string;
+    "is_falling_back"?: boolean;
     "m.in_reply_to"?: {
         event_id?: string;
     };
-    key?: string;
+    "key"?: string;
 }
 
 /**
@@ -560,13 +560,12 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * @experimental
      */
     public get isThreadRoot(): boolean {
-        const threadDetails = this
-            .getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
+        const threadDetails = this.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
 
         // Bundled relationships only returned when the sync response is limited
         // hence us having to check both bundled relation and inspect the thread
         // model
-        return !!threadDetails || (this.getThread()?.id === this.getId());
+        return !!threadDetails || this.getThread()?.id === this.getId();
     }
 
     public get replyEventId(): string | undefined {
@@ -575,14 +574,12 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         // can't just rely on ev.getContent() by itself because historically we
         // still show the reply from the original message even though the edit
         // event does not include the relation reply.
-        const mRelatesTo = this.getContent()['m.relates_to'] || this.getWireContent()['m.relates_to'];
-        return mRelatesTo?.['m.in_reply_to']?.event_id;
+        const mRelatesTo = this.getContent()["m.relates_to"] || this.getWireContent()["m.relates_to"];
+        return mRelatesTo?.["m.in_reply_to"]?.event_id;
     }
 
     public get relationEventId(): string | undefined {
-        return this.getWireContent()
-            ?.["m.relates_to"]
-            ?.event_id;
+        return this.getWireContent()?.["m.relates_to"]?.event_id;
     }
 
     /**
@@ -738,9 +735,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         const forceRedecrypt = options.forceRedecryptIfUntrusted && this.isKeySourceUntrusted();
         if (alreadyDecrypted && !forceRedecrypt) {
             // we may want to just ignore this? let's start with rejecting it.
-            throw new Error(
-                "Attempt to decrypt event which has already been decrypted",
-            );
+            throw new Error("Attempt to decrypt event which has already been decrypted");
         }
 
         // if we already have a decryption attempt in progress, then it may
@@ -750,9 +745,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         // new info.
         //
         if (this.decryptionPromise) {
-            logger.log(
-                `Event ${this.getId()} already being decrypted; queueing a retry`,
-            );
+            logger.log(`Event ${this.getId()} already being decrypted; queueing a retry`);
             this.retryDecryption = true;
             return this.decryptionPromise;
         }
@@ -771,12 +764,16 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      */
     public cancelAndResendKeyRequest(crypto: Crypto, userId: string): Promise<void> {
         const wireContent = this.getWireContent();
-        return crypto.requestRoomKey({
-            algorithm: wireContent.algorithm,
-            room_id: this.getRoomId()!,
-            session_id: wireContent.session_id,
-            sender_key: wireContent.sender_key,
-        }, this.getKeyRequestRecipients(userId), true);
+        return crypto.requestRoomKey(
+            {
+                algorithm: wireContent.algorithm,
+                room_id: this.getRoomId()!,
+                session_id: wireContent.session_id,
+                sender_key: wireContent.sender_key,
+            },
+            this.getKeyRequestRecipients(userId),
+            true,
+        );
     }
 
     /**
@@ -790,10 +787,12 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         // send the request to all of our own devices, and the
         // original sending device if it wasn't us.
         const wireContent = this.getWireContent();
-        const recipients = [{
-            userId,
-            deviceId: '*',
-        }];
+        const recipients = [
+            {
+                userId,
+                deviceId: "*",
+            },
+        ];
         const sender = this.getSender();
         if (sender !== userId) {
             recipients.push({
@@ -830,7 +829,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
                 if ((<Error>e).name !== "DecryptionError") {
                     // not a decryption error: log the whole exception as an error
                     // (and don't bother with a retry)
-                    const re = options.isRetry ? 're' : '';
+                    const re = options.isRetry ? "re" : "";
                     // For find results: this can produce "Error decrypting event (id=$ev)" and
                     // "Error redecrypting event (id=$ev)".
                     logger.error(`Error ${re}decrypting event (${this.getDetails()})`, e);
@@ -859,7 +858,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
                     // decryption error, but we have a retry queued.
                     logger.log(
                         `Error decrypting event (${this.getDetails()}), but retrying: ` +
-                        (<DecryptionError>e).detailedString,
+                            (<DecryptionError>e).detailedString,
                     );
                     continue;
                 }
@@ -869,10 +868,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
                 //
                 // the detailedString already includes the name and message of the error, and the stack isn't much use,
                 // so we don't bother to log `e` separately.
-                logger.warn(
-                    `Error decrypting event (${this.getDetails()}): ` +
-                    (<DecryptionError>e).detailedString,
-                );
+                logger.warn(`Error decrypting event (${this.getDetails()}): ` + (<DecryptionError>e).detailedString);
 
                 res = this.badEncryptedMessage((<DecryptionError>e).message);
             }
@@ -935,8 +931,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         this.clearEvent = decryptionResult.clearEvent;
         this.senderCurve25519Key = decryptionResult.senderCurve25519Key ?? null;
         this.claimedEd25519Key = decryptionResult.claimedEd25519Key ?? null;
-        this.forwardingCurve25519KeyChain =
-            decryptionResult.forwardingCurve25519KeyChain || [];
+        this.forwardingCurve25519KeyChain = decryptionResult.forwardingCurve25519KeyChain || [];
         this.untrusted = decryptionResult.untrusted || false;
         this.invalidateExtensibleEvent();
     }
@@ -1145,9 +1140,10 @@ 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() as keyof typeof REDACT_KEEP_CONTENT_MAP]
+                : {};
         const content = this.getContent();
         for (const key in content) {
             if (content.hasOwnProperty(key) && !keeps[key]) {
@@ -1511,7 +1507,8 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     public toSnapshot(): MatrixEvent {
         const ev = new MatrixEvent(JSON.parse(JSON.stringify(this.event)));
         for (const [p, v] of Object.entries(this)) {
-            if (p !== "event") { // exclude the thing we just cloned
+            if (p !== "event") {
+                // exclude the thing we just cloned
                 // @ts-ignore - XXX: this is just nasty
                 ev[p as keyof MatrixEvent] = v;
             }
@@ -1606,18 +1603,31 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
  *  - We keep user_id for backwards-compat with v1
  */
 const REDACT_KEEP_KEYS = new Set([
-    'event_id', 'type', 'room_id', 'user_id', 'sender', 'state_key', 'prev_state',
-    'content', 'unsigned', 'origin_server_ts',
+    "event_id",
+    "type",
+    "room_id",
+    "user_id",
+    "sender",
+    "state_key",
+    "prev_state",
+    "content",
+    "unsigned",
+    "origin_server_ts",
 ]);
 
 // a map from state event type to the .content keys we keep when an event is redacted
 const REDACT_KEEP_CONTENT_MAP: Record<string, Record<string, 1>> = {
-    [EventType.RoomMember]: { 'membership': 1 },
-    [EventType.RoomCreate]: { 'creator': 1 },
-    [EventType.RoomJoinRules]: { 'join_rule': 1 },
+    [EventType.RoomMember]: { membership: 1 },
+    [EventType.RoomCreate]: { creator: 1 },
+    [EventType.RoomJoinRules]: { join_rule: 1 },
     [EventType.RoomPowerLevels]: {
-        'ban': 1, 'events': 1, 'events_default': 1,
-        'kick': 1, 'redact': 1, 'state_default': 1,
-        'users': 1, 'users_default': 1,
+        ban: 1,
+        events: 1,
+        events_default: 1,
+        kick: 1,
+        redact: 1,
+        state_default: 1,
+        users: 1,
+        users_default: 1,
     },
 } as const;
diff --git a/src/models/invites-ignorer.ts b/src/models/invites-ignorer.ts
index c17d22f9f9e..173ba620d9b 100644
--- a/src/models/invites-ignorer.ts
+++ b/src/models/invites-ignorer.ts
@@ -31,8 +31,10 @@ export const POLICIES_ACCOUNT_EVENT_TYPE = new UnstableValue("m.policies", "org.
 /// The key within the user's individual policies storing the user's ignored invites.
 ///
 /// Exported for testing purposes.
-export const IGNORE_INVITES_ACCOUNT_EVENT_KEY = new UnstableValue("m.ignore.invites",
-    "org.matrix.msc3847.ignore.invites");
+export const IGNORE_INVITES_ACCOUNT_EVENT_KEY = new UnstableValue(
+    "m.ignore.invites",
+    "org.matrix.msc3847.ignore.invites",
+);
 
 /// The types of recommendations understood.
 enum PolicyRecommendation {
@@ -73,10 +75,7 @@ export enum PolicyScope {
  * our data structures.
  */
 export class IgnoredInvites {
-    public constructor(
-        private readonly client: MatrixClient,
-    ) {
-    }
+    public constructor(private readonly client: MatrixClient) {}
 
     /**
      * Add a new rule.
@@ -125,13 +124,12 @@ export class IgnoredInvites {
         // of the racy section.
         await this.client.joinRoom(roomId);
         // Race starts.
-        const sources = (await this.getOrCreateSourceRooms())
-            .map(room => room.roomId);
+        const sources = (await this.getOrCreateSourceRooms()).map((room) => room.roomId);
         if (sources.includes(roomId)) {
             return false;
         }
         sources.push(roomId);
-        await this.withIgnoreInvitesPolicies(ignoreInvitesPolicies => {
+        await this.withIgnoreInvitesPolicies((ignoreInvitesPolicies) => {
             ignoreInvitesPolicies.sources = sources;
         });
 
@@ -146,7 +144,10 @@ export class IgnoredInvites {
      * @param roomId - The room to which the user is invited.
      * @returns A rule matching the entity, if any was found, `null` otherwise.
      */
-    public async getRuleForInvite({ sender, roomId }: {
+    public async getRuleForInvite({
+        sender,
+        roomId,
+    }: {
         sender: string;
         roomId: string;
     }): Promise<Readonly<MatrixEvent | null>> {
@@ -234,11 +235,13 @@ export class IgnoredInvites {
             }
         }
         // We need to create our own policy room for ignoring invites.
-        target = (await this.client.createRoom({
-            name: "Individual Policy Room",
-            preset: Preset.PrivateChat,
-        })).room_id;
-        await this.withIgnoreInvitesPolicies(ignoreInvitesPolicies => {
+        target = (
+            await this.client.createRoom({
+                name: "Individual Policy Room",
+                preset: Preset.PrivateChat,
+            })
+        ).room_id;
+        await this.withIgnoreInvitesPolicies((ignoreInvitesPolicies) => {
             ignoreInvitesPolicies.target = target;
         });
 
@@ -274,9 +277,9 @@ export class IgnoredInvites {
         }
         let sourceRooms = sources
             // `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((roomId) => typeof roomId === "string")
+            .map((roomId) => this.client.getRoom(roomId))
+            .filter((room) => !!room) as Room[];
         if (sourceRooms.length != sources.length) {
             hasChanges = true;
         }
@@ -290,7 +293,7 @@ export class IgnoredInvites {
         if (hasChanges) {
             // Reload `policies`/`ignoreInvitesPolicies` in case it has been changed
             // during or by our call to `this.getTargetRoom()`.
-            await this.withIgnoreInvitesPolicies(ignoreInvitesPolicies => {
+            await this.withIgnoreInvitesPolicies((ignoreInvitesPolicies) => {
                 ignoreInvitesPolicies.sources = sources;
             });
         }
@@ -307,14 +310,16 @@ export class IgnoredInvites {
      *
      * @returns A non-null object.
      */
-    private getIgnoreInvitesPolicies(): {[key: string]: any} {
+    private getIgnoreInvitesPolicies(): { [key: string]: any } {
         return this.getPoliciesAndIgnoreInvitesPolicies().ignoreInvitesPolicies;
     }
 
     /**
      * Modify in place the `IGNORE_INVITES_POLICIES` object from account data.
      */
-    private async withIgnoreInvitesPolicies(cb: (ignoreInvitesPolicies: {[key: string]: any}) => void): Promise<void> {
+    private async withIgnoreInvitesPolicies(
+        cb: (ignoreInvitesPolicies: { [key: string]: any }) => void,
+    ): Promise<void> {
         const { policies, ignoreInvitesPolicies } = this.getPoliciesAndIgnoreInvitesPolicies();
         cb(ignoreInvitesPolicies);
         policies[IGNORE_INVITES_ACCOUNT_EVENT_KEY.name] = ignoreInvitesPolicies;
@@ -325,8 +330,10 @@ export class IgnoredInvites {
      * As `getIgnoreInvitesPolicies` but also return the `POLICIES_ACCOUNT_EVENT_TYPE`
      * object.
      */
-    private getPoliciesAndIgnoreInvitesPolicies():
-        {policies: {[key: string]: any}, ignoreInvitesPolicies: {[key: string]: any}} {
+    private getPoliciesAndIgnoreInvitesPolicies(): {
+        policies: { [key: string]: any };
+        ignoreInvitesPolicies: { [key: string]: any };
+    } {
         let policies: IContent = {};
         for (const key of [POLICIES_ACCOUNT_EVENT_TYPE.name, POLICIES_ACCOUNT_EVENT_TYPE.altName]) {
             if (!key) {
diff --git a/src/models/read-receipt.ts b/src/models/read-receipt.ts
index afea2ebdf99..1cfe9adfc16 100644
--- a/src/models/read-receipt.ts
+++ b/src/models/read-receipt.ts
@@ -69,7 +69,9 @@ export abstract class ReadReceipt<
      * @returns the latest receipts of the chosen type for the chosen user
      */
     public getReadReceiptForUserId(
-        userId: string, ignoreSynthesized = false, receiptType = ReceiptType.Read,
+        userId: string,
+        ignoreSynthesized = false,
+        receiptType = ReceiptType.Read,
     ): WrappedReceipt | null {
         const [realReceipt, syntheticReceipt] = this.receipts[receiptType]?.[userId] ?? [];
         if (ignoreSynthesized) {
@@ -113,7 +115,7 @@ export abstract class ReadReceipt<
         if (!comparison) return privateReadReceipt?.eventId ?? publicReadReceipt?.eventId ?? null;
 
         // If public read receipt is older, return the private one
-        return ((comparison < 0) ? privateReadReceipt?.eventId : publicReadReceipt?.eventId) ?? null;
+        return (comparison < 0 ? privateReadReceipt?.eventId : publicReadReceipt?.eventId) ?? null;
     }
 
     public addReceiptToStructure(
@@ -140,10 +142,7 @@ export abstract class ReadReceipt<
         if (existingReceipt) {
             // we only want to add this receipt if we think it is later than the one we already have.
             // This is managed server-side, but because we synthesize RRs locally we have to do it here too.
-            const ordering = this.getUnfilteredTimelineSet().compareEventOrdering(
-                existingReceipt.eventId,
-                eventId,
-            );
+            const ordering = this.getUnfilteredTimelineSet().compareEventOrdering(existingReceipt.eventId, eventId);
             if (ordering !== null && ordering >= 0) {
                 return;
             }
@@ -188,11 +187,9 @@ export abstract class ReadReceipt<
         if (cachedReceipt && this.receiptCacheByEventId[cachedReceipt.eventId]) {
             const previousEventId = cachedReceipt.eventId;
             // Remove the receipt we're about to clobber out of existence from the cache
-            this.receiptCacheByEventId[previousEventId] = (
-                this.receiptCacheByEventId[previousEventId].filter(r => {
-                    return r.type !== receiptType || r.userId !== userId;
-                })
-            );
+            this.receiptCacheByEventId[previousEventId] = this.receiptCacheByEventId[previousEventId].filter((r) => {
+                return r.type !== receiptType || r.userId !== userId;
+            });
 
             if (this.receiptCacheByEventId[previousEventId].length < 1) {
                 delete this.receiptCacheByEventId[previousEventId]; // clean up the cache keys
@@ -239,11 +236,13 @@ export abstract class ReadReceipt<
      * @returns A list of user IDs.
      */
     public getUsersReadUpTo(event: MatrixEvent): string[] {
-        return this.getReceiptsForEvent(event).filter(function(receipt) {
-            return utils.isSupportedReceiptType(receipt.type);
-        }).map(function(receipt) {
-            return receipt.userId;
-        });
+        return this.getReceiptsForEvent(event)
+            .filter(function (receipt) {
+                return utils.isSupportedReceiptType(receipt.type);
+            })
+            .map(function (receipt) {
+                return receipt.userId;
+            });
     }
 
     /**
@@ -258,9 +257,11 @@ export abstract class ReadReceipt<
         const readUpToId = this.getEventReadUpTo(userId, false);
         if (readUpToId === eventId) return true;
 
-        if (this.timeline?.length
-            && this.timeline[this.timeline.length - 1].getSender()
-            && this.timeline[this.timeline.length - 1].getSender() === userId) {
+        if (
+            this.timeline?.length &&
+            this.timeline[this.timeline.length - 1].getSender() &&
+            this.timeline[this.timeline.length - 1].getSender() === userId
+        ) {
             // It doesn't matter where the event is in the timeline, the user has read
             // it because they've sent the latest event.
             return true;
diff --git a/src/models/related-relations.ts b/src/models/related-relations.ts
index f619ea059fe..a0051695a5b 100644
--- a/src/models/related-relations.ts
+++ b/src/models/related-relations.ts
@@ -22,7 +22,7 @@ export class RelatedRelations {
     private relations: Relations[];
 
     public constructor(relations: Relations[]) {
-        this.relations = relations.filter(r => !!r);
+        this.relations = relations.filter((r) => !!r);
     }
 
     public getRelations(): MatrixEvent[] {
@@ -30,10 +30,10 @@ export class RelatedRelations {
     }
 
     public on<T extends RelationsEvent>(ev: T, fn: Listener<RelationsEvent, EventHandlerMap, T>): void {
-        this.relations.forEach(r => r.on(ev, fn));
+        this.relations.forEach((r) => r.on(ev, fn));
     }
 
     public off<T extends RelationsEvent>(ev: T, fn: Listener<RelationsEvent, EventHandlerMap, T>): void {
-        this.relations.forEach(r => r.off(ev, fn));
+        this.relations.forEach((r) => r.off(ev, fn));
     }
 }
diff --git a/src/models/relations-container.ts b/src/models/relations-container.ts
index 397e9c52b66..d328b1c8b54 100644
--- a/src/models/relations-container.ts
+++ b/src/models/relations-container.ts
@@ -26,8 +26,7 @@ export class RelationsContainer {
     // this.relations.get(parentEventId).get(relationType).get(relationEventType)
     private relations = new Map<string, Map<RelationType | string, Map<EventType | string, Relations>>>();
 
-    public constructor(private readonly client: MatrixClient, private readonly room?: Room) {
-    }
+    public constructor(private readonly client: MatrixClient, private readonly room?: Room) {}
 
     /**
      * Get a collection of child events to a given event in this timeline set.
@@ -52,8 +51,8 @@ export class RelationsContainer {
     }
 
     public getAllChildEventsForEvent(parentEventId: string): MatrixEvent[] {
-        const relationsForEvent = this.relations.get(parentEventId)
-            ?? new Map<RelationType | string, Map<EventType | string, Relations>>();
+        const relationsForEvent =
+            this.relations.get(parentEventId) ?? new Map<RelationType | string, Map<EventType | string, Relations>>();
         const events: MatrixEvent[] = [];
         for (const relationsRecord of relationsForEvent.values()) {
             for (const relations of relationsRecord.values()) {
@@ -129,17 +128,14 @@ export class RelationsContainer {
 
         let relationsWithEventType = relationsWithRelType.get(eventType);
         if (!relationsWithEventType) {
-            relationsWithEventType = new Relations(
-                relationType!,
-                eventType,
-                this.client,
-            );
+            relationsWithEventType = new Relations(relationType!, eventType, this.client);
             relationsWithRelType.set(eventType, relationsWithEventType);
 
             const room = this.room ?? timelineSet?.room;
-            const relatesToEvent = timelineSet?.findEventById(relatesToEventId!)
-                ?? room?.findEventById(relatesToEventId!)
-                ?? room?.getPendingEvent(relatesToEventId!);
+            const relatesToEvent =
+                timelineSet?.findEventById(relatesToEventId!) ??
+                room?.findEventById(relatesToEventId!) ??
+                room?.getPendingEvent(relatesToEventId!);
             if (relatesToEvent) {
                 relationsWithEventType.setTargetEvent(relatesToEvent);
             }
diff --git a/src/models/relations.ts b/src/models/relations.ts
index 1a984985749..bd6f0093814 100644
--- a/src/models/relations.ts
+++ b/src/models/relations.ts
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { EventStatus, IAggregatedRelation, MatrixEvent, MatrixEventEvent } from './event';
-import { logger } from '../logger';
+import { EventStatus, IAggregatedRelation, MatrixEvent, MatrixEventEvent } from "./event";
+import { logger } from "../logger";
 import { RelationType } from "../@types/event";
 import { TypedEventEmitter } from "./typed-event-emitter";
 import { MatrixClient } from "../client";
diff --git a/src/models/room-member.ts b/src/models/room-member.ts
index 21f8f5f650e..116a93b624b 100644
--- a/src/models/room-member.ts
+++ b/src/models/room-member.ts
@@ -194,7 +194,8 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
             logger.trace(
                 `membership event with membership undefined (forwardLooking: ${event.forwardLooking})!`,
                 event.getContent(),
-                `prevcontent is `, event.getPrevContent(),
+                `prevcontent is `,
+                event.getPrevContent(),
             );
         }
 
@@ -309,9 +310,11 @@ export class RoomMember extends TypedEventEmitter<RoomMemberEvent, RoomMemberEve
     }
 
     public isKicked(): boolean {
-        return this.membership === "leave"
-            && this.events.member !== undefined
-            && this.events.member.getSender() !== this.events.member.getStateKey();
+        return (
+            this.membership === "leave" &&
+            this.events.member !== undefined &&
+            this.events.member.getSender() !== this.events.member.getStateKey()
+        );
     }
 
     /**
@@ -426,11 +429,7 @@ function shouldDisambiguate(selfUserId: string, displayName?: string, roomState?
     return false;
 }
 
-function calculateDisplayName(
-    selfUserId: string,
-    displayName: string | undefined,
-    disambiguate: boolean,
-): string {
+function calculateDisplayName(selfUserId: string, displayName: string | undefined, disambiguate: boolean): string {
     if (!displayName || displayName === selfUserId) return selfUserId;
 
     if (disambiguate) return utils.removeDirectionOverrideChars(displayName) + " (" + selfUserId + ")";
diff --git a/src/models/room-state.ts b/src/models/room-state.ts
index 01081f33a6a..3940659f24c 100644
--- a/src/models/room-state.ts
+++ b/src/models/room-state.ts
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 import { RoomMember } from "./room-member";
-import { logger } from '../logger';
+import { logger } from "../logger";
 import * as utils from "../utils";
 import { EventType, UNSTABLE_MSC2716_MARKER } from "../@types/event";
 import { IEvent, MatrixEvent, MatrixEventEvent } from "./event";
@@ -142,7 +142,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     // and we should only trust that
     // we could also only trust that before OOB members
     // are loaded but doesn't seem worth the hassle atm
-    private summaryJoinedMemberCount: number |null = null;
+    private summaryJoinedMemberCount: number | null = null;
     // same for invited member count
     private invitedMemberCount: number | null = null;
     private summaryInvitedMemberCount: number | null = null;
@@ -203,7 +203,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
         }
         if (this.joinedMemberCount === null) {
             this.joinedMemberCount = this.getMembers().reduce((count, m) => {
-                return m.membership === 'join' ? count + 1 : count;
+                return m.membership === "join" ? count + 1 : count;
             }, 0);
         }
         return this.joinedMemberCount;
@@ -227,7 +227,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
         }
         if (this.invitedMemberCount === null) {
             this.invitedMemberCount = this.getMembers().reduce((count, m) => {
-                return m.membership === 'invite' ? count + 1 : count;
+                return m.membership === "invite" ? count + 1 : count;
             }, 0);
         }
         return this.invitedMemberCount;
@@ -307,7 +307,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
             // no match
             return stateKey === undefined ? [] : null;
         }
-        if (stateKey === undefined) { // return all values
+        if (stateKey === undefined) {
+            // return all values
             return Array.from(this.events.get(eventType)!.values());
         }
         const event = this.events.get(eventType)!.get(stateKey);
@@ -428,14 +429,10 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
                 // leave events apparently elide the displayname or avatar_url,
                 // so let's fake one up so that we don't leak user ids
                 // into the timeline
-                if (event.getContent().membership === "leave" ||
-                    event.getContent().membership === "ban") {
-                    event.getContent().avatar_url =
-                        event.getContent().avatar_url ||
-                        event.getPrevContent().avatar_url;
+                if (event.getContent().membership === "leave" || event.getContent().membership === "ban") {
+                    event.getContent().avatar_url = event.getContent().avatar_url || event.getPrevContent().avatar_url;
                     event.getContent().displayname =
-                        event.getContent().displayname ||
-                        event.getPrevContent().displayname;
+                        event.getContent().displayname || event.getPrevContent().displayname;
                 }
 
                 const member = this.getOrCreateMember(userId, event);
@@ -479,8 +476,10 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
             return;
         }
 
-        const beaconByEventIdDict: Record<string, Beacon> =
-            [...this.beacons.values()].reduce((dict, beacon) => ({ ...dict, [beacon.beaconInfoId]: beacon }), {});
+        const beaconByEventIdDict: Record<string, Beacon> = [...this.beacons.values()].reduce(
+            (dict, beacon) => ({ ...dict, [beacon.beaconInfoId]: beacon }),
+            {},
+        );
 
         const processBeaconRelation = (beaconInfoEventId: string, event: MatrixEvent): void => {
             if (!M_BEACON.matches(event.getType())) {
@@ -590,8 +589,8 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      */
     private onBeaconLivenessChange(): void {
         this._liveBeaconIds = Array.from(this.beacons.values())
-            .filter(beacon => beacon.isLive)
-            .map(beacon => beacon.identifier);
+            .filter((beacon) => beacon.isLive)
+            .map((beacon) => beacon.identifier);
 
         this.emit(RoomStateEvent.BeaconLiveness, this, this.hasLiveBeacons);
     }
@@ -711,7 +710,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * @param event - The typing event
      */
     public setTypingEvent(event: MatrixEvent): void {
-        Object.values(this.members).forEach(function(member) {
+        Object.values(this.members).forEach(function (member) {
             member.setTypingEvent(event);
         });
     }
@@ -760,7 +759,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      */
     public maySendRedactionForEvent(mxEvent: MatrixEvent, userId: string): boolean {
         const member = this.getMember(userId);
-        if (!member || member.membership === 'leave') return false;
+        if (!member || member.membership === "leave") return false;
 
         if (mxEvent.status || mxEvent.isRedacted()) return false;
 
@@ -769,7 +768,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
         const canRedact = this.maySendEvent(EventType.RoomRedaction, userId);
         if (mxEvent.getSender() === userId) return canRedact;
 
-        return this.hasSufficientPowerLevelFor('redact', member.powerLevel);
+        return this.hasSufficientPowerLevelFor("redact", member.powerLevel);
     }
 
     /**
@@ -818,14 +817,14 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     }
 
     /**
-      * Returns true if the given MatrixClient has permission to send a state
-      * event of type `stateEventType` into this room.
-      * @param stateEventType - The type of state events to test
-      * @param cli - The client to test permission for
-      * @returns true if the given client should be permitted to send
-      *                        the given type of state event into this room,
-      *                        according to the room's state.
-      */
+     * Returns true if the given MatrixClient has permission to send a state
+     * event of type `stateEventType` into this room.
+     * @param stateEventType - The type of state events to test
+     * @param cli - The client to test permission for
+     * @returns true if the given client should be permitted to send
+     *                        the given type of state event into this room,
+     *                        according to the room's state.
+     */
     public mayClientSendStateEvent(stateEventType: EventType | string, cli: MatrixClient): boolean {
         if (cli.isGuest() || !cli.credentials.userId) {
             return false;
@@ -859,7 +858,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      *                        according to the room's state.
      */
     private maySendEventOfType(eventType: EventType | string, userId: string, state: boolean): boolean {
-        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, '');
+        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, "");
 
         let powerLevels: IPowerLevelsContent;
         let eventsLevels: Record<EventType | string, number> = {};
@@ -910,7 +909,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
             return false;
         }
 
-        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, '');
+        const powerLevelsEvent = this.getStateEvents(EventType.RoomPowerLevels, "");
 
         let notifLevel = 50;
         if (
diff --git a/src/models/room-summary.ts b/src/models/room-summary.ts
index d12eb66ece5..936ec1d828b 100644
--- a/src/models/room-summary.ts
+++ b/src/models/room-summary.ts
@@ -42,4 +42,3 @@ interface IInfo {
 export class RoomSummary {
     public constructor(public readonly roomId: string, info?: IInfo) {}
 }
-
diff --git a/src/models/room.ts b/src/models/room.ts
index 95c33614c74..6d3c14398ff 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -30,10 +30,13 @@ import { IEvent, IThreadBundledRelationship, MatrixEvent, MatrixEventEvent, Matr
 import { EventStatus } from "./event-status";
 import { RoomMember } from "./room-member";
 import { IRoomSummary, RoomSummary } from "./room-summary";
-import { logger } from '../logger';
-import { TypedReEmitter } from '../ReEmitter';
+import { logger } from "../logger";
+import { TypedReEmitter } from "../ReEmitter";
 import {
-    EventType, RoomCreateTypeField, RoomType, UNSTABLE_ELEMENT_FUNCTIONAL_USERS,
+    EventType,
+    RoomCreateTypeField,
+    RoomType,
+    UNSTABLE_ELEMENT_FUNCTIONAL_USERS,
     EVENT_VISIBILITY_CHANGE_TYPE,
     RelationType,
 } from "../@types/event";
@@ -46,17 +49,15 @@ import {
     Thread,
     ThreadEvent,
     EventHandlerMap as ThreadHandlerMap,
-    FILTER_RELATED_BY_REL_TYPES, THREAD_RELATION_TYPE,
+    FILTER_RELATED_BY_REL_TYPES,
+    THREAD_RELATION_TYPE,
     FILTER_RELATED_BY_SENDERS,
     ThreadFilterType,
 } from "./thread";
 import { MAIN_ROOM_TIMELINE, Receipt, ReceiptContent, ReceiptType } from "../@types/read_receipts";
 import { IStateEventWithRoomId } from "../@types/search";
 import { RelationsContainer } from "./relations-container";
-import {
-    ReadReceipt,
-    synthesizeReceipt,
-} from "./read-receipt";
+import { ReadReceipt, synthesizeReceipt } from "./read-receipt";
 import { Feature, ServerSupport } from "../feature";
 
 // These constants are used as sane defaults when the homeserver doesn't support
@@ -65,8 +66,8 @@ import { Feature, ServerSupport } from "../feature";
 // room versions which are considered okay for people to run without being asked
 // to upgrade (ie: "stable"). Eventually, we should remove these when all homeservers
 // return an m.room_versions capability.
-export const KNOWN_SAFE_ROOM_VERSION = '9';
-const SAFE_ROOM_VERSIONS = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];
+export const KNOWN_SAFE_ROOM_VERSION = "9";
+const SAFE_ROOM_VERSIONS = ["1", "2", "3", "4", "5", "6", "7", "8", "9"];
 
 interface IOpts {
     /**
@@ -140,7 +141,8 @@ export enum RoomEvent {
     UnreadNotifications = "Room.UnreadNotifications",
 }
 
-export type RoomEmittedEvents = RoomEvent
+export type RoomEmittedEvents =
+    | RoomEvent
     | RoomStateEvent.Events
     | RoomStateEvent.Members
     | RoomStateEvent.NewMember
@@ -205,7 +207,8 @@ export type RoomEventHandlerMap = {
      * });
      * ```
      */
-    [RoomEvent.Receipt]: (event: MatrixEvent, room: Room) => void;/**
+    [RoomEvent.Receipt]: (event: MatrixEvent, room: Room) => void
+    /**
      * Fires whenever the name of a room is updated.
      * @param room - The room whose Room.name was updated.
      * @example
@@ -214,7 +217,7 @@ export type RoomEventHandlerMap = {
      *   var newName = room.name;
      * });
      * ```
-     */
+     */;
     [RoomEvent.Name]: (room: Room) => void;
     /**
      * Fires when an event we had previously received is redacted.
@@ -276,42 +279,30 @@ export type RoomEventHandlerMap = {
     ) => void;
     [RoomEvent.OldStateUpdated]: (room: Room, previousRoomState: RoomState, roomState: RoomState) => void;
     [RoomEvent.CurrentStateUpdated]: (room: Room, previousRoomState: RoomState, roomState: RoomState) => void;
-    [RoomEvent.HistoryImportedWithinTimeline]: (
-        markerEvent: MatrixEvent,
-        room: Room,
-    ) => void;
-    [RoomEvent.UnreadNotifications]: (
-        unreadNotifications?: NotificationCount,
-        threadId?: string,
-    ) => void;
+    [RoomEvent.HistoryImportedWithinTimeline]: (markerEvent: MatrixEvent, room: Room) => void;
+    [RoomEvent.UnreadNotifications]: (unreadNotifications?: NotificationCount, threadId?: string) => void;
     [RoomEvent.TimelineRefresh]: (room: Room, eventTimelineSet: EventTimelineSet) => void;
     [ThreadEvent.New]: (thread: Thread, toStartOfTimeline: boolean) => void;
-} & Pick<
-        ThreadHandlerMap,
-        ThreadEvent.Update | ThreadEvent.NewReply | ThreadEvent.Delete
-    >
-    & EventTimelineSetHandlerMap
-    & Pick<MatrixEventHandlerMap, MatrixEventEvent.BeforeRedaction>
-    & Pick<
+} & Pick<ThreadHandlerMap, ThreadEvent.Update | ThreadEvent.NewReply | ThreadEvent.Delete> &
+    EventTimelineSetHandlerMap &
+    Pick<MatrixEventHandlerMap, MatrixEventEvent.BeforeRedaction> &
+    Pick<
         RoomStateEventHandlerMap,
-        RoomStateEvent.Events
-            | RoomStateEvent.Members
-            | RoomStateEvent.NewMember
-            | RoomStateEvent.Update
-            | RoomStateEvent.Marker
-            | BeaconEvent.New
-    >
-    & Pick<
-        BeaconEventHandlerMap,
-        BeaconEvent.Update | BeaconEvent.Destroy | BeaconEvent.LivenessChange
-    >;
+        | RoomStateEvent.Events
+        | RoomStateEvent.Members
+        | RoomStateEvent.NewMember
+        | RoomStateEvent.Update
+        | RoomStateEvent.Marker
+        | BeaconEvent.New
+    > &
+    Pick<BeaconEventHandlerMap, BeaconEvent.Update | BeaconEvent.Destroy | BeaconEvent.LivenessChange>;
 
 export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     public readonly reEmitter: TypedReEmitter<RoomEmittedEvents, RoomEventHandlerMap>;
     private txnToEvent: Record<string, MatrixEvent> = {}; // Pending in-flight requests { string: MatrixEvent }
     private notificationCounts: NotificationCount = {};
     private readonly threadNotifications = new Map<string, NotificationCount>();
-    public readonly cachedThreadReadReceipts = new Map<string, { event: MatrixEvent, synthetic: boolean }[]>();
+    public readonly cachedThreadReadReceipts = new Map<string, { event: MatrixEvent; synthetic: boolean }[]>();
     private readonly timelineSets: EventTimelineSet[];
     public readonly threadsTimelineSets: EventTimelineSet[] = [];
     // any filtered timeline sets we're maintaining for this room
@@ -437,16 +428,13 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // all our per-room timeline sets. the first one is the unfiltered ones;
         // the subsequent ones are the filtered ones in no particular order.
         this.timelineSets = [new EventTimelineSet(this, opts)];
-        this.reEmitter.reEmit(this.getUnfilteredTimelineSet(), [
-            RoomEvent.Timeline,
-            RoomEvent.TimelineReset,
-        ]);
+        this.reEmitter.reEmit(this.getUnfilteredTimelineSet(), [RoomEvent.Timeline, RoomEvent.TimelineReset]);
 
         this.fixUpLegacyTimelineFields();
 
         if (this.opts.pendingEventOrdering === PendingEventOrdering.Detached) {
             this.pendingEventList = [];
-            this.client.store.getPendingEvents(this.roomId).then(events => {
+            this.client.store.getPendingEvents(this.roomId).then((events) => {
                 const mapper = this.client.getEventMapper({
                     toDevice: false,
                     decrypt: false,
@@ -509,15 +497,15 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
         const readReceiptEventId = this.getEventReadUpTo(this.client.getUserId()!, true);
         const events = this.getLiveTimeline().getEvents();
-        const readReceiptTimelineIndex = events.findIndex(matrixEvent => {
+        const readReceiptTimelineIndex = events.findIndex((matrixEvent) => {
             return matrixEvent.event.event_id === readReceiptEventId;
         });
 
         const decryptionPromises = events
             .slice(readReceiptTimelineIndex)
-            .filter(event => event.shouldAttemptDecryption())
+            .filter((event) => event.shouldAttemptDecryption())
             .reverse()
-            .map(event => event.attemptDecryption(this.client.crypto!, { isRetry: true }));
+            .map((event) => event.attemptDecryption(this.client.crypto!, { isRetry: true }));
 
         await Promise.allSettled(decryptionPromises);
     }
@@ -530,13 +518,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     public async decryptAllEvents(): Promise<void> {
         if (!this.client.isCryptoEnabled()) return;
 
-        const decryptionPromises = this
-            .getUnfilteredTimelineSet()
+        const decryptionPromises = this.getUnfilteredTimelineSet()
             .getLiveTimeline()
             .getEvents()
-            .filter(event => event.shouldAttemptDecryption())
+            .filter((event) => event.shouldAttemptDecryption())
             .reverse()
-            .map(event => event.attemptDecryption(this.client.crypto!, { isRetry: true }));
+            .map((event) => event.attemptDecryption(this.client.crypto!, { isRetry: true }));
 
         await Promise.allSettled(decryptionPromises);
     }
@@ -547,7 +534,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     public getCreator(): string | null {
         const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
-        return createEvent?.getContent()['creator'] ?? null;
+        return createEvent?.getContent()["creator"] ?? null;
     }
 
     /**
@@ -561,9 +548,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 logger.warn("[getVersion] Room " + this.roomId + " does not have an m.room.create event");
                 this.getVersionWarning = true;
             }
-            return '1';
+            return "1";
         }
-        return createEvent.getContent()['room_version'] ?? '1';
+        return createEvent.getContent()["room_version"] ?? "1";
     }
 
     /**
@@ -621,7 +608,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             // the capability we're using to determine this.
             logger.warn(
                 "Refreshing room version capability because the server looks " +
-                "to be supporting a newer room version we don't know about.",
+                    "to be supporting a newer room version we don't know about.",
             );
 
             const caps = await this.client.getCapabilities(true);
@@ -651,8 +638,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // If the room is on the default version then nothing needs to change
         if (currentVersion === versionCap.default) return result;
 
-        const stableVersions = Object.keys(versionCap.available)
-            .filter((v) => versionCap.available[v] === 'stable');
+        const stableVersions = Object.keys(versionCap.available).filter((v) => versionCap.available[v] === "stable");
 
         // Check if the room is on an unstable version. We determine urgency based
         // off the version being in the Matrix spec namespace or not (if the version
@@ -694,8 +680,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     public getPendingEvents(): MatrixEvent[] {
         if (!this.pendingEventList) {
             throw new Error(
-                "Cannot call getPendingEvents with pendingEventOrdering == " +
-                this.opts.pendingEventOrdering);
+                "Cannot call getPendingEvents with pendingEventOrdering == " + this.opts.pendingEventOrdering,
+            );
         }
 
         return this.pendingEventList;
@@ -709,15 +695,16 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     public removePendingEvent(eventId: string): boolean {
         if (!this.pendingEventList) {
             throw new Error(
-                "Cannot call removePendingEvent with pendingEventOrdering == " +
-                this.opts.pendingEventOrdering);
+                "Cannot call removePendingEvent with pendingEventOrdering == " + this.opts.pendingEventOrdering,
+            );
         }
 
         const removed = utils.removeElement(
             this.pendingEventList,
-            function(ev) {
+            function (ev) {
                 return ev.getId() == eventId;
-            }, false,
+            },
+            false,
         );
 
         this.savePendingEvents();
@@ -732,7 +719,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * @param eventId - The event ID to check for.
      */
     public hasPendingEvent(eventId: string): boolean {
-        return this.pendingEventList?.some(event => event.getId() === eventId) ?? false;
+        return this.pendingEventList?.some((event) => event.getId() === eventId) ?? false;
     }
 
     /**
@@ -741,7 +728,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * @param eventId - The event ID to check for.
      */
     public getPendingEvent(eventId: string): MatrixEvent | null {
-        return this.pendingEventList?.find(event => event.getId() === eventId) ?? null;
+        return this.pendingEventList?.find((event) => event.getId() === eventId) ?? null;
     }
 
     /**
@@ -855,8 +842,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 return this.client.getUser(userId);
             }).find((user) => !!user);
             if (availableUser) {
-                const member = new RoomMember(
-                    this.roomId, availableUser.userId);
+                const member = new RoomMember(this.roomId, availableUser.userId);
                 member.user = availableUser;
                 return member;
             }
@@ -884,7 +870,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         return response.chunk;
     }
 
-    private async loadMembers(): Promise<{ memberEvents: MatrixEvent[], fromServer: boolean }> {
+    private async loadMembers(): Promise<{ memberEvents: MatrixEvent[]; fromServer: boolean }> {
         // were the members loaded from the server?
         let fromServer = false;
         let rawMembersEvents = await this.client.store.getOutOfBandMembers(this.roomId);
@@ -893,13 +879,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // that this function is only called once (unless loading the members
         // fails), since loadMembersIfNeeded always returns this.membersPromise
         // if set, which will be the result of the first (successful) call.
-        if (rawMembersEvents === null ||
-            (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId))
-        ) {
+        if (rawMembersEvents === null || (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId))) {
             fromServer = true;
             rawMembersEvents = await this.loadMembersFromServer();
-            logger.log(`LL: got ${rawMembersEvents.length} ` +
-                `members from server for room ${this.roomId}`);
+            logger.log(`LL: got ${rawMembersEvents.length} ` + `members from server for room ${this.roomId}`);
         }
         const memberEvents = rawMembersEvents.map(this.client.getEventMapper());
         return { memberEvents, fromServer };
@@ -923,41 +906,47 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // the OOB members
         this.currentState.markOutOfBandMembersStarted();
 
-        const inMemoryUpdate = this.loadMembers().then((result) => {
-            this.currentState.setOutOfBandMembers(result.memberEvents);
-            // now the members are loaded, start to track the e2e devices if needed
-            if (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId)) {
-                this.client.crypto!.trackRoomDevices(this.roomId);
-            }
-            return result.fromServer;
-        }).catch((err) => {
-            // allow retries on fail
-            this.membersPromise = undefined;
-            this.currentState.markOutOfBandMembersFailed();
-            throw err;
-        });
+        const inMemoryUpdate = this.loadMembers()
+            .then((result) => {
+                this.currentState.setOutOfBandMembers(result.memberEvents);
+                // now the members are loaded, start to track the e2e devices if needed
+                if (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId)) {
+                    this.client.crypto!.trackRoomDevices(this.roomId);
+                }
+                return result.fromServer;
+            })
+            .catch((err) => {
+                // allow retries on fail
+                this.membersPromise = undefined;
+                this.currentState.markOutOfBandMembersFailed();
+                throw err;
+            });
         // update members in storage, but don't wait for it
-        inMemoryUpdate.then((fromServer) => {
-            if (fromServer) {
-                const oobMembers = this.currentState.getMembers()
-                    .filter((m) => m.isOutOfBand())
-                    .map((m) => m.events.member?.event as IStateEventWithRoomId);
-                logger.log(`LL: telling store to write ${oobMembers.length}`
-                    + ` members for room ${this.roomId}`);
-                const store = this.client.store;
-                return store.setOutOfBandMembers(this.roomId, oobMembers)
-                    // swallow any IDB error as we don't want to fail
-                    // because of this
-                    .catch((err) => {
-                        logger.log("LL: storing OOB room members failed, oh well",
-                            err);
-                    });
-            }
-        }).catch((err) => {
-            // as this is not awaited anywhere,
-            // at least show the error in the console
-            logger.error(err);
-        });
+        inMemoryUpdate
+            .then((fromServer) => {
+                if (fromServer) {
+                    const oobMembers = this.currentState
+                        .getMembers()
+                        .filter((m) => m.isOutOfBand())
+                        .map((m) => m.events.member?.event as IStateEventWithRoomId);
+                    logger.log(`LL: telling store to write ${oobMembers.length}` + ` members for room ${this.roomId}`);
+                    const store = this.client.store;
+                    return (
+                        store
+                            .setOutOfBandMembers(this.roomId, oobMembers)
+                            // swallow any IDB error as we don't want to fail
+                            // because of this
+                            .catch((err) => {
+                                logger.log("LL: storing OOB room members failed, oh well", err);
+                            })
+                    );
+                }
+            })
+            .catch((err) => {
+                // as this is not awaited anywhere,
+                // at least show the error in the console
+                logger.error(err);
+            });
 
         this.membersPromise = inMemoryUpdate;
 
@@ -982,8 +971,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     private cleanupAfterLeaving(): void {
         this.clearLoadedMembersIfNeeded().catch((err) => {
-            logger.error(`error after clearing loaded members from ` +
-                `room ${this.roomId} after leaving`);
+            logger.error(`error after clearing loaded members from ` + `room ${this.roomId} after leaving`);
             logger.log(err);
         });
     }
@@ -1009,10 +997,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         const mostRecentEventInTimeline = eventsBefore[eventsBefore.length - 1];
         logger.log(
             `[refreshLiveTimeline for ${this.roomId}] at ` +
-            `mostRecentEventInTimeline=${mostRecentEventInTimeline && mostRecentEventInTimeline.getId()} ` +
-            `liveTimelineBefore=${liveTimelineBefore.toString()} ` +
-            `forwardPaginationToken=${forwardPaginationToken} ` +
-            `backwardPaginationToken=${backwardPaginationToken}`,
+                `mostRecentEventInTimeline=${mostRecentEventInTimeline && mostRecentEventInTimeline.getId()} ` +
+                `liveTimelineBefore=${liveTimelineBefore.toString()} ` +
+                `forwardPaginationToken=${forwardPaginationToken} ` +
+                `backwardPaginationToken=${backwardPaginationToken}`,
         );
 
         // Get the main TimelineSet
@@ -1056,11 +1044,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // instead because it's the latest in the room and any new messages in
         // the scrollback will include the history.
         const liveTimeline = timelineSet.getLiveTimeline();
-        if (!liveTimeline || (
-            liveTimeline.getPaginationToken(Direction.Forward) === null &&
-            liveTimeline.getPaginationToken(Direction.Backward) === null &&
-            liveTimeline.getEvents().length === 0
-        )) {
+        if (
+            !liveTimeline ||
+            (liveTimeline.getPaginationToken(Direction.Forward) === null &&
+                liveTimeline.getPaginationToken(Direction.Backward) === null &&
+                liveTimeline.getEvents().length === 0)
+        ) {
             logger.log(`[refreshLiveTimeline for ${this.roomId}] using our new live timeline`);
             // Set the pagination token back to the live sync token (`null`) instead
             // of using the `/context` historical token (ex. `t12-13_0_0_0_0_0_0_0_0`)
@@ -1077,8 +1066,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         } else {
             logger.log(
                 `[refreshLiveTimeline for ${this.roomId}] \`/sync\` or some other request beat us to creating a new ` +
-                `live timeline after we reset it. We'll use that instead since any events in the scrollback from ` +
-                `this timeline will include the history.`,
+                    `live timeline after we reset it. We'll use that instead since any events in the scrollback from ` +
+                    `this timeline will include the history.`,
             );
         }
 
@@ -1103,10 +1092,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     public resetLiveTimeline(backPaginationToken?: string | null, forwardPaginationToken?: string | null): void {
         for (const timelineSet of this.timelineSets) {
-            timelineSet.resetLiveTimeline(
-                backPaginationToken ?? undefined,
-                forwardPaginationToken ?? undefined,
-            );
+            timelineSet.resetLiveTimeline(backPaginationToken ?? undefined, forwardPaginationToken ?? undefined);
         }
 
         this.fixUpLegacyTimelineFields();
@@ -1295,9 +1281,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     public getUnreadCountForEventContext(type = NotificationCountType.Total, event: MatrixEvent): number {
         const isThreadEvent = !!event.threadRootId && !event.isThreadRoot;
 
-        return (isThreadEvent
-            ? this.getThreadUnreadNotificationCount(event.threadRootId, type)
-            : this.getRoomUnreadNotificationCount(type)) ?? 0;
+        return (
+            (isThreadEvent
+                ? this.getThreadUnreadNotificationCount(event.threadRootId, type)
+                : this.getRoomUnreadNotificationCount(type)) ?? 0
+        );
     }
 
     /**
@@ -1354,11 +1342,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
         this.threadNotifications.set(threadId, notification);
 
-        this.emit(
-            RoomEvent.UnreadNotifications,
-            notification,
-            threadId,
-        );
+        this.emit(RoomEvent.UnreadNotifications, notification, threadId);
     }
 
     /**
@@ -1610,7 +1594,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * @returns A list of members with the given membership state.
      */
     public getMembersWithMembership(membership: string): RoomMember[] {
-        return this.currentState.getMembers().filter(function(m) {
+        return this.currentState.getMembers().filter(function (m) {
             return m.membership === membership;
         });
     }
@@ -1671,21 +1655,14 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     public getOrCreateFilteredTimelineSet(
         filter: Filter,
-        {
-            prepopulateTimeline = true,
-            useSyncEvents = true,
-            pendingEvents = true,
-        }: ICreateFilterOpts = {},
+        { prepopulateTimeline = true, useSyncEvents = true, pendingEvents = true }: ICreateFilterOpts = {},
     ): EventTimelineSet {
         if (this.filteredTimelineSets[filter.filterId!]) {
             return this.filteredTimelineSets[filter.filterId!];
         }
         const opts = Object.assign({ filter, pendingEvents }, this.opts);
         const timelineSet = new EventTimelineSet(this, opts);
-        this.reEmitter.reEmit(timelineSet, [
-            RoomEvent.Timeline,
-            RoomEvent.TimelineReset,
-        ]);
+        this.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
         if (useSyncEvents) {
             this.filteredTimelineSets[filter.filterId!] = timelineSet;
             this.timelineSets.push(timelineSet);
@@ -1703,7 +1680,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             // may have grown huge and so take a long time to filter.
             // see https://github.com/vector-im/vector-web/issues/2109
 
-            unfilteredLiveTimeline.getEvents().forEach(function(event) {
+            unfilteredLiveTimeline.getEvents().forEach(function (event) {
                 timelineSet.addLiveEvent(event);
             });
 
@@ -1713,15 +1690,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 timeline = timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)!;
             }
 
-            timelineSet.getLiveTimeline().setPaginationToken(
-                timeline.getPaginationToken(EventTimeline.BACKWARDS),
-                EventTimeline.BACKWARDS,
-            );
-        } else if (useSyncEvents) {
-            const livePaginationToken = unfilteredLiveTimeline.getPaginationToken(Direction.Forward);
             timelineSet
                 .getLiveTimeline()
-                .setPaginationToken(livePaginationToken, Direction.Backward);
+                .setPaginationToken(timeline.getPaginationToken(EventTimeline.BACKWARDS), EventTimeline.BACKWARDS);
+        } else if (useSyncEvents) {
+            const livePaginationToken = unfilteredLiveTimeline.getPaginationToken(Direction.Forward);
+            timelineSet.getLiveTimeline().setPaginationToken(livePaginationToken, Direction.Backward);
         }
 
         // alternatively, we could try to do something like this to try and re-paginate
@@ -1740,8 +1714,8 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         const filter = new Filter(myUserId);
 
         const definition: IFilterDefinition = {
-            "room": {
-                "timeline": {
+            room: {
+                timeline: {
                     [FILTER_RELATED_BY_REL_TYPES.name]: [THREAD_RELATION_TYPE.name],
                 },
             },
@@ -1752,10 +1726,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
 
         filter.setDefinition(definition);
-        const filterId = await this.client.getOrCreateFilter(
-            `THREAD_PANEL_${this.roomId}_${filterType}`,
-            filter,
-        );
+        const filterId = await this.client.getOrCreateFilter(`THREAD_PANEL_${this.roomId}_${filterType}`, filter);
 
         filter.filterId = filterId;
 
@@ -1765,43 +1736,41 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     private async createThreadTimelineSet(filterType?: ThreadFilterType): Promise<EventTimelineSet> {
         let timelineSet: EventTimelineSet;
         if (Thread.hasServerSideListSupport) {
-            timelineSet =
-                new EventTimelineSet(this, {
+            timelineSet = new EventTimelineSet(
+                this,
+                {
                     ...this.opts,
                     pendingEvents: false,
-                }, undefined, undefined, filterType ?? ThreadFilterType.All);
-            this.reEmitter.reEmit(timelineSet, [
-                RoomEvent.Timeline,
-                RoomEvent.TimelineReset,
-            ]);
+                },
+                undefined,
+                undefined,
+                filterType ?? ThreadFilterType.All,
+            );
+            this.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
         } else if (Thread.hasServerSideSupport) {
             const filter = await this.getThreadListFilter(filterType);
 
-            timelineSet = this.getOrCreateFilteredTimelineSet(
-                filter,
-                {
-                    prepopulateTimeline: false,
-                    useSyncEvents: false,
-                    pendingEvents: false,
-                },
-            );
+            timelineSet = this.getOrCreateFilteredTimelineSet(filter, {
+                prepopulateTimeline: false,
+                useSyncEvents: false,
+                pendingEvents: false,
+            });
         } else {
             timelineSet = new EventTimelineSet(this, {
                 pendingEvents: false,
             });
 
-            Array.from(this.threads)
-                .forEach(([, thread]) => {
-                    if (thread.length === 0) return;
-                    const currentUserParticipated = thread.timeline.some(event => {
-                        return event.getSender() === this.client.getUserId();
-                    });
-                    if (filterType !== ThreadFilterType.My || currentUserParticipated) {
-                        timelineSet.getLiveTimeline().addEvent(thread.rootEvent!, {
-                            toStartOfTimeline: false,
-                        });
-                    }
+            Array.from(this.threads).forEach(([, thread]) => {
+                if (thread.length === 0) return;
+                const currentUserParticipated = thread.timeline.some((event) => {
+                    return event.getSender() === this.client.getUserId();
                 });
+                if (filterType !== ThreadFilterType.My || currentUserParticipated) {
+                    timelineSet.getLiveTimeline().addEvent(thread.rootEvent!, {
+                        toStartOfTimeline: false,
+                    });
+                }
+            });
         }
 
         return timelineSet;
@@ -1814,11 +1783,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     public processThreadRoots(events: MatrixEvent[], toStartOfTimeline: boolean): void {
         for (const rootEvent of events) {
-            EventTimeline.setEventMetadata(
-                rootEvent,
-                this.currentState,
-                toStartOfTimeline,
-            );
+            EventTimeline.setEventMetadata(rootEvent, this.currentState, toStartOfTimeline);
             if (!this.getThread(rootEvent.getId()!)) {
                 this.createThread(rootEvent.getId()!, rootEvent, [], toStartOfTimeline);
             }
@@ -1854,22 +1819,21 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             if (!events.length) return;
 
             // Sorted by last_reply origin_server_ts
-            const threadRoots = events
-                .map(this.client.getEventMapper())
-                .sort((eventA, eventB) => {
-                    /**
-                     * `origin_server_ts` in a decentralised world is far from ideal
-                     * but for lack of any better, we will have to use this
-                     * Long term the sorting should be handled by homeservers and this
-                     * is only meant as a short term patch
-                     */
-                    const threadAMetadata = eventA
-                        .getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name)!;
-                    const threadBMetadata = eventB
-                        .getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name)!;
-                    return threadAMetadata.latest_event.origin_server_ts -
-                        threadBMetadata.latest_event.origin_server_ts;
-                });
+            const threadRoots = events.map(this.client.getEventMapper()).sort((eventA, eventB) => {
+                /**
+                 * `origin_server_ts` in a decentralised world is far from ideal
+                 * but for lack of any better, we will have to use this
+                 * Long term the sorting should be handled by homeservers and this
+                 * is only meant as a short term patch
+                 */
+                const threadAMetadata = eventA.getServerAggregatedRelation<IThreadBundledRelationship>(
+                    THREAD_RELATION_TYPE.name,
+                )!;
+                const threadBMetadata = eventB.getServerAggregatedRelation<IThreadBundledRelationship>(
+                    THREAD_RELATION_TYPE.name,
+                )!;
+                return threadAMetadata.latest_event.origin_server_ts - threadBMetadata.latest_event.origin_server_ts;
+            });
 
             let latestMyThreadsRootEvent: MatrixEvent | undefined;
             const roomState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);
@@ -1881,8 +1845,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 };
                 this.threadsTimelineSets[0]?.addLiveEvent(rootEvent, opts);
 
-                const threadRelationship = rootEvent
-                    .getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
+                const threadRelationship = rootEvent.getServerAggregatedRelation<IThreadBundledRelationship>(
+                    THREAD_RELATION_TYPE.name,
+                );
                 if (threadRelationship?.current_user_participated) {
                     this.threadsTimelineSets[1]?.addLiveEvent(rootEvent, opts);
                     latestMyThreadsRootEvent = rootEvent;
@@ -1891,7 +1856,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
             this.processThreadRoots(threadRoots, true);
 
-            this.client.decryptEventIfNeeded(threadRoots[threadRoots.length -1]);
+            this.client.decryptEventIfNeeded(threadRoots[threadRoots.length - 1]);
             if (latestMyThreadsRootEvent) {
                 this.client.decryptEventIfNeeded(latestMyThreadsRootEvent);
             }
@@ -1907,9 +1872,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * @internal
      */
     private async fetchRoomThreadList(filter?: ThreadFilterType): Promise<void> {
-        const timelineSet = filter === ThreadFilterType.My
-            ? this.threadsTimelineSets[1]
-            : this.threadsTimelineSets[0];
+        const timelineSet = filter === ThreadFilterType.My ? this.threadsTimelineSets[1] : this.threadsTimelineSets[0];
 
         const { chunk: events, end } = await this.client.createThreadListMessagesRequest(
             this.roomId,
@@ -1944,7 +1907,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         this.threads.delete(thread.id);
 
         const timeline = this.getTimelineForEvent(thread.id);
-        const roomEvent = timeline?.getEvents()?.find(it => it.getId() === thread.id);
+        const roomEvent = timeline?.getEvents()?.find((it) => it.getId() === thread.id);
         if (roomEvent) {
             thread.clearEventMetadata(roomEvent);
         } else {
@@ -1969,7 +1932,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
     }
 
-    public eventShouldLiveIn(event: MatrixEvent, events?: MatrixEvent[], roots?: Set<string>): {
+    public eventShouldLiveIn(
+        event: MatrixEvent,
+        events?: MatrixEvent[],
+        roots?: Set<string>,
+    ): {
         shouldLiveInRoom: boolean;
         shouldLiveInThread: boolean;
         threadId?: string;
@@ -2000,7 +1967,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         }
 
         const parentEventId = event.getAssociatedId()!;
-        const parentEvent = this.findEventById(parentEventId) ?? events?.find(e => e.getId() === parentEventId);
+        const parentEvent = this.findEventById(parentEventId) ?? events?.find((e) => e.getId() === parentEventId);
 
         // Treat relations and redactions as extensions of their parents so evaluate parentEvent instead
         if (parentEvent && (event.isRelation() || event.isRedaction())) {
@@ -2034,7 +2001,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         let thread = this.getThread(threadId);
 
         if (!thread) {
-            const rootEvent = this.findEventById(threadId) ?? events.find(e => e.getId() === threadId);
+            const rootEvent = this.findEventById(threadId) ?? events.find((e) => e.getId() === threadId);
             thread = this.createThread(threadId, rootEvent, events, toStartOfTimeline);
         }
 
@@ -2057,9 +2024,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             eventsByThread[threadId!]?.push(event);
         }
 
-        Object.entries(eventsByThread).map(([threadId, threadEvents]) => (
-            this.addThreadedEvents(threadId, threadEvents, toStartOfTimeline)
-        ));
+        Object.entries(eventsByThread).map(([threadId, threadEvents]) =>
+            this.addThreadedEvents(threadId, threadEvents, toStartOfTimeline),
+        );
     }
 
     private updateThreadRootEvents = (thread: Thread, toStartOfTimeline: boolean, recreateEvent: boolean): void => {
@@ -2088,11 +2055,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                     roomState: this.currentState,
                 });
             } else {
-                timelineSet.addEventToTimeline(
-                    thread.rootEvent,
-                    timelineSet.getLiveTimeline(),
-                    { toStartOfTimeline },
-                );
+                timelineSet.addEventToTimeline(thread.rootEvent, timelineSet.getLiveTimeline(), { toStartOfTimeline });
             }
         }
     };
@@ -2108,7 +2071,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             if (relatedEvents?.length) {
                 // Include all relations of the root event, given it'll be visible in both timelines,
                 // except `m.replace` as that will already be applied atop the event using `MatrixEvent::makeReplaced`
-                events = events.concat(relatedEvents.filter(e => !e.isRelation(RelationType.Replace)));
+                events = events.concat(relatedEvents.filter((e) => !e.isRelation(RelationType.Replace)));
             }
         }
 
@@ -2135,9 +2098,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             RoomEvent.Timeline,
             RoomEvent.TimelineReset,
         ]);
-        const isNewer = this.lastThread?.rootEvent
-            && rootEvent?.localTimestamp
-            && this.lastThread.rootEvent?.localTimestamp < rootEvent?.localTimestamp;
+        const isNewer =
+            this.lastThread?.rootEvent &&
+            rootEvent?.localTimestamp &&
+            this.lastThread.rootEvent?.localTimestamp < rootEvent?.localTimestamp;
 
         if (!this.lastThread || isNewer) {
             this.lastThread = thread;
@@ -2270,9 +2234,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // pointing to an event that wasn't yet in the timeline
         // Don't synthesize RR for m.room.redaction as this causes the RR to go missing.
         if (event.sender && event.getType() !== EventType.RoomRedaction) {
-            this.addReceipt(synthesizeReceipt(
-                event.sender.userId, event, ReceiptType.Read,
-            ), true);
+            this.addReceipt(synthesizeReceipt(event.sender.userId, event, ReceiptType.Read), true);
 
             // Any live events from a user could be taken as implicit
             // presence information: evidence that they are currently active.
@@ -2303,13 +2265,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     public addPendingEvent(event: MatrixEvent, txnId: string): void {
         if (event.status !== EventStatus.SENDING && event.status !== EventStatus.NOT_SENT) {
-            throw new Error("addPendingEvent called on an event with status " +
-                event.status);
+            throw new Error("addPendingEvent called on an event with status " + event.status);
         }
 
         if (this.txnToEvent[txnId]) {
-            throw new Error("addPendingEvent called on an event with known txnId " +
-                txnId);
+            throw new Error("addPendingEvent called on an event with known txnId " + txnId);
         }
 
         // call setEventMetadata to set up event.sender etc
@@ -2334,7 +2294,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
             if (event.isRedaction()) {
                 const redactId = event.event.redacts;
-                let redactedEvent = this.pendingEventList.find(e => e.getId() === redactId);
+                let redactedEvent = this.pendingEventList.find((e) => e.getId() === redactId);
                 if (!redactedEvent && redactId) {
                     redactedEvent = this.findEventById(redactId);
                 }
@@ -2347,16 +2307,14 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             for (const timelineSet of this.timelineSets) {
                 if (timelineSet.getFilter()) {
                     if (timelineSet.getFilter()!.filterRoomTimeline([event]).length) {
-                        timelineSet.addEventToTimeline(event,
-                            timelineSet.getLiveTimeline(), {
-                                toStartOfTimeline: false,
-                            });
-                    }
-                } else {
-                    timelineSet.addEventToTimeline(event,
-                        timelineSet.getLiveTimeline(), {
+                        timelineSet.addEventToTimeline(event, timelineSet.getLiveTimeline(), {
                             toStartOfTimeline: false,
                         });
+                    }
+                } else {
+                    timelineSet.addEventToTimeline(event, timelineSet.getLiveTimeline(), {
+                        toStartOfTimeline: false,
+                    });
                 }
             }
         }
@@ -2379,17 +2337,19 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      */
     private savePendingEvents(): void {
         if (this.pendingEventList) {
-            const pendingEvents = this.pendingEventList.map(event => {
-                return {
-                    ...event.event,
-                    txn_id: event.getTxnId(),
-                };
-            }).filter(event => {
-                // Filter out the unencrypted messages if the room is encrypted
-                const isEventEncrypted = event.type === EventType.RoomMessageEncrypted;
-                const isRoomEncrypted = this.client.isRoomEncrypted(this.roomId);
-                return isEventEncrypted || !isRoomEncrypted;
-            });
+            const pendingEvents = this.pendingEventList
+                .map((event) => {
+                    return {
+                        ...event.event,
+                        txn_id: event.getTxnId(),
+                    };
+                })
+                .filter((event) => {
+                    // Filter out the unencrypted messages if the room is encrypted
+                    const isEventEncrypted = event.type === EventType.RoomMessageEncrypted;
+                    const isRoomEncrypted = this.client.isRoomEncrypted(this.roomId);
+                    return isEventEncrypted || !isRoomEncrypted;
+                });
 
             this.client.store.setPendingEvents(this.roomId, pendingEvents);
         }
@@ -2478,7 +2438,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     public updatePendingEvent(event: MatrixEvent, newStatus: EventStatus, newEventId?: string): void {
         logger.log(
             `setting pendingEvent status to ${newStatus} in ${event.getRoomId()} ` +
-            `event ID ${event.getId()} -> ${newEventId}`,
+                `event ID ${event.getId()} -> ${newEventId}`,
         );
 
         // if the message was sent, we expect an event id
@@ -2562,8 +2522,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         if (!redactId) {
             return;
         }
-        const redactedEvent = this.getUnfilteredTimelineSet()
-            .findEventById(redactId);
+        const redactedEvent = this.getUnfilteredTimelineSet().findEventById(redactId);
         if (redactedEvent) {
             redactedEvent.unmarkLocallyRedacted();
             // re-render after undoing redaction
@@ -2596,7 +2555,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
     ): void {
         let duplicateStrategy: DuplicateStrategy | undefined = duplicateStrategyOrOpts as DuplicateStrategy;
         let timelineWasEmpty: boolean | undefined = false;
-        if (typeof (duplicateStrategyOrOpts) === 'object') {
+        if (typeof duplicateStrategyOrOpts === "object") {
             ({
                 duplicateStrategy,
                 fromCache = false,
@@ -2607,9 +2566,9 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             // Deprecation warning
             // FIXME: Remove after 2023-06-01 (technical debt)
             logger.warn(
-                'Overload deprecated: ' +
-                '`Room.addLiveEvents(events, duplicateStrategy?, fromCache?)` ' +
-                'is deprecated in favor of the overload with `Room.addLiveEvents(events, IAddLiveEventOptions)`',
+                "Overload deprecated: " +
+                    "`Room.addLiveEvents(events, duplicateStrategy?, fromCache?)` " +
+                    "is deprecated in favor of the overload with `Room.addLiveEvents(events, IAddLiveEventOptions)`",
             );
         }
 
@@ -2622,8 +2581,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             const liveTimeline = this.timelineSets[i].getLiveTimeline();
             if (liveTimeline.getPaginationToken(EventTimeline.FORWARDS)) {
                 throw new Error(
-                    "live timeline " + i + " is no longer live - it has a pagination token " +
-                    "(" + liveTimeline.getPaginationToken(EventTimeline.FORWARDS) + ")",
+                    "live timeline " +
+                        i +
+                        " is no longer live - it has a pagination token " +
+                        "(" +
+                        liveTimeline.getPaginationToken(EventTimeline.FORWARDS) +
+                        ")",
                 );
             }
             if (liveTimeline.getNeighbouringTimeline(EventTimeline.FORWARDS)) {
@@ -2653,11 +2616,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 }
             }
 
-            const {
-                shouldLiveInRoom,
-                shouldLiveInThread,
-                threadId,
-            } = this.eventShouldLiveIn(event, events, threadRoots);
+            const { shouldLiveInRoom, shouldLiveInThread, threadId } = this.eventShouldLiveIn(
+                event,
+                events,
+                threadRoots,
+            );
 
             if (shouldLiveInThread && !eventsByThread[threadId ?? ""]) {
                 eventsByThread[threadId ?? ""] = [];
@@ -2674,39 +2637,38 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         });
     }
 
-    public partitionThreadedEvents(events: MatrixEvent[]): [
-        timelineEvents: MatrixEvent[],
-        threadedEvents: MatrixEvent[],
-    ] {
+    public partitionThreadedEvents(
+        events: MatrixEvent[],
+    ): [timelineEvents: MatrixEvent[], threadedEvents: MatrixEvent[]] {
         // Indices to the events array, for readability
         const ROOM = 0;
         const THREAD = 1;
         if (this.client.supportsExperimentalThreads()) {
             const threadRoots = this.findThreadRoots(events);
-            return events.reduce((memo, event: MatrixEvent) => {
-                const {
-                    shouldLiveInRoom,
-                    shouldLiveInThread,
-                    threadId,
-                } = this.eventShouldLiveIn(event, events, threadRoots);
-
-                if (shouldLiveInRoom) {
-                    memo[ROOM].push(event);
-                }
+            return events.reduce(
+                (memo, event: MatrixEvent) => {
+                    const { shouldLiveInRoom, shouldLiveInThread, threadId } = this.eventShouldLiveIn(
+                        event,
+                        events,
+                        threadRoots,
+                    );
 
-                if (shouldLiveInThread) {
-                    event.setThreadId(threadId ?? "");
-                    memo[THREAD].push(event);
-                }
+                    if (shouldLiveInRoom) {
+                        memo[ROOM].push(event);
+                    }
 
-                return memo;
-            }, [[] as MatrixEvent[], [] as MatrixEvent[]]);
+                    if (shouldLiveInThread) {
+                        event.setThreadId(threadId ?? "");
+                        memo[THREAD].push(event);
+                    }
+
+                    return memo;
+                },
+                [[] as MatrixEvent[], [] as MatrixEvent[]],
+            );
         } else {
             // When `experimentalThreadSupport` is disabled treat all events as timelineEvents
-            return [
-                events as MatrixEvent[],
-                [] as MatrixEvent[],
-            ];
+            return [events as MatrixEvent[], [] as MatrixEvent[]];
         }
     }
 
@@ -2832,14 +2794,16 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                     const existingEvent = this.currentState.getStateEvents(strippedEvent.type, strippedEvent.state_key);
                     if (!existingEvent) {
                         // set the fake stripped event instead
-                        this.currentState.setStateEvents([new MatrixEvent({
-                            type: strippedEvent.type,
-                            state_key: strippedEvent.state_key,
-                            content: strippedEvent.content,
-                            event_id: "$fake" + Date.now(),
-                            room_id: this.roomId,
-                            user_id: this.myUserId, // technically a lie
-                        })]);
+                        this.currentState.setStateEvents([
+                            new MatrixEvent({
+                                type: strippedEvent.type,
+                                state_key: strippedEvent.state_key,
+                                content: strippedEvent.content,
+                                event_id: "$fake" + Date.now(),
+                                room_id: this.roomId,
+                                user_id: this.myUserId, // technically a lie
+                            }),
+                        ]);
                     }
                 });
             }
@@ -2908,9 +2872,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      *                   message events into the room.
      */
     public maySendMessage(): boolean {
-        return this.getMyMembership() === 'join' && (this.client.isRoomEncrypted(this.roomId)
-            ? this.currentState.maySendEvent(EventType.RoomMessageEncrypted, this.myUserId)
-            : this.currentState.maySendEvent(EventType.RoomMessage, this.myUserId));
+        return (
+            this.getMyMembership() === "join" &&
+            (this.client.isRoomEncrypted(this.roomId)
+                ? this.currentState.maySendEvent(EventType.RoomMessageEncrypted, this.myUserId)
+                : this.currentState.maySendEvent(EventType.RoomMessage, this.myUserId))
+        );
     }
 
     /**
@@ -3105,7 +3072,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         const myMembership = this.getMyMembership();
         // if I have created a room and invited people through
         // 3rd party invites
-        if (myMembership == 'join') {
+        if (myMembership == "join") {
             const thirdPartyInvites = this.currentState.getStateEvents(EventType.RoomThirdPartyInvite);
 
             if (thirdPartyInvites?.length) {
@@ -3126,11 +3093,12 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         let leftNames = otherNames;
         // if we didn't have heroes, try finding them in the room state
         if (!leftNames.length) {
-            leftNames = this.currentState.getMembers().filter((m) => {
-                return m.userId !== userId &&
-                    m.membership !== "invite" &&
-                    m.membership !== "join";
-            }).map((m) => m.name);
+            leftNames = this.currentState
+                .getMembers()
+                .filter((m) => {
+                    return m.userId !== userId && m.membership !== "invite" && m.membership !== "join";
+                })
+                .map((m) => m.name);
         }
 
         let oldName: string | undefined;
@@ -3169,14 +3137,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             return;
         }
         const isPowerSufficient =
-            (
-                EVENT_VISIBILITY_CHANGE_TYPE.name
-                && this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.name, userId)
-            )
-            || (
-                EVENT_VISIBILITY_CHANGE_TYPE.altName
-                && this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.altName, userId)
-            );
+            (EVENT_VISIBILITY_CHANGE_TYPE.name &&
+                this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.name, userId)) ||
+            (EVENT_VISIBILITY_CHANGE_TYPE.altName &&
+                this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.altName, userId));
         if (!isPowerSufficient) {
             // Powerlevel is insufficient.
             return;
@@ -3196,8 +3160,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             // However, to protect against a potential DoS attack, we limit the
             // number of iterations in this loop.
             let index = visibilityEventsOnOriginalEvent.length - 1;
-            const min = Math.max(0,
-                visibilityEventsOnOriginalEvent.length - MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH);
+            const min = Math.max(
+                0,
+                visibilityEventsOnOriginalEvent.length - MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH,
+            );
             for (; index >= min; --index) {
                 const target = visibilityEventsOnOriginalEvent[index];
                 if (target.getTs() < event.getTs()) {
@@ -3237,7 +3203,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             // most likely because it was ill-formed.
             return;
         }
-        const index = visibilityEventsOnOriginalEvent.findIndex(change => change.getId() === event.getId());
+        const index = visibilityEventsOnOriginalEvent.findIndex((change) => change.getId() === event.getId());
         if (index === -1) {
             // This change event was not recorded, most likely because
             // it was ill-formed.
@@ -3306,27 +3272,11 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
 
 // a map from current event status to a list of allowed next statuses
 const ALLOWED_TRANSITIONS: Record<EventStatus, EventStatus[]> = {
-    [EventStatus.ENCRYPTING]: [
-        EventStatus.SENDING,
-        EventStatus.NOT_SENT,
-        EventStatus.CANCELLED,
-    ],
-    [EventStatus.SENDING]: [
-        EventStatus.ENCRYPTING,
-        EventStatus.QUEUED,
-        EventStatus.NOT_SENT,
-        EventStatus.SENT,
-    ],
-    [EventStatus.QUEUED]: [
-        EventStatus.SENDING,
-        EventStatus.CANCELLED,
-    ],
+    [EventStatus.ENCRYPTING]: [EventStatus.SENDING, EventStatus.NOT_SENT, EventStatus.CANCELLED],
+    [EventStatus.SENDING]: [EventStatus.ENCRYPTING, EventStatus.QUEUED, EventStatus.NOT_SENT, EventStatus.SENT],
+    [EventStatus.QUEUED]: [EventStatus.SENDING, EventStatus.CANCELLED],
     [EventStatus.SENT]: [],
-    [EventStatus.NOT_SENT]: [
-        EventStatus.SENDING,
-        EventStatus.QUEUED,
-        EventStatus.CANCELLED,
-    ],
+    [EventStatus.NOT_SENT]: [EventStatus.SENDING, EventStatus.QUEUED, EventStatus.CANCELLED],
     [EventStatus.CANCELLED]: [],
 };
 
diff --git a/src/models/search-result.ts b/src/models/search-result.ts
index 2f27495acf4..21192a6ea04 100644
--- a/src/models/search-result.ts
+++ b/src/models/search-result.ts
@@ -24,7 +24,7 @@ export class SearchResult {
      */
 
     public static fromJson(jsonObj: ISearchResult, eventMapper: EventMapper): SearchResult {
-        const jsonContext = jsonObj.context || {} as IResultContext;
+        const jsonContext = jsonObj.context || ({} as IResultContext);
         let eventsBefore = (jsonContext.events_before || []).map(eventMapper);
         let eventsAfter = (jsonContext.events_after || []).map(eventMapper);
 
@@ -32,8 +32,8 @@ export class SearchResult {
 
         // Filter out any contextual events which do not correspond to the same timeline (thread or room)
         const threadRootId = context.ourEvent.threadRootId;
-        eventsBefore = eventsBefore.filter(e => e.threadRootId === threadRootId);
-        eventsAfter = eventsAfter.filter(e => e.threadRootId === threadRootId);
+        eventsBefore = eventsBefore.filter((e) => e.threadRootId === threadRootId);
+        eventsAfter = eventsAfter.filter((e) => e.threadRootId === threadRootId);
 
         context.setPaginateToken(jsonContext.start, true);
         context.addEvents(eventsBefore, true);
diff --git a/src/models/thread.ts b/src/models/thread.ts
index 61b010a1859..998c2156912 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -21,8 +21,8 @@ import { TypedReEmitter } from "../ReEmitter";
 import { RelationType } from "../@types/event";
 import { EventStatus, IThreadBundledRelationship, MatrixEvent, MatrixEventEvent } from "./event";
 import { EventTimeline } from "./event-timeline";
-import { EventTimelineSet, EventTimelineSetHandlerMap } from './event-timeline-set';
-import { NotificationCountType, Room, RoomEvent } from './room';
+import { EventTimelineSet, EventTimelineSetHandlerMap } from "./event-timeline-set";
+import { NotificationCountType, Room, RoomEvent } from "./room";
 import { RoomState } from "./room-state";
 import { ServerControlledNamespacedValue } from "../NamespacedValue";
 import { logger } from "../logger";
@@ -34,12 +34,10 @@ export enum ThreadEvent {
     Update = "Thread.update",
     NewReply = "Thread.newReply",
     ViewThread = "Thread.viewThread",
-    Delete = "Thread.delete"
+    Delete = "Thread.delete",
 }
 
-type EmittedEvents = Exclude<ThreadEvent, ThreadEvent.New>
-    | RoomEvent.Timeline
-    | RoomEvent.TimelineReset;
+type EmittedEvents = Exclude<ThreadEvent, ThreadEvent.New> | RoomEvent.Timeline | RoomEvent.TimelineReset;
 
 export type EventHandlerMap = {
     [ThreadEvent.Update]: (thread: Thread) => void;
@@ -57,7 +55,7 @@ interface IThreadOpts {
 export enum FeatureSupport {
     None = 0,
     Experimental = 1,
-    Stable = 2
+    Stable = 2,
 }
 
 export function determineFeatureSupport(stable: boolean, unstable: boolean): FeatureSupport {
@@ -99,11 +97,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
     public initialEventsFetched = !Thread.hasServerSideSupport;
 
-    public constructor(
-        public readonly id: string,
-        public rootEvent: MatrixEvent | undefined,
-        opts: IThreadOpts,
-    ) {
+    public constructor(public readonly id: string, public rootEvent: MatrixEvent | undefined, opts: IThreadOpts) {
         super();
 
         if (!opts?.room) {
@@ -115,16 +109,18 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         this.room = opts.room;
         this.client = opts.client;
         this.pendingEventOrdering = opts.pendingEventOrdering ?? PendingEventOrdering.Chronological;
-        this.timelineSet = new EventTimelineSet(this.room, {
-            timelineSupport: true,
-            pendingEvents: true,
-        }, this.client, this);
+        this.timelineSet = new EventTimelineSet(
+            this.room,
+            {
+                timelineSupport: true,
+                pendingEvents: true,
+            },
+            this.client,
+            this,
+        );
         this.reEmitter = new TypedReEmitter(this);
 
-        this.reEmitter.reEmit(this.timelineSet, [
-            RoomEvent.Timeline,
-            RoomEvent.TimelineReset,
-        ]);
+        this.reEmitter.reEmit(this.timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
 
         this.room.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
         this.room.on(RoomEvent.Redaction, this.onRedaction);
@@ -150,9 +146,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         await this.processEvent(this.rootEvent);
     }
 
-    public static setServerSideSupport(
-        status: FeatureSupport,
-    ): void {
+    public static setServerSideSupport(status: FeatureSupport): void {
         Thread.hasServerSideSupport = status;
         if (status !== FeatureSupport.Stable) {
             FILTER_RELATED_BY_SENDERS.setPreferUnstable(true);
@@ -161,20 +155,17 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         }
     }
 
-    public static setServerSideListSupport(
-        status: FeatureSupport,
-    ): void {
+    public static setServerSideListSupport(status: FeatureSupport): void {
         Thread.hasServerSideListSupport = status;
     }
 
-    public static setServerSideFwdPaginationSupport(
-        status: FeatureSupport,
-    ): void {
+    public static setServerSideFwdPaginationSupport(status: FeatureSupport): void {
         Thread.hasServerSideFwdPaginationSupport = status;
     }
 
     private onBeforeRedaction = (event: MatrixEvent, redaction: MatrixEvent): void => {
-        if (event?.isRelation(THREAD_RELATION_TYPE.name) &&
+        if (
+            event?.isRelation(THREAD_RELATION_TYPE.name) &&
             this.room.eventShouldLiveIn(event).threadId === this.id &&
             event.getId() !== this.id && // the root event isn't counted in the length so ignore this redaction
             !redaction.status // only respect it when it succeeds
@@ -225,21 +216,17 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
     private addEventToTimeline(event: MatrixEvent, toStartOfTimeline: boolean): void {
         if (!this.findEventById(event.getId()!)) {
-            this.timelineSet.addEventToTimeline(
-                event,
-                this.liveTimeline,
-                {
-                    toStartOfTimeline,
-                    fromCache: false,
-                    roomState: this.roomState,
-                },
-            );
+            this.timelineSet.addEventToTimeline(event, this.liveTimeline, {
+                toStartOfTimeline,
+                fromCache: false,
+                roomState: this.roomState,
+            });
             this.timeline = this.events;
         }
     }
 
     public addEvents(events: MatrixEvent[], toStartOfTimeline: boolean): void {
-        events.forEach(ev => this.addEvent(ev, toStartOfTimeline, false));
+        events.forEach((ev) => this.addEvent(ev, toStartOfTimeline, false));
         this.updateThreadMetadata();
     }
 
@@ -318,13 +305,14 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
         let pendingEvents: MatrixEvent[];
         if (this.pendingEventOrdering === PendingEventOrdering.Detached) {
-            pendingEvents = this.room.getPendingEvents()
-                .filter(ev => ev.isRelation(THREAD_RELATION_TYPE.name) && this.id === ev.threadRootId);
-            await Promise.all(pendingEvents.map(ev => this.processEvent(ev)));
+            pendingEvents = this.room
+                .getPendingEvents()
+                .filter((ev) => ev.isRelation(THREAD_RELATION_TYPE.name) && this.id === ev.threadRootId);
+            await Promise.all(pendingEvents.map((ev) => this.processEvent(ev)));
         } else {
             pendingEvents = this.events
-                .filter(ev => ev.isRelation(THREAD_RELATION_TYPE.name))
-                .filter(ev => ev.status !== EventStatus.SENT && ev.status !== EventStatus.CANCELLED);
+                .filter((ev) => ev.isRelation(THREAD_RELATION_TYPE.name))
+                .filter((ev) => ev.status !== EventStatus.SENT && ev.status !== EventStatus.CANCELLED);
         }
         this.lastPendingEvent = pendingEvents.length ? pendingEvents[pendingEvents.length - 1] : undefined;
         this.pendingReplyCount = pendingEvents.length;
@@ -362,18 +350,25 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
     // XXX: Workaround for https://github.com/matrix-org/matrix-spec-proposals/pull/2676/files#r827240084
     private async fetchEditsWhereNeeded(...events: MatrixEvent[]): Promise<unknown> {
-        return Promise.all(events.filter(e => e.isEncrypted()).map((event: MatrixEvent) => {
-            if (event.isRelation()) return; // skip - relations don't get edits
-            return this.client.relations(this.roomId, event.getId()!, RelationType.Replace, event.getType(), {
-                limit: 1,
-            }).then(relations => {
-                if (relations.events.length) {
-                    event.makeReplaced(relations.events[0]);
-                }
-            }).catch(e => {
-                logger.error("Failed to load edits for encrypted thread event", e);
-            });
-        }));
+        return Promise.all(
+            events
+                .filter((e) => e.isEncrypted())
+                .map((event: MatrixEvent) => {
+                    if (event.isRelation()) return; // skip - relations don't get edits
+                    return this.client
+                        .relations(this.roomId, event.getId()!, RelationType.Replace, event.getType(), {
+                            limit: 1,
+                        })
+                        .then((relations) => {
+                            if (relations.events.length) {
+                                event.makeReplaced(relations.events[0]);
+                            }
+                        })
+                        .catch((e) => {
+                            logger.error("Failed to load edits for encrypted thread event", e);
+                        });
+                }),
+        );
     }
 
     public setEventMetadata(event: Optional<MatrixEvent>): void {
@@ -486,21 +481,18 @@ export const FILTER_RELATED_BY_REL_TYPES = new ServerControlledNamespacedValue(
     "related_by_rel_types",
     "io.element.relation_types",
 );
-export const THREAD_RELATION_TYPE = new ServerControlledNamespacedValue(
-    "m.thread",
-    "io.element.thread",
-);
+export const THREAD_RELATION_TYPE = new ServerControlledNamespacedValue("m.thread", "io.element.thread");
 
 export enum ThreadFilterType {
     "My",
-    "All"
+    "All",
 }
 
-export function threadFilterTypeToFilter(type: ThreadFilterType | null): 'all' | 'participated' {
+export function threadFilterTypeToFilter(type: ThreadFilterType | null): "all" | "participated" {
     switch (type) {
         case ThreadFilterType.My:
-            return 'participated';
+            return "participated";
         default:
-            return 'all';
+            return "all";
     }
 }
diff --git a/src/models/typed-event-emitter.ts b/src/models/typed-event-emitter.ts
index f9150077821..3cfe602f8fb 100644
--- a/src/models/typed-event-emitter.ts
+++ b/src/models/typed-event-emitter.ts
@@ -28,12 +28,10 @@ export type ListenerMap<E extends string> = { [eventName in E]: AnyListener };
 type EventEmitterEventListener = (eventName: string, listener: AnyListener) => void;
 type EventEmitterErrorListener = (error: Error) => void;
 
-export type Listener<
-    E extends string,
-    A extends ListenerMap<E>,
-    T extends E | EventEmitterEvents,
-> = T extends E ? A[T]
-    : T extends EventEmitterEvents ? EventEmitterErrorListener
+export type Listener<E extends string, A extends ListenerMap<E>, T extends E | EventEmitterEvents> = T extends E
+    ? A[T]
+    : T extends EventEmitterEvents
+    ? EventEmitterErrorListener
     : EventEmitterEventListener;
 
 /**
@@ -73,24 +71,15 @@ export class TypedEventEmitter<
         return super.listeners(event);
     }
 
-    public off<T extends Events | EventEmitterEvents>(
-        event: T,
-        listener: Listener<Events, Arguments, T>,
-    ): this {
+    public off<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
         return super.off(event, listener);
     }
 
-    public on<T extends Events | EventEmitterEvents>(
-        event: T,
-        listener: Listener<Events, Arguments, T>,
-    ): this {
+    public on<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
         return super.on(event, listener);
     }
 
-    public once<T extends Events | EventEmitterEvents>(
-        event: T,
-        listener: Listener<Events, Arguments, T>,
-    ): this {
+    public once<T extends Events | EventEmitterEvents>(event: T, listener: Listener<Events, Arguments, T>): this {
         return super.once(event, listener);
     }
 
diff --git a/src/models/user.ts b/src/models/user.ts
index 3dd199f3b1d..054a17438f2 100644
--- a/src/models/user.ts
+++ b/src/models/user.ts
@@ -182,16 +182,16 @@ export class User extends TypedEventEmitter<UserEvent, UserEventHandlerMap> {
         if (event.getContent().presence !== this.presence || firstFire) {
             eventsToFire.push(UserEvent.Presence);
         }
-        if (event.getContent().avatar_url &&
-            event.getContent().avatar_url !== this.avatarUrl) {
+        if (event.getContent().avatar_url && event.getContent().avatar_url !== this.avatarUrl) {
             eventsToFire.push(UserEvent.AvatarUrl);
         }
-        if (event.getContent().displayname &&
-            event.getContent().displayname !== this.displayName) {
+        if (event.getContent().displayname && event.getContent().displayname !== this.displayName) {
             eventsToFire.push(UserEvent.DisplayName);
         }
-        if (event.getContent().currently_active !== undefined &&
-            event.getContent().currently_active !== this.currentlyActive) {
+        if (
+            event.getContent().currently_active !== undefined &&
+            event.getContent().currently_active !== this.currentlyActive
+        ) {
             eventsToFire.push(UserEvent.CurrentlyActive);
         }
 
diff --git a/src/pushprocessor.ts b/src/pushprocessor.ts
index e6a30769256..0d7338f8fb1 100644
--- a/src/pushprocessor.ts
+++ b/src/pushprocessor.ts
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 import { deepCompare, escapeRegExp, globToRegexp, isNullOrUndefined } from "./utils";
-import { logger } from './logger';
+import { logger } from "./logger";
 import { MatrixClient } from "./client";
 import { MatrixEvent } from "./models/event";
 import {
@@ -66,9 +66,7 @@ const DEFAULT_OVERRIDE_RULES: IPushRule[] = [
                 pattern: "m.reaction",
             },
         ],
-        actions: [
-            PushRuleActionName.DontNotify,
-        ],
+        actions: [PushRuleActionName.DontNotify],
     },
     {
         // For homeservers which don't support MSC3786 yet
@@ -139,7 +137,7 @@ export class PushProcessor {
         for (const action of actionList) {
             if (action === PushRuleActionName.Notify) {
                 actionObj.notify = true;
-            } else if (typeof action === 'object') {
+            } else if (typeof action === "object") {
                 if (action.value === undefined) {
                     action.value = true;
                 }
@@ -169,8 +167,7 @@ export class PushProcessor {
         // Merge the client-level defaults with the ones from the server
         const globalOverrides = newRules.global.override;
         for (const override of DEFAULT_OVERRIDE_RULES) {
-            const existingRule = globalOverrides
-                .find((r) => r.rule_id === override.rule_id);
+            const existingRule = globalOverrides.find((r) => r.rule_id === override.rule_id);
 
             if (existingRule) {
                 // Copy over the actions, default, and conditions. Don't touch the user's preference.
@@ -187,8 +184,7 @@ export class PushProcessor {
 
         const globalUnderrides = newRules.global.underride ?? [];
         for (const underride of DEFAULT_UNDERRIDE_RULES) {
-            const existingRule = globalUnderrides
-                .find((r) => r.rule_id === underride.rule_id);
+            const existingRule = globalUnderrides.find((r) => r.rule_id === underride.rule_id);
 
             if (existingRule) {
                 // Copy over the actions, default, and conditions. Don't touch the user's preference.
@@ -241,9 +237,9 @@ export class PushProcessor {
         tprule: IPushRule,
     ): Pick<IPushRule, "rule_id" | "actions" | "conditions"> | null {
         const rawrule: Pick<IPushRule, "rule_id" | "actions" | "conditions"> = {
-            'rule_id': tprule.rule_id,
-            'actions': tprule.actions,
-            'conditions': [],
+            rule_id: tprule.rule_id,
+            actions: tprule.actions,
+            conditions: [],
         };
         switch (kind) {
             case PushRuleKind.Underride:
@@ -255,9 +251,9 @@ export class PushProcessor {
                     return null;
                 }
                 rawrule.conditions!.push({
-                    'kind': ConditionKind.EventMatch,
-                    'key': 'room_id',
-                    'value': tprule.rule_id,
+                    kind: ConditionKind.EventMatch,
+                    key: "room_id",
+                    value: tprule.rule_id,
                 });
                 break;
             case PushRuleKind.SenderSpecific:
@@ -265,9 +261,9 @@ export class PushProcessor {
                     return null;
                 }
                 rawrule.conditions!.push({
-                    'kind': ConditionKind.EventMatch,
-                    'key': 'user_id',
-                    'value': tprule.rule_id,
+                    kind: ConditionKind.EventMatch,
+                    key: "user_id",
+                    value: tprule.rule_id,
                 });
                 break;
             case PushRuleKind.ContentSpecific:
@@ -275,9 +271,9 @@ export class PushProcessor {
                     return null;
                 }
                 rawrule.conditions!.push({
-                    'kind': ConditionKind.EventMatch,
-                    'key': 'content.body',
-                    'pattern': tprule.pattern,
+                    kind: ConditionKind.EventMatch,
+                    key: "content.body",
+                    pattern: tprule.pattern,
                 });
                 break;
         }
@@ -309,7 +305,7 @@ export class PushProcessor {
         cond: ISenderNotificationPermissionCondition,
         ev: MatrixEvent,
     ): boolean {
-        const notifLevelKey = cond['key'];
+        const notifLevelKey = cond["key"];
         if (!notifLevelKey) {
             return false;
         }
@@ -347,16 +343,16 @@ export class PushProcessor {
             return false;
         }
         switch (ineq) {
-            case '':
-            case '==':
+            case "":
+            case "==":
                 return memberCount == rhs;
-            case '<':
+            case "<":
                 return memberCount < rhs;
-            case '>':
+            case ">":
                 return memberCount > rhs;
-            case '<=':
+            case "<=":
                 return memberCount <= rhs;
-            case '>=':
+            case ">=":
                 return memberCount >= rhs;
             default:
                 return false;
@@ -368,7 +364,7 @@ export class PushProcessor {
         if (ev.isEncrypted() && ev.getClearContent()) {
             content = ev.getClearContent()!;
         }
-        if (!content || !content.body || typeof content.body != 'string') {
+        if (!content || !content.body || typeof content.body != "string") {
             return false;
         }
 
@@ -382,7 +378,7 @@ export class PushProcessor {
 
         // N.B. we can't use \b as it chokes on unicode. however \W seems to be okay
         // as shorthand for [^0-9A-Za-z_].
-        const pat = new RegExp("(^|\\W)" + escapeRegExp(displayName) + "(\\W|$)", 'i');
+        const pat = new RegExp("(^|\\W)" + escapeRegExp(displayName) + "(\\W|$)", "i");
         return content.body.search(pat) > -1;
     }
 
@@ -392,7 +388,7 @@ export class PushProcessor {
         }
 
         const val = this.valueForDottedKey(cond.key, ev);
-        if (typeof val !== 'string') {
+        if (typeof val !== "string") {
             return false;
         }
 
@@ -400,13 +396,14 @@ export class PushProcessor {
             return cond.value === val;
         }
 
-        if (typeof cond.pattern !== 'string') {
+        if (typeof cond.pattern !== "string") {
             return false;
         }
 
-        const regex = cond.key === 'content.body'
-            ? this.createCachedRegex('(^|\\W)', cond.pattern, '(\\W|$)')
-            : this.createCachedRegex('^', cond.pattern, '$');
+        const regex =
+            cond.key === "content.body"
+                ? this.createCachedRegex("(^|\\W)", cond.pattern, "(\\W|$)")
+                : this.createCachedRegex("^", cond.pattern, "$");
 
         return !!val.match(regex);
     }
@@ -418,12 +415,10 @@ export class PushProcessor {
         // Since servers don't support properly sending push notification
         // about MSC3401 call events, we do the handling ourselves
         return (
-            ["m.ring", "m.prompt"].includes(ev.getContent()["m.intent"])
-            && !("m.terminated" in ev.getContent())
-            && (
-                (ev.getPrevContent()["m.terminated"] !== ev.getContent()["m.terminated"])
-                || deepCompare(ev.getPrevContent(), {})
-            )
+            ["m.ring", "m.prompt"].includes(ev.getContent()["m.intent"]) &&
+            !("m.terminated" in ev.getContent()) &&
+            (ev.getPrevContent()["m.terminated"] !== ev.getContent()["m.terminated"] ||
+                deepCompare(ev.getPrevContent(), {}))
         );
     }
 
@@ -433,21 +428,21 @@ export class PushProcessor {
         }
         PushProcessor.cachedGlobToRegex[glob] = new RegExp(
             prefix + globToRegexp(glob) + suffix,
-            'i', // Case insensitive
+            "i", // Case insensitive
         );
         return PushProcessor.cachedGlobToRegex[glob];
     }
 
     private valueForDottedKey(key: string, ev: MatrixEvent): any {
-        const parts = key.split('.');
+        const parts = key.split(".");
         let val: any;
 
         // special-case the first component to deal with encrypted messages
         const firstPart = parts[0];
-        if (firstPart === 'content') {
+        if (firstPart === "content") {
             val = ev.getContent();
             parts.shift();
-        } else if (firstPart === 'type') {
+        } else if (firstPart === "type") {
             val = ev.getType();
             parts.shift();
         } else {
@@ -488,14 +483,14 @@ export class PushProcessor {
         if (actionObj.tweaks.highlight === undefined) {
             // if it isn't specified, highlight if it's a content
             // rule but otherwise not
-            actionObj.tweaks.highlight = (rule.kind == PushRuleKind.ContentSpecific);
+            actionObj.tweaks.highlight = rule.kind == PushRuleKind.ContentSpecific;
         }
 
         return actionObj;
     }
 
     public ruleMatchesEvent(rule: Partial<IPushRule> & Pick<IPushRule, "conditions">, ev: MatrixEvent): boolean {
-        return !rule.conditions?.some(cond => !this.eventFulfillsCondition(cond, ev));
+        return !rule.conditions?.some((cond) => !this.eventFulfillsCondition(cond, ev));
     }
 
     /**
@@ -512,7 +507,7 @@ export class PushProcessor {
      * @returns The push rule, or null if no such rule was found
      */
     public getPushRuleById(ruleId: string): IPushRule | null {
-        for (const scope of ['global'] as const) {
+        for (const scope of ["global"] as const) {
             if (this.client.pushRules?.[scope] === undefined) continue;
 
             for (const kind of RULEKINDS_IN_ORDER) {
diff --git a/src/realtime-callbacks.ts b/src/realtime-callbacks.ts
index 005e9816bc5..1b03a579a28 100644
--- a/src/realtime-callbacks.ts
+++ b/src/realtime-callbacks.ts
@@ -24,7 +24,7 @@ limitations under the License.
  * it will instead fire as soon as possible after resume.
  */
 
-import { logger } from './logger';
+import { logger } from "./logger";
 
 // we schedule a callback at least this often, to check if we've missed out on
 // some wall-clock time due to being suspended.
@@ -49,7 +49,7 @@ const callbackList: Callback[] = [];
 
 // var debuglog = logger.log.bind(logger);
 /* istanbul ignore next */
-const debuglog = function(...params: any[]): void {};
+const debuglog = function (...params: any[]): void {};
 
 /**
  * reimplementation of window.setTimeout, which will call the callback if
@@ -69,8 +69,7 @@ export function setTimeout(func: (...params: any[]) => void, delayMs: number, ..
 
     const runAt = Date.now() + delayMs;
     const key = count++;
-    debuglog("setTimeout: scheduling cb", key, "at", runAt,
-        "(delay", delayMs, ")");
+    debuglog("setTimeout: scheduling cb", key, "at", runAt, "(delay", delayMs, ")");
     const data = {
         runAt: runAt,
         func: func,
@@ -79,11 +78,9 @@ export function setTimeout(func: (...params: any[]) => void, delayMs: number, ..
     };
 
     // figure out where it goes in the list
-    const idx = binarySearch(
-        callbackList, function(el) {
-            return el.runAt - runAt;
-        },
-    );
+    const idx = binarySearch(callbackList, function (el) {
+        return el.runAt - runAt;
+    });
 
     callbackList.splice(idx, 0, data);
     scheduleRealCallback();
diff --git a/src/rendezvous/MSC3906Rendezvous.ts b/src/rendezvous/MSC3906Rendezvous.ts
index d4ed1bc1709..f431c8358d0 100644
--- a/src/rendezvous/MSC3906Rendezvous.ts
+++ b/src/rendezvous/MSC3906Rendezvous.ts
@@ -25,17 +25,17 @@ import { logger } from "../logger";
 import { sleep } from "../utils";
 
 enum PayloadType {
-    Start = 'm.login.start',
-    Finish = 'm.login.finish',
-    Progress = 'm.login.progress',
+    Start = "m.login.start",
+    Finish = "m.login.finish",
+    Progress = "m.login.progress",
 }
 
 enum Outcome {
-    Success = 'success',
-    Failure = 'failure',
-    Verified = 'verified',
-    Declined = 'declined',
-    Unsupported = 'unsupported',
+    Success = "success",
+    Failure = "failure",
+    Verified = "verified",
+    Declined = "declined",
+    Unsupported = "unsupported",
 }
 
 export interface MSC3906RendezvousPayload {
@@ -111,13 +111,13 @@ export class MSC3906Rendezvous {
 
         await this.send({ type: PayloadType.Progress, protocols: [LOGIN_TOKEN_PROTOCOL.name] });
 
-        logger.info('Waiting for other device to chose protocol');
+        logger.info("Waiting for other device to chose protocol");
         const { type, protocol, outcome } = await this.receive();
 
         if (type === PayloadType.Finish) {
             // new device decided not to complete
-            switch (outcome ?? '') {
-                case 'unsupported':
+            switch (outcome ?? "") {
+                case "unsupported":
                     await this.cancel(RendezvousFailureReason.UnsupportedAlgorithm);
                     break;
                 default:
@@ -140,7 +140,7 @@ export class MSC3906Rendezvous {
     }
 
     private async receive(): Promise<MSC3906RendezvousPayload> {
-        return await this.channel.receive() as MSC3906RendezvousPayload;
+        return (await this.channel.receive()) as MSC3906RendezvousPayload;
     }
 
     private async send(payload: MSC3906RendezvousPayload): Promise<void> {
@@ -148,7 +148,7 @@ export class MSC3906Rendezvous {
     }
 
     public async declineLoginOnExistingDevice(): Promise<void> {
-        logger.info('User declined sign in');
+        logger.info("User declined sign in");
         await this.send({ type: PayloadType.Finish, outcome: Outcome.Declined });
     }
 
@@ -156,15 +156,15 @@ export class MSC3906Rendezvous {
         // eslint-disable-next-line camelcase
         await this.send({ type: PayloadType.Progress, login_token: loginToken, homeserver: this.client.baseUrl });
 
-        logger.info('Waiting for outcome');
+        logger.info("Waiting for outcome");
         const res = await this.receive();
         if (!res) {
             return undefined;
         }
         const { outcome, device_id: deviceId, device_key: deviceKey } = res;
 
-        if (outcome !== 'success') {
-            throw new Error('Linking failed');
+        if (outcome !== "success") {
+            throw new Error("Linking failed");
         }
 
         this.newDeviceId = deviceId;
@@ -175,11 +175,11 @@ export class MSC3906Rendezvous {
 
     private async verifyAndCrossSignDevice(deviceInfo: DeviceInfo): Promise<CrossSigningInfo | DeviceInfo> {
         if (!this.client.crypto) {
-            throw new Error('Crypto not available on client');
+            throw new Error("Crypto not available on client");
         }
 
         if (!this.newDeviceId) {
-            throw new Error('No new device ID set');
+            throw new Error("No new device ID set");
         }
 
         // check that keys received from the server for the new device match those received from the device itself
@@ -192,17 +192,13 @@ export class MSC3906Rendezvous {
         const userId = this.client.getUserId();
 
         if (!userId) {
-            throw new Error('No user ID set');
+            throw new Error("No user ID set");
         }
         // mark the device as verified locally + cross sign
         logger.info(`Marking device ${this.newDeviceId} as verified`);
-        const info = await this.client.crypto.setDeviceVerification(
-            userId,
-            this.newDeviceId,
-            true, false, true,
-        );
+        const info = await this.client.crypto.setDeviceVerification(userId, this.newDeviceId, true, false, true);
 
-        const masterPublicKey = this.client.crypto.crossSigningInfo.getId('master')!;
+        const masterPublicKey = this.client.crypto.crossSigningInfo.getId("master")!;
 
         await this.send({
             type: PayloadType.Finish,
@@ -224,7 +220,7 @@ export class MSC3906Rendezvous {
         timeout = 10 * 1000,
     ): Promise<DeviceInfo | CrossSigningInfo | undefined> {
         if (!this.newDeviceId) {
-            throw new Error('No new device to sign');
+            throw new Error("No new device to sign");
         }
 
         if (!this.newDeviceKey) {
@@ -233,13 +229,13 @@ export class MSC3906Rendezvous {
         }
 
         if (!this.client.crypto) {
-            throw new Error('Crypto not available on client');
+            throw new Error("Crypto not available on client");
         }
 
         const userId = this.client.getUserId();
 
         if (!userId) {
-            throw new Error('No user ID set');
+            throw new Error("No user ID set");
         }
 
         let deviceInfo = this.client.crypto.getStoredDevice(userId, this.newDeviceId);
@@ -254,7 +250,7 @@ export class MSC3906Rendezvous {
             return await this.verifyAndCrossSignDevice(deviceInfo);
         }
 
-        throw new Error('Device not online within timeout');
+        throw new Error("Device not online within timeout");
     }
 
     public async cancel(reason: RendezvousFailureReason): Promise<void> {
diff --git a/src/rendezvous/RendezvousChannel.ts b/src/rendezvous/RendezvousChannel.ts
index f5c35217ff3..549ebc83f51 100644
--- a/src/rendezvous/RendezvousChannel.ts
+++ b/src/rendezvous/RendezvousChannel.ts
@@ -14,11 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import {
-    RendezvousCode,
-    RendezvousIntent,
-    RendezvousFailureReason,
-} from ".";
+import { RendezvousCode, RendezvousIntent, RendezvousFailureReason } from ".";
 
 export interface RendezvousChannel<T> {
     /**
diff --git a/src/rendezvous/RendezvousFailureReason.ts b/src/rendezvous/RendezvousFailureReason.ts
index c23168dd154..b19a91cec0b 100644
--- a/src/rendezvous/RendezvousFailureReason.ts
+++ b/src/rendezvous/RendezvousFailureReason.ts
@@ -17,15 +17,15 @@ limitations under the License.
 export type RendezvousFailureListener = (reason: RendezvousFailureReason) => void;
 
 export enum RendezvousFailureReason {
-  UserDeclined = 'user_declined',
-  OtherDeviceNotSignedIn = 'other_device_not_signed_in',
-  OtherDeviceAlreadySignedIn = 'other_device_already_signed_in',
-  Unknown = 'unknown',
-  Expired = 'expired',
-  UserCancelled = 'user_cancelled',
-  InvalidCode = 'invalid_code',
-  UnsupportedAlgorithm = 'unsupported_algorithm',
-  DataMismatch = 'data_mismatch',
-  UnsupportedTransport = 'unsupported_transport',
-  HomeserverLacksSupport = 'homeserver_lacks_support',
+    UserDeclined = "user_declined",
+    OtherDeviceNotSignedIn = "other_device_not_signed_in",
+    OtherDeviceAlreadySignedIn = "other_device_already_signed_in",
+    Unknown = "unknown",
+    Expired = "expired",
+    UserCancelled = "user_cancelled",
+    InvalidCode = "invalid_code",
+    UnsupportedAlgorithm = "unsupported_algorithm",
+    DataMismatch = "data_mismatch",
+    UnsupportedTransport = "unsupported_transport",
+    HomeserverLacksSupport = "homeserver_lacks_support",
 }
diff --git a/src/rendezvous/RendezvousIntent.ts b/src/rendezvous/RendezvousIntent.ts
index 98b64ecb0ad..db53ef9cb86 100644
--- a/src/rendezvous/RendezvousIntent.ts
+++ b/src/rendezvous/RendezvousIntent.ts
@@ -15,6 +15,6 @@ limitations under the License.
 */
 
 export enum RendezvousIntent {
-  LOGIN_ON_NEW_DEVICE = "login.start",
-  RECIPROCATE_LOGIN_ON_EXISTING_DEVICE = "login.reciprocate",
+    LOGIN_ON_NEW_DEVICE = "login.start",
+    RECIPROCATE_LOGIN_ON_EXISTING_DEVICE = "login.reciprocate",
 }
diff --git a/src/rendezvous/RendezvousTransport.ts b/src/rendezvous/RendezvousTransport.ts
index 8721febffa0..08905be65e8 100644
--- a/src/rendezvous/RendezvousTransport.ts
+++ b/src/rendezvous/RendezvousTransport.ts
@@ -17,42 +17,42 @@ limitations under the License.
 import { RendezvousFailureListener, RendezvousFailureReason } from ".";
 
 export interface RendezvousTransportDetails {
-  type: string;
+    type: string;
 }
 
 /**
  * Interface representing a generic rendezvous transport.
  */
 export interface RendezvousTransport<T> {
-  /**
-   * Ready state of the transport. This is set to true when the transport is ready to be used.
-   */
-  readonly ready: boolean;
-
-  /**
-   * Listener for cancellation events. This is called when the rendezvous is cancelled or fails.
-   */
-  onFailure?: RendezvousFailureListener;
-
-  /**
-   * @returns the transport details that can be encoded in a QR or similar
-   */
-  details(): Promise<RendezvousTransportDetails>;
-
-  /**
-   * Send data via the transport.
-   * @param data - the data itself
-   */
-  send(data: T): Promise<void>;
-
-  /**
-   * Receive data from the transport.
-   */
-  receive(): Promise<Partial<T> | undefined>;
-
-  /**
-   * Cancel the rendezvous. This will call `onCancelled()` if it is set.
-   * @param reason - the reason for the cancellation/failure
-   */
-  cancel(reason: RendezvousFailureReason): Promise<void>;
+    /**
+     * Ready state of the transport. This is set to true when the transport is ready to be used.
+     */
+    readonly ready: boolean;
+
+    /**
+     * Listener for cancellation events. This is called when the rendezvous is cancelled or fails.
+     */
+    onFailure?: RendezvousFailureListener;
+
+    /**
+     * @returns the transport details that can be encoded in a QR or similar
+     */
+    details(): Promise<RendezvousTransportDetails>;
+
+    /**
+     * Send data via the transport.
+     * @param data - the data itself
+     */
+    send(data: T): Promise<void>;
+
+    /**
+     * Receive data from the transport.
+     */
+    receive(): Promise<Partial<T> | undefined>;
+
+    /**
+     * Cancel the rendezvous. This will call `onCancelled()` if it is set.
+     * @param reason - the reason for the cancellation/failure
+     */
+    cancel(reason: RendezvousFailureReason): Promise<void>;
 }
diff --git a/src/rendezvous/channels/MSC3903ECDHv1RendezvousChannel.ts b/src/rendezvous/channels/MSC3903ECDHv1RendezvousChannel.ts
index d3d5fc6807b..24ebcbe4c2e 100644
--- a/src/rendezvous/channels/MSC3903ECDHv1RendezvousChannel.ts
+++ b/src/rendezvous/channels/MSC3903ECDHv1RendezvousChannel.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { SAS } from '@matrix-org/olm';
+import { SAS } from "@matrix-org/olm";
 
 import {
     RendezvousError,
@@ -24,11 +24,11 @@ import {
     RendezvousTransportDetails,
     RendezvousTransport,
     RendezvousFailureReason,
-} from '..';
-import { encodeBase64, decodeBase64 } from '../../crypto/olmlib';
-import { crypto, subtleCrypto, TextEncoder } from '../../crypto/crypto';
-import { generateDecimalSas } from '../../crypto/verification/SASDecimal';
-import { UnstableValue } from '../../NamespacedValue';
+} from "..";
+import { encodeBase64, decodeBase64 } from "../../crypto/olmlib";
+import { crypto, subtleCrypto, TextEncoder } from "../../crypto/crypto";
+import { generateDecimalSas } from "../../crypto/verification/SASDecimal";
+import { UnstableValue } from "../../NamespacedValue";
 
 const ECDH_V1 = new UnstableValue(
     "m.rendezvous.v1.curve25519-aes-sha256",
@@ -57,16 +57,10 @@ export interface EncryptedPayload {
 
 async function importKey(key: Uint8Array): Promise<CryptoKey> {
     if (!subtleCrypto) {
-        throw new Error('Web Crypto is not available');
+        throw new Error("Web Crypto is not available");
     }
 
-    const imported = subtleCrypto.importKey(
-        'raw',
-        key,
-        { name: 'AES-GCM' },
-        false,
-        ['encrypt', 'decrypt'],
-    );
+    const imported = subtleCrypto.importKey("raw", key, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
 
     return imported;
 }
@@ -93,13 +87,13 @@ export class MSC3903ECDHv1RendezvousChannel<T> implements RendezvousChannel<T> {
 
     public async generateCode(intent: RendezvousIntent): Promise<ECDHv1RendezvousCode> {
         if (this.transport.ready) {
-            throw new Error('Code already generated');
+            throw new Error("Code already generated");
         }
 
         await this.transport.send({ algorithm: ECDH_V1.name });
 
         const rendezvous: ECDHv1RendezvousCode = {
-            "rendezvous": {
+            rendezvous: {
                 algorithm: ECDH_V1.name,
                 key: encodeBase64(this.ourPublicKey),
                 transport: await this.transport.details(),
@@ -112,11 +106,11 @@ export class MSC3903ECDHv1RendezvousChannel<T> implements RendezvousChannel<T> {
 
     public async connect(): Promise<string> {
         if (this.connected) {
-            throw new Error('Channel already connected');
+            throw new Error("Channel already connected");
         }
 
         if (!this.olmSAS) {
-            throw new Error('Channel closed');
+            throw new Error("Channel closed");
         }
 
         const isInitiator = !this.theirPublicKey;
@@ -125,13 +119,13 @@ export class MSC3903ECDHv1RendezvousChannel<T> implements RendezvousChannel<T> {
             // wait for the other side to send us their public key
             const rawRes = await this.transport.receive();
             if (!rawRes) {
-                throw new Error('No response from other device');
+                throw new Error("No response from other device");
             }
             const res = rawRes as Partial<PlainTextPayload>;
             const { key, algorithm } = res;
             if (!algorithm || !ECDH_V1.matches(algorithm) || !key) {
                 throw new RendezvousError(
-                    'Unsupported algorithm: ' + algorithm,
+                    "Unsupported algorithm: " + algorithm,
                     RendezvousFailureReason.UnsupportedAlgorithm,
                 );
             }
@@ -163,12 +157,12 @@ export class MSC3903ECDHv1RendezvousChannel<T> implements RendezvousChannel<T> {
         aesKeyBytes.fill(0);
 
         const rawChecksum = this.olmSAS.generate_bytes(aesInfo, 5);
-        return generateDecimalSas(Array.from(rawChecksum)).join('-');
+        return generateDecimalSas(Array.from(rawChecksum)).join("-");
     }
 
     private async encrypt(data: T): Promise<MSC3903ECDHPayload> {
         if (!subtleCrypto) {
-            throw new Error('Web Crypto is not available');
+            throw new Error("Web Crypto is not available");
         }
 
         const iv = new Uint8Array(32);
@@ -194,25 +188,25 @@ export class MSC3903ECDHv1RendezvousChannel<T> implements RendezvousChannel<T> {
 
     public async send(payload: T): Promise<void> {
         if (!this.olmSAS) {
-            throw new Error('Channel closed');
+            throw new Error("Channel closed");
         }
 
         if (!this.aesKey) {
-            throw new Error('Shared secret not set up');
+            throw new Error("Shared secret not set up");
         }
 
-        return this.transport.send((await this.encrypt(payload)));
+        return this.transport.send(await this.encrypt(payload));
     }
 
     private async decrypt({ iv, ciphertext }: EncryptedPayload): Promise<Partial<T>> {
         if (!ciphertext || !iv) {
-            throw new Error('Missing ciphertext and/or iv');
+            throw new Error("Missing ciphertext and/or iv");
         }
 
         const ciphertextBytes = decodeBase64(ciphertext);
 
         if (!subtleCrypto) {
-            throw new Error('Web Crypto is not available');
+            throw new Error("Web Crypto is not available");
         }
 
         const plaintext = await subtleCrypto.decrypt(
@@ -230,10 +224,10 @@ export class MSC3903ECDHv1RendezvousChannel<T> implements RendezvousChannel<T> {
 
     public async receive(): Promise<Partial<T> | undefined> {
         if (!this.olmSAS) {
-            throw new Error('Channel closed');
+            throw new Error("Channel closed");
         }
         if (!this.aesKey) {
-            throw new Error('Shared secret not set up');
+            throw new Error("Shared secret not set up");
         }
 
         const rawData = await this.transport.receive();
@@ -245,7 +239,7 @@ export class MSC3903ECDHv1RendezvousChannel<T> implements RendezvousChannel<T> {
             return this.decrypt(data as EncryptedPayload);
         }
 
-        throw new Error('Data received but no ciphertext');
+        throw new Error("Data received but no ciphertext");
     }
 
     public async close(): Promise<void> {
diff --git a/src/rendezvous/channels/index.ts b/src/rendezvous/channels/index.ts
index f1139c0629a..072a1014694 100644
--- a/src/rendezvous/channels/index.ts
+++ b/src/rendezvous/channels/index.ts
@@ -14,5 +14,4 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-export * from './MSC3903ECDHv1RendezvousChannel';
-
+export * from "./MSC3903ECDHv1RendezvousChannel";
diff --git a/src/rendezvous/index.ts b/src/rendezvous/index.ts
index 7e506b45052..379b13351b8 100644
--- a/src/rendezvous/index.ts
+++ b/src/rendezvous/index.ts
@@ -14,10 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-export * from './MSC3906Rendezvous';
-export * from './RendezvousChannel';
-export * from './RendezvousCode';
-export * from './RendezvousError';
-export * from './RendezvousFailureReason';
-export * from './RendezvousIntent';
-export * from './RendezvousTransport';
+export * from "./MSC3906Rendezvous";
+export * from "./RendezvousChannel";
+export * from "./RendezvousCode";
+export * from "./RendezvousError";
+export * from "./RendezvousFailureReason";
+export * from "./RendezvousIntent";
+export * from "./RendezvousTransport";
diff --git a/src/rendezvous/transports/MSC3886SimpleHttpRendezvousTransport.ts b/src/rendezvous/transports/MSC3886SimpleHttpRendezvousTransport.ts
index cffbefe5a26..430ee92d1c7 100644
--- a/src/rendezvous/transports/MSC3886SimpleHttpRendezvousTransport.ts
+++ b/src/rendezvous/transports/MSC3886SimpleHttpRendezvousTransport.ts
@@ -14,18 +14,18 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { UnstableValue } from 'matrix-events-sdk';
+import { UnstableValue } from "matrix-events-sdk";
 
-import { logger } from '../../logger';
-import { sleep } from '../../utils';
+import { logger } from "../../logger";
+import { sleep } from "../../utils";
 import {
     RendezvousFailureListener,
     RendezvousFailureReason,
     RendezvousTransport,
     RendezvousTransportDetails,
-} from '..';
-import { MatrixClient } from '../../matrix';
-import { ClientPrefix } from '../../http-api';
+} from "..";
+import { MatrixClient } from "../../matrix";
+import { ClientPrefix } from "../../http-api";
 
 const TYPE = new UnstableValue("http.v1", "org.matrix.msc3886.http.v1");
 
@@ -72,7 +72,7 @@ export class MSC3886SimpleHttpRendezvousTransport<T extends {}> implements Rende
 
     public async details(): Promise<MSC3886SimpleHttpRendezvousTransportDetails> {
         if (!this.uri) {
-            throw new Error('Rendezvous not set up');
+            throw new Error("Rendezvous not set up");
         }
 
         return {
@@ -90,11 +90,11 @@ export class MSC3886SimpleHttpRendezvousTransport<T extends {}> implements Rende
 
     private async getPostEndpoint(): Promise<string | undefined> {
         try {
-            if (await this.client.doesServerSupportUnstableFeature('org.matrix.msc3886')) {
+            if (await this.client.doesServerSupportUnstableFeature("org.matrix.msc3886")) {
                 return `${this.client.baseUrl}${ClientPrefix.Unstable}/org.matrix.msc3886/rendezvous`;
             }
         } catch (err) {
-            logger.warn('Failed to get unstable features', err);
+            logger.warn("Failed to get unstable features", err);
         }
 
         return this.fallbackRzServer;
@@ -105,32 +105,29 @@ export class MSC3886SimpleHttpRendezvousTransport<T extends {}> implements Rende
             return;
         }
         const method = this.uri ? "PUT" : "POST";
-        const uri = this.uri ?? await this.getPostEndpoint();
+        const uri = this.uri ?? (await this.getPostEndpoint());
 
         if (!uri) {
-            throw new Error('Invalid rendezvous URI');
+            throw new Error("Invalid rendezvous URI");
         }
 
-        const headers: Record<string, string> = { 'content-type': 'application/json' };
+        const headers: Record<string, string> = { "content-type": "application/json" };
         if (this.etag) {
-            headers['if-match'] = this.etag;
+            headers["if-match"] = this.etag;
         }
 
-        const res = await this.fetch(uri, { method,
-            headers,
-            body: JSON.stringify(data),
-        });
+        const res = await this.fetch(uri, { method, headers, body: JSON.stringify(data) });
         if (res.status === 404) {
             return this.cancel(RendezvousFailureReason.Unknown);
         }
         this.etag = res.headers.get("etag") ?? undefined;
 
-        if (method === 'POST') {
-            const location = res.headers.get('location');
+        if (method === "POST") {
+            const location = res.headers.get("location");
             if (!location) {
-                throw new Error('No rendezvous URI given');
+                throw new Error("No rendezvous URI given");
             }
-            const expires = res.headers.get('expires');
+            const expires = res.headers.get("expires");
             if (expires) {
                 this.expiresAt = new Date(expires);
             }
@@ -138,14 +135,14 @@ export class MSC3886SimpleHttpRendezvousTransport<T extends {}> implements Rende
             // however, if a polyfill based on XHR is used it won't be set, we we use existing URI as fallback
             const baseUrl = res.url ?? uri;
             // resolve location header which could be relative or absolute
-            this.uri = new URL(location, `${baseUrl}${baseUrl.endsWith('/') ? '' : '/'}`).href;
+            this.uri = new URL(location, `${baseUrl}${baseUrl.endsWith("/") ? "" : "/"}`).href;
             this._ready = true;
         }
     }
 
     public async receive(): Promise<Partial<T> | undefined> {
         if (!this.uri) {
-            throw new Error('Rendezvous not set up');
+            throw new Error("Rendezvous not set up");
         }
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -155,7 +152,7 @@ export class MSC3886SimpleHttpRendezvousTransport<T extends {}> implements Rende
 
             const headers: Record<string, string> = {};
             if (this.etag) {
-                headers['if-none-match'] = this.etag;
+                headers["if-none-match"] = this.etag;
             }
             const poll = await this.fetch(this.uri, { method: "GET", headers });
 
@@ -166,7 +163,7 @@ export class MSC3886SimpleHttpRendezvousTransport<T extends {}> implements Rende
 
             // rely on server expiring the channel rather than checking ourselves
 
-            if (poll.headers.get('content-type') !== 'application/json') {
+            if (poll.headers.get("content-type") !== "application/json") {
                 this.etag = poll.headers.get("etag") ?? undefined;
             } else if (poll.status === 200) {
                 this.etag = poll.headers.get("etag") ?? undefined;
@@ -177,8 +174,7 @@ export class MSC3886SimpleHttpRendezvousTransport<T extends {}> implements Rende
     }
 
     public async cancel(reason: RendezvousFailureReason): Promise<void> {
-        if (reason === RendezvousFailureReason.Unknown &&
-            this.expiresAt && this.expiresAt.getTime() < Date.now()) {
+        if (reason === RendezvousFailureReason.Unknown && this.expiresAt && this.expiresAt.getTime() < Date.now()) {
             reason = RendezvousFailureReason.Expired;
         }
 
diff --git a/src/rendezvous/transports/index.ts b/src/rendezvous/transports/index.ts
index 05594da4543..6d8d64245e4 100644
--- a/src/rendezvous/transports/index.ts
+++ b/src/rendezvous/transports/index.ts
@@ -14,4 +14,4 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-export * from './MSC3886SimpleHttpRendezvousTransport';
+export * from "./MSC3886SimpleHttpRendezvousTransport";
diff --git a/src/room-hierarchy.ts b/src/room-hierarchy.ts
index 3ed0205271a..5c0b61d743f 100644
--- a/src/room-hierarchy.ts
+++ b/src/room-hierarchy.ts
@@ -66,7 +66,7 @@ export class RoomHierarchy {
     }
 
     public async load(pageSize = this.pageSize): Promise<IHierarchyRoom[]> {
-        if (this.loadRequest) return this.loadRequest.then(r => r.rooms);
+        if (this.loadRequest) return this.loadRequest.then((r) => r.rooms);
 
         this.loadRequest = this.root.client.getRoomHierarchy(
             this.root.roomId,
@@ -97,10 +97,10 @@ export class RoomHierarchy {
             this._rooms = rooms;
         }
 
-        rooms.forEach(room => {
+        rooms.forEach((room) => {
             this.roomMap.set(room.room_id, room);
 
-            room.children_state.forEach(ev => {
+            room.children_state.forEach((ev) => {
                 if (ev.type !== EventType.SpaceChild) return;
                 const childRoomId = ev.state_key;
 
@@ -116,7 +116,7 @@ export class RoomHierarchy {
                         this.viaMap.set(childRoomId, new Set());
                     }
                     const vias = this.viaMap.get(childRoomId)!;
-                    ev.content.via.forEach(via => vias.add(via));
+                    ev.content.via.forEach((via) => vias.add(via));
                 }
             });
         });
@@ -125,7 +125,7 @@ export class RoomHierarchy {
     }
 
     public getRelation(parentId: string, childId: string): IHierarchyRelation | undefined {
-        return this.roomMap.get(parentId)?.children_state.find(e => e.state_key === childId);
+        return this.roomMap.get(parentId)?.children_state.find((e) => e.state_key === childId);
     }
 
     public isSuggested(parentId: string, childId: string): boolean | undefined {
@@ -138,12 +138,15 @@ export class RoomHierarchy {
         if (backRefs?.length === 1) {
             this.backRefs.delete(childId);
         } else if (backRefs?.length) {
-            this.backRefs.set(childId, backRefs.filter(ref => ref !== parentId));
+            this.backRefs.set(
+                childId,
+                backRefs.filter((ref) => ref !== parentId),
+            );
         }
 
         const room = this.roomMap.get(parentId);
         if (room) {
-            room.children_state = room.children_state.filter(ev => ev.state_key !== childId);
+            room.children_state = room.children_state.filter((ev) => ev.state_key !== childId);
         }
     }
 }
diff --git a/src/scheduler.ts b/src/scheduler.ts
index d6cfef362cf..16c06665eee 100644
--- a/src/scheduler.ts
+++ b/src/scheduler.ts
@@ -19,14 +19,14 @@ limitations under the License.
  * of requests.
  */
 import * as utils from "./utils";
-import { logger } from './logger';
+import { logger } from "./logger";
 import { MatrixEvent } from "./models/event";
 import { EventType } from "./@types/event";
 import { IDeferred } from "./utils";
 import { ConnectionError, MatrixError } from "./http-api";
 import { ISendEventResponse } from "./@types/requests";
 
-const DEBUG = false;  // set true to enable console logging.
+const DEBUG = false; // set true to enable console logging.
 
 interface IQueueEntry<T> {
     event: MatrixEvent;
@@ -75,7 +75,7 @@ export class MatrixScheduler<T = ISendEventResponse> {
         if (attempts > 4) {
             return -1; // give up
         }
-        return (1000 * Math.pow(2, attempts));
+        return 1000 * Math.pow(2, attempts);
     }
 
     /**
@@ -158,7 +158,7 @@ export class MatrixScheduler<T = ISendEventResponse> {
         if (!name || !this.queues[name]) {
             return null;
         }
-        return this.queues[name].map(function(obj) {
+        return this.queues[name].map(function (obj) {
             return obj.event;
         });
     }
@@ -230,8 +230,7 @@ export class MatrixScheduler<T = ISendEventResponse> {
         // for each inactive queue with events in them
         Object.keys(this.queues)
             .filter((queueName) => {
-                return this.activeQueues.indexOf(queueName) === -1 &&
-                    this.queues[queueName].length > 0;
+                return this.activeQueues.indexOf(queueName) === -1 && this.queues[queueName].length > 0;
             })
             .forEach((queueName) => {
                 // mark the queue as active
@@ -262,31 +261,43 @@ export class MatrixScheduler<T = ISendEventResponse> {
         // the deferred of the previously sent event can run.
         // This way enqueued relations/redactions to enqueued events can receive
         // the remove id of their target before being sent.
-        Promise.resolve().then(() => {
-            return this.procFn!(obj.event);
-        }).then((res) => {
-            // remove this from the queue
-            this.removeNextEvent(queueName);
-            debuglog("Queue '%s' sent event %s", queueName, obj.event.getId());
-            obj.defer.resolve(res);
-            // keep processing
-            this.processQueue(queueName);
-        }, (err) => {
-            obj.attempts += 1;
-            // ask the retry algorithm when/if we should try again
-            const waitTimeMs = this.retryAlgorithm(obj.event, obj.attempts, err);
-            debuglog("retry(%s) err=%s event_id=%s waitTime=%s", obj.attempts, err, obj.event.getId(), waitTimeMs);
-            if (waitTimeMs === -1) {  // give up (you quitter!)
-                debuglog("Queue '%s' giving up on event %s", queueName, obj.event.getId());
-                // remove this from the queue
-                this.removeNextEvent(queueName);
-                obj.defer.reject(err);
-                // process next event
-                this.processQueue(queueName);
-            } else {
-                setTimeout(this.processQueue, waitTimeMs, queueName);
-            }
-        });
+        Promise.resolve()
+            .then(() => {
+                return this.procFn!(obj.event);
+            })
+            .then(
+                (res) => {
+                    // remove this from the queue
+                    this.removeNextEvent(queueName);
+                    debuglog("Queue '%s' sent event %s", queueName, obj.event.getId());
+                    obj.defer.resolve(res);
+                    // keep processing
+                    this.processQueue(queueName);
+                },
+                (err) => {
+                    obj.attempts += 1;
+                    // ask the retry algorithm when/if we should try again
+                    const waitTimeMs = this.retryAlgorithm(obj.event, obj.attempts, err);
+                    debuglog(
+                        "retry(%s) err=%s event_id=%s waitTime=%s",
+                        obj.attempts,
+                        err,
+                        obj.event.getId(),
+                        waitTimeMs,
+                    );
+                    if (waitTimeMs === -1) {
+                        // give up (you quitter!)
+                        debuglog("Queue '%s' giving up on event %s", queueName, obj.event.getId());
+                        // remove this from the queue
+                        this.removeNextEvent(queueName);
+                        obj.defer.reject(err);
+                        // process next event
+                        this.processQueue(queueName);
+                    } else {
+                        setTimeout(this.processQueue, waitTimeMs, queueName);
+                    }
+                },
+            );
     };
 
     private peekNextEvent(queueName: string): IQueueEntry<T> | undefined {
diff --git a/src/service-types.ts b/src/service-types.ts
index 80eeed74e88..3ed08bb27b0 100644
--- a/src/service-types.ts
+++ b/src/service-types.ts
@@ -15,6 +15,6 @@ limitations under the License.
 */
 
 export enum SERVICE_TYPES {
-    IS = 'SERVICE_TYPE_IS', // An identity server
-    IM = 'SERVICE_TYPE_IM', // An integration manager
+    IS = "SERVICE_TYPE_IS", // An identity server
+    IM = "SERVICE_TYPE_IM", // An integration manager
 }
diff --git a/src/sliding-sync-sdk.ts b/src/sliding-sync-sdk.ts
index f9bddd87595..c6d5f98a518 100644
--- a/src/sliding-sync-sdk.ts
+++ b/src/sliding-sync-sdk.ts
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 import { NotificationCountType, Room, RoomEvent } from "./models/room";
-import { logger } from './logger';
+import { logger } from "./logger";
 import * as utils from "./utils";
 import { EventTimeline } from "./models/event-timeline";
 import { ClientEvent, IStoredClientOpts, MatrixClient, PendingEventOrdering } from "./client";
@@ -48,11 +48,12 @@ type ExtensionE2EERequest = {
     enabled: boolean;
 };
 
-type ExtensionE2EEResponse = Pick<ISyncResponse,
-    "device_lists" |
-    "device_one_time_keys_count" |
-    "device_unused_fallback_key_types" |
-    "org.matrix.msc2732.device_unused_fallback_key_types"
+type ExtensionE2EEResponse = Pick<
+    ISyncResponse,
+    | "device_lists"
+    | "device_one_time_keys_count"
+    | "device_unused_fallback_key_types"
+    | "org.matrix.msc2732.device_unused_fallback_key_types"
 >;
 
 class ExtensionE2EE implements Extension<ExtensionE2EERequest, ExtensionE2EEResponse> {
@@ -78,9 +79,12 @@ class ExtensionE2EE implements Extension<ExtensionE2EERequest, ExtensionE2EEResp
     public async onResponse(data: ExtensionE2EEResponse): Promise<void> {
         // Handle device list updates
         if (data["device_lists"]) {
-            await this.crypto.handleDeviceListChanges({
-                oldSyncToken: "yep", // XXX need to do this so the device list changes get processed :(
-            }, data["device_lists"]);
+            await this.crypto.handleDeviceListChanges(
+                {
+                    oldSyncToken: "yep", // XXX need to do this so the device list changes get processed :(
+                },
+                data["device_lists"],
+            );
         }
 
         // Handle one_time_keys_count
@@ -88,16 +92,14 @@ class ExtensionE2EE implements Extension<ExtensionE2EERequest, ExtensionE2EEResp
             const currentCount = data["device_one_time_keys_count"].signed_curve25519 || 0;
             this.crypto.updateOneTimeKeyCount(currentCount);
         }
-        if (data["device_unused_fallback_key_types"] ||
-                data["org.matrix.msc2732.device_unused_fallback_key_types"]) {
+        if (data["device_unused_fallback_key_types"] || data["org.matrix.msc2732.device_unused_fallback_key_types"]) {
             // The presence of device_unused_fallback_key_types indicates that the
             // server supports fallback keys. If there's no unused
             // signed_curve25519 fallback key we need a new one.
-            const unusedFallbackKeys = data["device_unused_fallback_key_types"] ||
-                data["org.matrix.msc2732.device_unused_fallback_key_types"];
+            const unusedFallbackKeys =
+                data["device_unused_fallback_key_types"] || data["org.matrix.msc2732.device_unused_fallback_key_types"];
             this.crypto.setNeedsNewFallback(
-                Array.isArray(unusedFallbackKeys) &&
-                !unusedFallbackKeys.includes("signed_curve25519"),
+                Array.isArray(unusedFallbackKeys) && !unusedFallbackKeys.includes("signed_curve25519"),
             );
         }
     }
@@ -142,14 +144,15 @@ class ExtensionToDevice implements Extension<ExtensionToDeviceRequest, Extension
         const cancelledKeyVerificationTxns: string[] = [];
         data.events
             ?.map(this.client.getEventMapper())
-            .map((toDeviceEvent) => { // map is a cheap inline forEach
+            .map((toDeviceEvent) => {
+                // map is a cheap inline forEach
                 // We want to flag m.key.verification.start events as cancelled
                 // if there's an accompanying m.key.verification.cancel event, so
                 // we pull out the transaction IDs from the cancellation events
                 // so we can flag the verification events as cancelled in the loop
                 // below.
                 if (toDeviceEvent.getType() === "m.key.verification.cancel") {
-                    const txnId: string | undefined = toDeviceEvent.getContent()['transaction_id'];
+                    const txnId: string | undefined = toDeviceEvent.getContent()["transaction_id"];
                     if (txnId) {
                         cancelledKeyVerificationTxns.push(txnId);
                     }
@@ -159,32 +162,26 @@ class ExtensionToDevice implements Extension<ExtensionToDeviceRequest, Extension
                 // the unmodified event.
                 return toDeviceEvent;
             })
-            .forEach(
-                (toDeviceEvent) => {
-                    const content = toDeviceEvent.getContent();
-                    if (
-                        toDeviceEvent.getType() == "m.room.message" &&
-                        content.msgtype == "m.bad.encrypted"
-                    ) {
-                        // the mapper already logged a warning.
-                        logger.log(
-                            'Ignoring undecryptable to-device event from ' +
-                            toDeviceEvent.getSender(),
-                        );
-                        return;
-                    }
+            .forEach((toDeviceEvent) => {
+                const content = toDeviceEvent.getContent();
+                if (toDeviceEvent.getType() == "m.room.message" && content.msgtype == "m.bad.encrypted") {
+                    // the mapper already logged a warning.
+                    logger.log("Ignoring undecryptable to-device event from " + toDeviceEvent.getSender());
+                    return;
+                }
 
-                    if (toDeviceEvent.getType() === "m.key.verification.start"
-                        || toDeviceEvent.getType() === "m.key.verification.request") {
-                        const txnId = content['transaction_id'];
-                        if (cancelledKeyVerificationTxns.includes(txnId)) {
-                            toDeviceEvent.flagCancelled();
-                        }
+                if (
+                    toDeviceEvent.getType() === "m.key.verification.start" ||
+                    toDeviceEvent.getType() === "m.key.verification.request"
+                ) {
+                    const txnId = content["transaction_id"];
+                    if (cancelledKeyVerificationTxns.includes(txnId)) {
+                        toDeviceEvent.flagCancelled();
                     }
+                }
 
-                    this.client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);
-                },
-            );
+                this.client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);
+            });
 
         this.nextBatch = data.next_batch;
     }
@@ -245,21 +242,19 @@ class ExtensionAccountData implements Extension<ExtensionAccountDataRequest, Ext
             return m;
         }, {});
         this.client.store.storeAccountDataEvents(events);
-        events.forEach(
-            (accountDataEvent) => {
-                // Honour push rules that come down the sync stream but also
-                // honour push rules that were previously cached. Base rules
-                // will be updated when we receive push rules via getPushRules
-                // (see sync) before syncing over the network.
-                if (accountDataEvent.getType() === EventType.PushRules) {
-                    const rules = accountDataEvent.getContent<IPushRules>();
-                    this.client.pushRules = PushProcessor.rewriteDefaultRules(rules);
-                }
-                const prevEvent = prevEventsMap[accountDataEvent.getType()];
-                this.client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);
-                return accountDataEvent;
-            },
-        );
+        events.forEach((accountDataEvent) => {
+            // Honour push rules that come down the sync stream but also
+            // honour push rules that were previously cached. Base rules
+            // will be updated when we receive push rules via getPushRules
+            // (see sync) before syncing over the network.
+            if (accountDataEvent.getType() === EventType.PushRules) {
+                const rules = accountDataEvent.getContent<IPushRules>();
+                this.client.pushRules = PushProcessor.rewriteDefaultRules(rules);
+            }
+            const prevEvent = prevEventsMap[accountDataEvent.getType()];
+            this.client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);
+            return accountDataEvent;
+        });
     }
 }
 
@@ -336,9 +331,7 @@ class ExtensionReceipts implements Extension<ExtensionReceiptsRequest, Extension
         }
 
         for (const roomId in data.rooms) {
-            processEphemeralEvents(
-                this.client, roomId, [data.rooms[roomId]],
-            );
+            processEphemeralEvents(this.client, roomId, [data.rooms[roomId]]);
         }
     }
 }
@@ -361,7 +354,7 @@ export class SlidingSyncSdk {
     ) {
         this.opts.initialSyncLimit = this.opts.initialSyncLimit ?? 8;
         this.opts.resolveInvitesToProfiles = this.opts.resolveInvitesToProfiles || false;
-        this.opts.pollTimeout = this.opts.pollTimeout || (30 * 1000);
+        this.opts.pollTimeout = this.opts.pollTimeout || 30 * 1000;
         this.opts.pendingEventOrdering = this.opts.pendingEventOrdering || PendingEventOrdering.Chronological;
         this.opts.experimentalThreadSupport = this.opts.experimentalThreadSupport === true;
 
@@ -372,10 +365,7 @@ export class SlidingSyncSdk {
         }
 
         if (client.getNotifTimelineSet()) {
-            client.reEmitter.reEmit(client.getNotifTimelineSet()!, [
-                RoomEvent.Timeline,
-                RoomEvent.TimelineReset,
-            ]);
+            client.reEmitter.reEmit(client.getNotifTimelineSet()!, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
         }
 
         this.slidingSync.on(SlidingSyncEvent.Lifecycle, this.onLifecycle.bind(this));
@@ -387,9 +377,7 @@ export class SlidingSyncSdk {
             new ExtensionReceipts(this.client),
         ];
         if (this.opts.crypto) {
-            extensions.push(
-                new ExtensionE2EE(this.opts.crypto),
-            );
+            extensions.push(new ExtensionE2EE(this.opts.crypto));
         }
         extensions.forEach((ext) => {
             this.slidingSync.registerExtension(ext);
@@ -504,7 +492,8 @@ export class SlidingSyncSdk {
 
     // Helper functions which set up JS SDK structs are below and are identical to the sync v2 counterparts
 
-    public createRoom(roomId: string): Room { // XXX cargoculted from sync.ts
+    public createRoom(roomId: string): Room {
+        // XXX cargoculted from sync.ts
         const { timelineSupport } = this.client;
         const room = new Room(roomId, this.client, this.client.getUserId()!, {
             lazyLoadMembers: this.opts.lazyLoadMembers,
@@ -527,7 +516,8 @@ export class SlidingSyncSdk {
         return room;
     }
 
-    private registerStateListeners(room: Room): void { // XXX cargoculted from sync.ts
+    private registerStateListeners(room: Room): void {
+        // XXX cargoculted from sync.ts
         // we need to also re-emit room state and room member events, so hook it up
         // to the client now. We need to add a listener for RoomState.members in
         // order to hook them correctly.
@@ -584,9 +574,11 @@ export class SlidingSyncSdk {
             // If we do, then we've effectively done scrollback (e.g requesting timeline_limit: 1 for
             // this room, then timeline_limit: 50).
             const knownEvents = new Set<string>();
-            room.getLiveTimeline().getEvents().forEach((e) => {
-                knownEvents.add(e.getId()!);
-            });
+            room.getLiveTimeline()
+                .getEvents()
+                .forEach((e) => {
+                    knownEvents.add(e.getId()!);
+                });
             // all unknown events BEFORE a known event must be scrollback e.g:
             //       D E   <-- what we know
             // A B C D E F <-- what we just received
@@ -598,7 +590,7 @@ export class SlidingSyncSdk {
             const oldEvents: MatrixEvent[] = [];
             const newEvents: MatrixEvent[] = [];
             let seenKnownEvent = false;
-            for (let i = timelineEvents.length-1; i >= 0; i--) {
+            for (let i = timelineEvents.length - 1; i >= 0; i--) {
                 const recvEvent = timelineEvents[i];
                 if (knownEvents.has(recvEvent.getId()!)) {
                     seenKnownEvent = true;
@@ -622,10 +614,7 @@ export class SlidingSyncSdk {
         const encrypted = this.client.isRoomEncrypted(room.roomId);
         // we do this first so it's correct when any of the events fire
         if (roomData.notification_count != null) {
-            room.setUnreadNotificationCount(
-                NotificationCountType.Total,
-                roomData.notification_count,
-            );
+            room.setUnreadNotificationCount(NotificationCountType.Total, roomData.notification_count);
         }
 
         if (roomData.highlight_count != null) {
@@ -633,12 +622,8 @@ export class SlidingSyncSdk {
             // bother setting it here. We trust our calculations better than the
             // server's for this case, and therefore will assume that our non-zero
             // count is accurate.
-            if (!encrypted
-                || (encrypted && room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0)) {
-                room.setUnreadNotificationCount(
-                    NotificationCountType.Highlight,
-                    roomData.highlight_count,
-                );
+            if (!encrypted || (encrypted && room.getUnreadNotificationCount(NotificationCountType.Highlight) <= 0)) {
+                room.setUnreadNotificationCount(NotificationCountType.Highlight, roomData.highlight_count);
             }
         }
 
@@ -751,7 +736,7 @@ export class SlidingSyncSdk {
 
         await utils.promiseMapSeries(stateEvents, processRoomEvent);
         await utils.promiseMapSeries(timelineEvents, processRoomEvent);
-        ephemeralEvents.forEach(function(e) {
+        ephemeralEvents.forEach(function (e) {
             client.emit(ClientEvent.Event, e);
         });
 
@@ -856,7 +841,7 @@ export class SlidingSyncSdk {
         const client = this.client;
         // For each invited room member we want to give them a displayname/avatar url
         // if they have one (the m.room.member invites don't contain this).
-        room.getMembersWithMembership("invite").forEach(function(member) {
+        room.getMembersWithMembership("invite").forEach(function (member) {
             if (member.requestedProfileInfo) return;
             member.requestedProfileInfo = true;
             // try to get a cached copy first.
@@ -870,22 +855,25 @@ export class SlidingSyncSdk {
             } else {
                 promise = client.getProfileInfo(member.userId);
             }
-            promise.then(function(info) {
-                // slightly naughty by doctoring the invite event but this means all
-                // the code paths remain the same between invite/join display name stuff
-                // which is a worthy trade-off for some minor pollution.
-                const inviteEvent = member.events.member!;
-                if (inviteEvent.getContent().membership !== "invite") {
-                    // between resolving and now they have since joined, so don't clobber
-                    return;
-                }
-                inviteEvent.getContent().avatar_url = info.avatar_url;
-                inviteEvent.getContent().displayname = info.displayname;
-                // fire listeners
-                member.setMembershipEvent(inviteEvent, room.currentState);
-            }, function(_err) {
-                // OH WELL.
-            });
+            promise.then(
+                function (info) {
+                    // slightly naughty by doctoring the invite event but this means all
+                    // the code paths remain the same between invite/join display name stuff
+                    // which is a worthy trade-off for some minor pollution.
+                    const inviteEvent = member.events.member!;
+                    if (inviteEvent.getContent().membership !== "invite") {
+                        // between resolving and now they have since joined, so don't clobber
+                        return;
+                    }
+                    inviteEvent.getContent().avatar_url = info.avatar_url;
+                    inviteEvent.getContent().displayname = info.displayname;
+                    // fire listeners
+                    member.setMembershipEvent(inviteEvent, room.currentState);
+                },
+                function (_err) {
+                    // OH WELL.
+                },
+            );
         });
     }
 
@@ -955,8 +943,7 @@ export class SlidingSyncSdk {
         }
         for (const timelineEvent of timelineEventList) {
             const pushActions = this.client.getPushActionsForEvent(timelineEvent);
-            if (pushActions && pushActions.notify &&
-                pushActions.tweaks && pushActions.tweaks.highlight) {
+            if (pushActions && pushActions.notify && pushActions.tweaks && pushActions.tweaks.highlight) {
                 this.notifEvents.push(timelineEvent);
             }
         }
@@ -970,7 +957,7 @@ export class SlidingSyncSdk {
      * room B appearing earlier in the notifications timeline, even though it has the higher origin_server_ts.
      */
     private purgeNotifications(): void {
-        this.notifEvents.sort(function(a, b) {
+        this.notifEvents.sort(function (a, b) {
             return a.getTs() - b.getTs();
         });
         this.notifEvents.forEach((event) => {
@@ -1014,7 +1001,7 @@ type TaggedEvent = (IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent) &
 // just outside the class.
 function mapEvents(client: MatrixClient, roomId: string | undefined, events: object[], decrypt = true): MatrixEvent[] {
     const mapper = client.getEventMapper({ decrypt });
-    return (events as TaggedEvent[]).map(function(e) {
+    return (events as TaggedEvent[]).map(function (e) {
         e.room_id = roomId;
         return mapper(e);
     });
diff --git a/src/sliding-sync.ts b/src/sliding-sync.ts
index 81a67f05e15..b219dad1159 100644
--- a/src/sliding-sync.ts
+++ b/src/sliding-sync.ts
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { logger } from './logger';
+import { logger } from "./logger";
 import { MatrixClient } from "./client";
 import { IRoomEvent, IStateEvent } from "./sync-accumulator";
 import { TypedEventEmitter } from "./models/typed-event-emitter";
@@ -328,10 +328,14 @@ export enum SlidingSyncEvent {
 export type SlidingSyncEventHandlerMap = {
     [SlidingSyncEvent.RoomData]: (roomId: string, roomData: MSC3575RoomData) => void;
     [SlidingSyncEvent.Lifecycle]: (
-        state: SlidingSyncState, resp: MSC3575SlidingSyncResponse | null, err?: Error,
+        state: SlidingSyncState,
+        resp: MSC3575SlidingSyncResponse | null,
+        err?: Error,
     ) => void;
     [SlidingSyncEvent.List]: (
-        listIndex: number, joinedCount: number, roomIndexToRoomId: Record<number, string>,
+        listIndex: number,
+        joinedCount: number,
+        roomIndexToRoomId: Record<number, string>,
     ) => void;
 };
 
@@ -351,7 +355,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     private txnId: string | null = null;
     // a list (in chronological order of when they were sent) of objects containing the txn ID and
     // a defer to resolve/reject depending on whether they were successfully sent or not.
-    private txnIdDefers: (IDeferred<string> & { txnId: string})[] = [];
+    private txnIdDefers: (IDeferred<string> & { txnId: string })[] = [];
     // map of extension name to req/resp handler
     private extensions: Record<string, Extension<any, any>> = {};
 
@@ -422,7 +426,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
      * @param index - The list index
      * @returns The list data which contains the rooms in this list
      */
-    public getListData(index: number): {joinedCount: number, roomIndexToRoomId: Record<number, string>} | null {
+    public getListData(index: number): { joinedCount: number; roomIndexToRoomId: Record<number, string> } | null {
         if (!this.lists[index]) {
             return null;
         }
@@ -556,8 +560,12 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
      * @param roomData - The raw sliding sync response JSON.
      */
     private invokeRoomDataListeners(roomId: string, roomData: MSC3575RoomData): void {
-        if (!roomData.required_state) { roomData.required_state = []; }
-        if (!roomData.timeline) { roomData.timeline = []; }
+        if (!roomData.required_state) {
+            roomData.required_state = [];
+        }
+        if (!roomData.timeline) {
+            roomData.timeline = [];
+        }
         this.emit(SlidingSyncEvent.RoomData, roomId, roomData);
     }
 
@@ -581,10 +589,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
         // 0,1,2,2,3 <- after, hi is deleted and low is duplicated
         for (let i = hi; i > low; i--) {
             if (this.lists[listIndex].isIndexInRange(i)) {
-                this.lists[listIndex].roomIndexToRoomId[i] =
-                    this.lists[listIndex].roomIndexToRoomId[
-                        i - 1
-                    ];
+                this.lists[listIndex].roomIndexToRoomId[i] = this.lists[listIndex].roomIndexToRoomId[i - 1];
             }
         }
     }
@@ -595,10 +600,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
         // 0,1,3,4,4 <- after, low is deleted and hi is duplicated
         for (let i = low; i < hi; i++) {
             if (this.lists[listIndex].isIndexInRange(i)) {
-                this.lists[listIndex].roomIndexToRoomId[i] =
-                    this.lists[listIndex].roomIndexToRoomId[
-                        i + 1
-                    ];
+                this.lists[listIndex].roomIndexToRoomId[i] = this.lists[listIndex].roomIndexToRoomId[i + 1];
             }
         }
     }
@@ -631,7 +633,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
             return;
         }
         // Everything higher than the gap needs to be shifted right, +1 so we don't delete the highest element
-        this.shiftRight(listIndex, max+1, index);
+        this.shiftRight(listIndex, max + 1, index);
     }
 
     private processListOps(list: ListResponse, listIndex: number): void {
@@ -649,13 +651,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
                     break;
                 }
                 case "INSERT": {
-                    logger.debug(
-                        "INSERT",
-                        listIndex,
-                        op.index,
-                        op.room_id,
-                        ";",
-                    );
+                    logger.debug("INSERT", listIndex, op.index, op.room_id, ";");
                     if (this.lists[listIndex].roomIndexToRoomId[op.index]) {
                         // something is in this space, shift items out of the way
                         if (gapIndex < 0) {
@@ -689,13 +685,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
                     for (let i = startIndex; i <= op.range[1]; i++) {
                         delete this.lists[listIndex].roomIndexToRoomId[i];
                     }
-                    logger.debug(
-                        "INVALIDATE",
-                        listIndex,
-                        op.range[0],
-                        op.range[1],
-                        ";",
-                    );
+                    logger.debug("INVALIDATE", listIndex, op.range[0], op.range[1], ";");
                     break;
                 }
                 case "SYNC": {
@@ -707,14 +697,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
                         }
                         this.lists[listIndex].roomIndexToRoomId[i] = roomId;
                     }
-                    logger.debug(
-                        "SYNC",
-                        listIndex,
-                        op.range[0],
-                        op.range[1],
-                        (op.room_ids || []).join(" "),
-                        ";",
-                    );
+                    logger.debug("SYNC", listIndex, op.range[0], op.range[1], (op.room_ids || []).join(" "), ";");
                     break;
                 }
             }
@@ -734,7 +717,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
     public resend(): Promise<string> {
         if (this.needsResend && this.txnIdDefers.length > 0) {
             // we already have a resend queued, so just return the same promise
-            return this.txnIdDefers[this.txnIdDefers.length-1].promise;
+            return this.txnIdDefers[this.txnIdDefers.length - 1].promise;
         }
         this.needsResend = true;
         this.txnId = this.client.makeTxnId();
@@ -773,7 +756,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
         }
         this.txnIdDefers[txnIndex].resolve(txnId);
         // clear out settled promises, including the one we resolved.
-        this.txnIdDefers = this.txnIdDefers.slice(txnIndex+1);
+        this.txnIdDefers = this.txnIdDefers.slice(txnIndex + 1);
     }
 
     /**
@@ -880,17 +863,10 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
                 resp.lists.forEach((val, i) => {
                     this.lists[i].joinedCount = val.count;
                 });
-                this.invokeLifecycleListeners(
-                    SlidingSyncState.RequestFinished,
-                    resp,
-                );
+                this.invokeLifecycleListeners(SlidingSyncState.RequestFinished, resp);
             } catch (err) {
                 if ((<HTTPError>err).httpStatus) {
-                    this.invokeLifecycleListeners(
-                        SlidingSyncState.RequestFinished,
-                        null,
-                        <Error>err,
-                    );
+                    this.invokeLifecycleListeners(SlidingSyncState.RequestFinished, null, <Error>err);
                     if ((<HTTPError>err).httpStatus === 400) {
                         // session probably expired TODO: assign an errcode
                         // so drop state and re-request
@@ -911,10 +887,7 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
             this.onPreExtensionsResponse(resp.extensions);
 
             Object.keys(resp.rooms).forEach((roomId) => {
-                this.invokeRoomDataListeners(
-                    roomId,
-                    resp!.rooms[roomId],
-                );
+                this.invokeRoomDataListeners(roomId, resp!.rooms[roomId]);
             });
 
             const listIndexesWithUpdates: Set<number> = new Set();
@@ -932,7 +905,9 @@ export class SlidingSync extends TypedEventEmitter<SlidingSyncEvent, SlidingSync
             listIndexesWithUpdates.forEach((i) => {
                 this.emit(
                     SlidingSyncEvent.List,
-                    i, this.lists[i].joinedCount, Object.assign({}, this.lists[i].roomIndexToRoomId),
+                    i,
+                    this.lists[i].joinedCount,
+                    Object.assign({}, this.lists[i].roomIndexToRoomId),
                 );
             });
 
diff --git a/src/store/index.ts b/src/store/index.ts
index faf844f22d7..84f613cf4dd 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -233,15 +233,15 @@ export interface IStore {
     /**
      * Stores batches of outgoing to-device messages
      */
-     saveToDeviceBatches(batch: ToDeviceBatchWithTxnId[]): Promise<void>;
+    saveToDeviceBatches(batch: ToDeviceBatchWithTxnId[]): Promise<void>;
 
-     /**
-      * Fetches the oldest batch of to-device messages in the queue
-      */
-     getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null>;
+    /**
+     * Fetches the oldest batch of to-device messages in the queue
+     */
+    getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null>;
 
-     /**
-      * Removes a specific batch of to-device messages from the queue
-      */
-     removeToDeviceBatch(id: number): Promise<void>;
+    /**
+     * Removes a specific batch of to-device messages from the queue
+     */
+    removeToDeviceBatch(id: number): Promise<void>;
 }
diff --git a/src/store/indexeddb-local-backend.ts b/src/store/indexeddb-local-backend.ts
index fe61f11df37..7e84ad621a5 100644
--- a/src/store/indexeddb-local-backend.ts
+++ b/src/store/indexeddb-local-backend.ts
@@ -17,7 +17,7 @@ limitations under the License.
 import { IMinimalEvent, ISyncData, ISyncResponse, SyncAccumulator } from "../sync-accumulator";
 import * as utils from "../utils";
 import * as IndexedDBHelpers from "../indexeddb-helpers";
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { IStateEventWithRoomId, IStoredClientOpts } from "../matrix";
 import { ISavedSync } from "./index";
 import { IIndexedDBBackend, UserTuple } from "./indexeddb-backend";
@@ -37,14 +37,17 @@ const DB_MIGRATIONS: DbMigration[] = [
         db.createObjectStore("sync", { keyPath: ["clobber"] });
     },
     (db): void => {
-        const oobMembersStore = db.createObjectStore(
-            "oob_membership_events", {
-                keyPath: ["room_id", "state_key"],
-            });
+        const oobMembersStore = db.createObjectStore("oob_membership_events", {
+            keyPath: ["room_id", "state_key"],
+        });
         oobMembersStore.createIndex("room", "room_id");
     },
-    (db): void => { db.createObjectStore("client_options", { keyPath: ["clobber"] }); },
-    (db): void => { db.createObjectStore("to_device_queue", { autoIncrement: true }); },
+    (db): void => {
+        db.createObjectStore("client_options", { keyPath: ["clobber"] });
+    },
+    (db): void => {
+        db.createObjectStore("to_device_queue", { autoIncrement: true });
+    },
     // Expand as needed.
 ];
 const VERSION = DB_MIGRATIONS.length;
@@ -85,10 +88,10 @@ function selectQuery<T>(
 
 function txnAsPromise(txn: IDBTransaction): Promise<Event> {
     return new Promise((resolve, reject) => {
-        txn.oncomplete = function(event): void {
+        txn.oncomplete = function (event): void {
             resolve(event);
         };
-        txn.onerror = function(): void {
+        txn.onerror = function (): void {
             reject(txn.error);
         };
     });
@@ -96,10 +99,10 @@ function txnAsPromise(txn: IDBTransaction): Promise<Event> {
 
 function reqAsEventPromise(req: IDBRequest): Promise<Event> {
     return new Promise((resolve, reject) => {
-        req.onsuccess = function(event): void {
+        req.onsuccess = function (event): void {
             resolve(event);
         };
-        req.onerror = function(): void {
+        req.onerror = function (): void {
             reject(req.error);
         };
     });
@@ -163,9 +166,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
         req.onupgradeneeded = (ev): void => {
             const db = req.result;
             const oldVersion = ev.oldVersion;
-            logger.log(
-                `LocalIndexedDBStoreBackend.connect: upgrading from ${oldVersion}`,
-            );
+            logger.log(`LocalIndexedDBStoreBackend.connect: upgrading from ${oldVersion}`);
             if (oldVersion < 1) {
                 // The database did not previously exist
                 this._isNewlyCreated = true;
@@ -204,18 +205,18 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns Promise which resolves on success
      */
     private init(): Promise<unknown> {
-        return Promise.all([
-            this.loadAccountData(),
-            this.loadSyncData(),
-        ]).then(([accountData, syncData]) => {
+        return Promise.all([this.loadAccountData(), this.loadSyncData()]).then(([accountData, syncData]) => {
             logger.log(`LocalIndexedDBStoreBackend: loaded initial data`);
-            this.syncAccumulator.accumulate({
-                next_batch: syncData.nextBatch,
-                rooms: syncData.roomsData,
-                account_data: {
-                    events: accountData,
+            this.syncAccumulator.accumulate(
+                {
+                    next_batch: syncData.nextBatch,
+                    rooms: syncData.roomsData,
+                    account_data: {
+                        events: accountData,
+                    },
                 },
-            }, true);
+                true,
+            );
         });
     }
 
@@ -274,8 +275,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * @param membershipEvents - the membership events to store
      */
     public async setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
-        logger.log(`LL: backend about to store ${membershipEvents.length}` +
-            ` members for ${roomId}`);
+        logger.log(`LL: backend about to store ${membershipEvents.length}` + ` members for ${roomId}`);
         const tx = this.db!.transaction(["oob_membership_events"], "readwrite");
         const store = tx.objectStore("oob_membership_events");
         membershipEvents.forEach((e) => {
@@ -303,33 +303,28 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
         // keys in the store.
         // this should be way faster than deleting every member
         // individually for a large room.
-        const readTx = this.db!.transaction(
-            ["oob_membership_events"],
-            "readonly");
+        const readTx = this.db!.transaction(["oob_membership_events"], "readonly");
         const store = readTx.objectStore("oob_membership_events");
         const roomIndex = store.index("room");
         const roomRange = IDBKeyRange.only(roomId);
 
-        const minStateKeyProm = reqAsCursorPromise(
-            roomIndex.openKeyCursor(roomRange, "next"),
-        ).then((cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1]);
-        const maxStateKeyProm = reqAsCursorPromise(
-            roomIndex.openKeyCursor(roomRange, "prev"),
-        ).then((cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1]);
-        const [minStateKey, maxStateKey] = await Promise.all(
-            [minStateKeyProm, maxStateKeyProm]);
-
-        const writeTx = this.db!.transaction(
-            ["oob_membership_events"],
-            "readwrite");
+        const minStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "next")).then(
+            (cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1],
+        );
+        const maxStateKeyProm = reqAsCursorPromise(roomIndex.openKeyCursor(roomRange, "prev")).then(
+            (cursor) => (<IDBValidKey[]>cursor?.primaryKey)[1],
+        );
+        const [minStateKey, maxStateKey] = await Promise.all([minStateKeyProm, maxStateKeyProm]);
+
+        const writeTx = this.db!.transaction(["oob_membership_events"], "readwrite");
         const writeStore = writeTx.objectStore("oob_membership_events");
-        const membersKeyRange = IDBKeyRange.bound(
+        const membersKeyRange = IDBKeyRange.bound([roomId, minStateKey], [roomId, maxStateKey]);
+
+        logger.log(
+            `LL: Deleting all users + marker in storage for room ${roomId}, with key range:`,
             [roomId, minStateKey],
             [roomId, maxStateKey],
         );
-
-        logger.log(`LL: Deleting all users + marker in storage for room ${roomId}, with key range:`,
-            [roomId, minStateKey], [roomId, maxStateKey]);
         await reqAsPromise(writeStore.delete(membersKeyRange));
     }
 
@@ -422,10 +417,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * @param roomsData - The 'rooms' /sync data from a SyncAccumulator
      * @returns Promise which resolves if the data was persisted.
      */
-    private persistSyncData(
-        nextBatch: string,
-        roomsData: ISyncResponse["rooms"],
-    ): Promise<void> {
+    private persistSyncData(nextBatch: string, roomsData: ISyncResponse["rooms"]): Promise<void> {
         logger.log("Persisting sync data up to", nextBatch);
         return utils.promiseTry<void>(() => {
             const txn = this.db!.transaction(["sync"], "readwrite");
@@ -530,7 +522,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
                 if (results.length > 1) {
                     logger.warn("loadSyncData: More than 1 sync row found.");
                 }
-                return results.length > 0 ? results[0] : {} as ISyncData;
+                return results.length > 0 ? results[0] : ({} as ISyncData);
             });
         });
     }
diff --git a/src/store/indexeddb-remote-backend.ts b/src/store/indexeddb-remote-backend.ts
index 05909b0e3f5..7406d3a6198 100644
--- a/src/store/indexeddb-remote-backend.ts
+++ b/src/store/indexeddb-remote-backend.ts
@@ -41,10 +41,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @param dbName - Optional database name. The same name must be used
      * to open the same database.
      */
-    public constructor(
-        private readonly workerFactory: () => Worker,
-        private readonly dbName?: string,
-    ) {}
+    public constructor(private readonly workerFactory: () => Worker, private readonly dbName?: string) {}
 
     /**
      * Attempt to connect to the database. This can fail if the user does not
@@ -52,7 +49,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns Promise which resolves if successfully connected.
      */
     public connect(): Promise<void> {
-        return this.ensureStarted().then(() => this.doCmd('connect'));
+        return this.ensureStarted().then(() => this.doCmd("connect"));
     }
 
     /**
@@ -61,12 +58,12 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns Resolved when the database is cleared.
      */
     public clearDatabase(): Promise<void> {
-        return this.ensureStarted().then(() => this.doCmd('clearDatabase'));
+        return this.ensureStarted().then(() => this.doCmd("clearDatabase"));
     }
 
     /** @returns whether or not the database was newly created in this session. */
     public isNewlyCreated(): Promise<boolean> {
-        return this.doCmd('isNewlyCreated');
+        return this.doCmd("isNewlyCreated");
     }
 
     /**
@@ -75,19 +72,19 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * is no saved sync data.
      */
     public getSavedSync(): Promise<ISavedSync> {
-        return this.doCmd('getSavedSync');
+        return this.doCmd("getSavedSync");
     }
 
     public getNextBatchToken(): Promise<string> {
-        return this.doCmd('getNextBatchToken');
+        return this.doCmd("getNextBatchToken");
     }
 
     public setSyncData(syncData: ISyncResponse): Promise<void> {
-        return this.doCmd('setSyncData', [syncData]);
+        return this.doCmd("setSyncData", [syncData]);
     }
 
     public syncToDatabase(userTuples: UserTuple[]): Promise<void> {
-        return this.doCmd('syncToDatabase', [userTuples]);
+        return this.doCmd("syncToDatabase", [userTuples]);
     }
 
     /**
@@ -97,7 +94,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns in case the members for this room haven't been stored yet
      */
     public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
-        return this.doCmd('getOutOfBandMembers', [roomId]);
+        return this.doCmd("getOutOfBandMembers", [roomId]);
     }
 
     /**
@@ -108,19 +105,19 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns when all members have been stored
      */
     public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
-        return this.doCmd('setOutOfBandMembers', [roomId, membershipEvents]);
+        return this.doCmd("setOutOfBandMembers", [roomId, membershipEvents]);
     }
 
     public clearOutOfBandMembers(roomId: string): Promise<void> {
-        return this.doCmd('clearOutOfBandMembers', [roomId]);
+        return this.doCmd("clearOutOfBandMembers", [roomId]);
     }
 
     public getClientOptions(): Promise<IStoredClientOpts | undefined> {
-        return this.doCmd('getClientOptions');
+        return this.doCmd("getClientOptions");
     }
 
     public storeClientOptions(options: IStoredClientOpts): Promise<void> {
-        return this.doCmd('storeClientOptions', [options]);
+        return this.doCmd("storeClientOptions", [options]);
     }
 
     /**
@@ -128,19 +125,19 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns A list of presence events in their raw form.
      */
     public getUserPresenceEvents(): Promise<UserTuple[]> {
-        return this.doCmd('getUserPresenceEvents');
+        return this.doCmd("getUserPresenceEvents");
     }
 
     public async saveToDeviceBatches(batches: ToDeviceBatchWithTxnId[]): Promise<void> {
-        return this.doCmd('saveToDeviceBatches', [batches]);
+        return this.doCmd("saveToDeviceBatches", [batches]);
     }
 
     public async getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null> {
-        return this.doCmd('getOldestToDeviceBatch');
+        return this.doCmd("getOldestToDeviceBatch");
     }
 
     public async removeToDeviceBatch(id: number): Promise<void> {
-        return this.doCmd('removeToDeviceBatch', [id]);
+        return this.doCmd("removeToDeviceBatch", [id]);
     }
 
     private ensureStarted(): Promise<void> {
@@ -149,7 +146,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
             this.worker.onmessage = this.onWorkerMessage;
 
             // tell the worker the db name.
-            this.startPromise = this.doCmd('setupWorker', [this.dbName]).then(() => {
+            this.startPromise = this.doCmd("setupWorker", [this.dbName]).then(() => {
                 logger.log("IndexedDB worker is ready");
             });
         }
@@ -174,7 +171,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     private onWorkerMessage = (ev: MessageEvent): void => {
         const msg = ev.data;
 
-        if (msg.command == 'cmd_success' || msg.command == 'cmd_fail') {
+        if (msg.command == "cmd_success" || msg.command == "cmd_fail") {
             if (msg.seq === undefined) {
                 logger.error("Got reply from worker with no seq");
                 return;
@@ -187,7 +184,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
             }
             delete this.inFlight[msg.seq];
 
-            if (msg.command == 'cmd_success') {
+            if (msg.command == "cmd_success") {
                 def.resolve(msg.result);
             } else {
                 const error = new Error(msg.error.message);
@@ -199,4 +196,3 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
         }
     };
 }
-
diff --git a/src/store/indexeddb-store-worker.ts b/src/store/indexeddb-store-worker.ts
index a9bc2abcd07..df508ffa7ba 100644
--- a/src/store/indexeddb-store-worker.ts
+++ b/src/store/indexeddb-store-worker.ts
@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 import { LocalIndexedDBStoreBackend } from "./indexeddb-local-backend";
-import { logger } from '../logger';
+import { logger } from "../logger";
 
 interface ICmd {
     command: string;
@@ -60,65 +60,65 @@ export class IndexedDBStoreWorker {
         let prom;
 
         switch (msg.command) {
-            case 'setupWorker':
+            case "setupWorker":
                 // this is the 'indexedDB' global (where global != window
                 // because it's a web worker and there is no window).
                 this.backend = new LocalIndexedDBStoreBackend(indexedDB, msg.args[0]);
                 prom = Promise.resolve();
                 break;
-            case 'connect':
+            case "connect":
                 prom = this.backend?.connect();
                 break;
-            case 'isNewlyCreated':
+            case "isNewlyCreated":
                 prom = this.backend?.isNewlyCreated();
                 break;
-            case 'clearDatabase':
+            case "clearDatabase":
                 prom = this.backend?.clearDatabase();
                 break;
-            case 'getSavedSync':
+            case "getSavedSync":
                 prom = this.backend?.getSavedSync(false);
                 break;
-            case 'setSyncData':
+            case "setSyncData":
                 prom = this.backend?.setSyncData(msg.args[0]);
                 break;
-            case 'syncToDatabase':
+            case "syncToDatabase":
                 prom = this.backend?.syncToDatabase(msg.args[0]);
                 break;
-            case 'getUserPresenceEvents':
+            case "getUserPresenceEvents":
                 prom = this.backend?.getUserPresenceEvents();
                 break;
-            case 'getNextBatchToken':
+            case "getNextBatchToken":
                 prom = this.backend?.getNextBatchToken();
                 break;
-            case 'getOutOfBandMembers':
+            case "getOutOfBandMembers":
                 prom = this.backend?.getOutOfBandMembers(msg.args[0]);
                 break;
-            case 'clearOutOfBandMembers':
+            case "clearOutOfBandMembers":
                 prom = this.backend?.clearOutOfBandMembers(msg.args[0]);
                 break;
-            case 'setOutOfBandMembers':
+            case "setOutOfBandMembers":
                 prom = this.backend?.setOutOfBandMembers(msg.args[0], msg.args[1]);
                 break;
-            case 'getClientOptions':
+            case "getClientOptions":
                 prom = this.backend?.getClientOptions();
                 break;
-            case 'storeClientOptions':
+            case "storeClientOptions":
                 prom = this.backend?.storeClientOptions(msg.args[0]);
                 break;
-            case 'saveToDeviceBatches':
+            case "saveToDeviceBatches":
                 prom = this.backend?.saveToDeviceBatches(msg.args[0]);
                 break;
-            case 'getOldestToDeviceBatch':
+            case "getOldestToDeviceBatch":
                 prom = this.backend?.getOldestToDeviceBatch();
                 break;
-            case 'removeToDeviceBatch':
+            case "removeToDeviceBatch":
                 prom = this.backend?.removeToDeviceBatch(msg.args[0]);
                 break;
         }
 
         if (prom === undefined) {
             this.postMessage({
-                command: 'cmd_fail',
+                command: "cmd_fail",
                 seq: msg.seq,
                 // Can't be an Error because they're not structured cloneable
                 error: "Unrecognised command",
@@ -126,23 +126,26 @@ export class IndexedDBStoreWorker {
             return;
         }
 
-        prom.then((ret) => {
-            this.postMessage.call(null, {
-                command: 'cmd_success',
-                seq: msg.seq,
-                result: ret,
-            });
-        }, (err) => {
-            logger.error("Error running command: " + msg.command, err);
-            this.postMessage.call(null, {
-                command: 'cmd_fail',
-                seq: msg.seq,
-                // Just send a string because Error objects aren't cloneable
-                error: {
-                    message: err.message,
-                    name: err.name,
-                },
-            });
-        });
+        prom.then(
+            (ret) => {
+                this.postMessage.call(null, {
+                    command: "cmd_success",
+                    seq: msg.seq,
+                    result: ret,
+                });
+            },
+            (err) => {
+                logger.error("Error running command: " + msg.command, err);
+                this.postMessage.call(null, {
+                    command: "cmd_fail",
+                    seq: msg.seq,
+                    // Just send a string because Error objects aren't cloneable
+                    error: {
+                        message: err.message,
+                        name: err.name,
+                    },
+                });
+            },
+        );
     };
 }
diff --git a/src/store/indexeddb.ts b/src/store/indexeddb.ts
index 656049f2b27..1f0961e2bc0 100644
--- a/src/store/indexeddb.ts
+++ b/src/store/indexeddb.ts
@@ -21,7 +21,7 @@ import { LocalIndexedDBStoreBackend } from "./indexeddb-local-backend";
 import { RemoteIndexedDBStoreBackend } from "./indexeddb-remote-backend";
 import { User } from "../models/user";
 import { IEvent, MatrixEvent } from "../models/event";
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { ISavedSync } from "./index";
 import { IIndexedDBBackend } from "./indexeddb-backend";
 import { ISyncResponse } from "../sync-accumulator";
@@ -51,7 +51,7 @@ interface IOpts extends IBaseOpts {
 }
 
 type EventHandlerMap = {
-    "degraded": (e: Error) => void;
+    degraded: (e: Error) => void;
 };
 
 export class IndexedDBStore extends MemoryStore {
@@ -104,7 +104,7 @@ export class IndexedDBStore extends MemoryStore {
         super(opts);
 
         if (!opts.indexedDB) {
-            throw new Error('Missing required option: indexedDB');
+            throw new Error("Missing required option: indexedDB");
         }
 
         if (opts.workerFactory) {
@@ -126,20 +126,23 @@ export class IndexedDBStore extends MemoryStore {
         }
 
         logger.log(`IndexedDBStore.startup: connecting to backend`);
-        return this.backend.connect().then(() => {
-            logger.log(`IndexedDBStore.startup: loading presence events`);
-            return this.backend.getUserPresenceEvents();
-        }).then((userPresenceEvents) => {
-            logger.log(`IndexedDBStore.startup: processing presence events`);
-            userPresenceEvents.forEach(([userId, rawEvent]) => {
-                const u = new User(userId);
-                if (rawEvent) {
-                    u.setPresenceEvent(new MatrixEvent(rawEvent));
-                }
-                this.userModifiedMap[u.userId] = u.getLastModifiedTime();
-                this.storeUser(u);
+        return this.backend
+            .connect()
+            .then(() => {
+                logger.log(`IndexedDBStore.startup: loading presence events`);
+                return this.backend.getUserPresenceEvents();
+            })
+            .then((userPresenceEvents) => {
+                logger.log(`IndexedDBStore.startup: processing presence events`);
+                userPresenceEvents.forEach(([userId, rawEvent]) => {
+                    const u = new User(userId);
+                    if (rawEvent) {
+                        u.setPresenceEvent(new MatrixEvent(rawEvent));
+                    }
+                    this.userModifiedMap[u.userId] = u.getLastModifiedTime();
+                    this.storeUser(u);
+                });
             });
-        });
     }
 
     /**
@@ -170,12 +173,15 @@ export class IndexedDBStore extends MemoryStore {
      */
     public deleteAllData = this.degradable((): Promise<void> => {
         super.deleteAllData();
-        return this.backend.clearDatabase().then(() => {
-            logger.log("Deleted indexeddb data.");
-        }, (err) => {
-            logger.error(`Failed to delete indexeddb data: ${err}`);
-            throw err;
-        });
+        return this.backend.clearDatabase().then(
+            () => {
+                logger.log("Deleted indexeddb data.");
+            },
+            (err) => {
+                logger.error(`Failed to delete indexeddb data: ${err}`);
+                throw err;
+            },
+        );
     });
 
     /**
@@ -284,7 +290,7 @@ export class IndexedDBStore extends MemoryStore {
         func: DegradableFn<A, R>,
         fallback?: keyof MemoryStore,
     ): DegradableFn<A, R> {
-        const fallbackFn = fallback ? super[fallback] as Function : null;
+        const fallbackFn = fallback ? (super[fallback] as Function) : null;
 
         return async (...args) => {
             try {
diff --git a/src/store/local-storage-events-emitter.ts b/src/store/local-storage-events-emitter.ts
index 24524c63438..adb70cb541d 100644
--- a/src/store/local-storage-events-emitter.ts
+++ b/src/store/local-storage-events-emitter.ts
@@ -17,12 +17,12 @@ limitations under the License.
 import { TypedEventEmitter } from "../models/typed-event-emitter";
 
 export enum LocalStorageErrors {
-    Global = 'Global',
-    SetItemError = 'setItem',
-    GetItemError = 'getItem',
-    RemoveItemError = 'removeItem',
-    ClearError = 'clear',
-    QuotaExceededError = 'QuotaExceededError'
+    Global = "Global",
+    SetItemError = "setItem",
+    GetItemError = "getItem",
+    RemoveItemError = "removeItem",
+    ClearError = "clear",
+    QuotaExceededError = "QuotaExceededError",
 }
 
 type EventHandlerMap = {
diff --git a/src/store/memory.ts b/src/store/memory.ts
index c698b93955f..782d7edef77 100644
--- a/src/store/memory.ts
+++ b/src/store/memory.ts
@@ -33,7 +33,8 @@ import { IndexedToDeviceBatch, ToDeviceBatchWithTxnId } from "../models/ToDevice
 import { IStoredClientOpts } from "../client";
 
 function isValidFilterId(filterId?: string | number | null): boolean {
-    const isValidStr = typeof filterId === "string" &&
+    const isValidStr =
+        typeof filterId === "string" &&
         !!filterId &&
         filterId !== "undefined" && // exclude these as we've serialized undefined in localStorage before
         filterId !== "null";
@@ -162,7 +163,7 @@ export class MemoryStore implements IStore {
      * @returns A summary of each room.
      */
     public getRoomSummaries(): RoomSummary[] {
-        return Object.values(this.rooms).map(function(room) {
+        return Object.values(this.rooms).map(function (room) {
             return room.summary!;
         });
     }
@@ -434,7 +435,7 @@ export class MemoryStore implements IStore {
     }
 
     public removeToDeviceBatch(id: number): Promise<void> {
-        this.pendingToDeviceBatches = this.pendingToDeviceBatches.filter(batch => batch.id !== id);
+        this.pendingToDeviceBatches = this.pendingToDeviceBatches.filter((batch) => batch.id !== id);
         return Promise.resolve();
     }
 }
diff --git a/src/sync-accumulator.ts b/src/sync-accumulator.ts
index 13f87ecc06e..be1e8a16ffa 100644
--- a/src/sync-accumulator.ts
+++ b/src/sync-accumulator.ts
@@ -18,13 +18,13 @@ limitations under the License.
  * This is an internal module. See {@link SyncAccumulator} for the public class.
  */
 
-import { logger } from './logger';
+import { logger } from "./logger";
 import { deepCopy, isSupportedReceiptType } from "./utils";
 import { IContent, IUnsigned } from "./models/event";
 import { IRoomSummary } from "./models/room-summary";
 import { EventType } from "./@types/event";
 import { MAIN_ROOM_TIMELINE, ReceiptContent, ReceiptType } from "./@types/read_receipts";
-import { UNREAD_THREAD_NOTIFICATIONS } from './@types/sync';
+import { UNREAD_THREAD_NOTIFICATIONS } from "./@types/sync";
 
 interface IOpts {
     /**
@@ -77,13 +77,13 @@ export interface ITimeline {
 }
 
 export interface IJoinedRoom {
-    summary: IRoomSummary;
-    state: IState;
-    timeline: ITimeline;
-    ephemeral: IEphemeral;
-    account_data: IAccountData;
-    unread_notifications: UnreadNotificationCounts;
-    unread_thread_notifications?: Record<string, UnreadNotificationCounts>;
+    "summary": IRoomSummary;
+    "state": IState;
+    "timeline": ITimeline;
+    "ephemeral": IEphemeral;
+    "account_data": IAccountData;
+    "unread_notifications": UnreadNotificationCounts;
+    "unread_thread_notifications"?: Record<string, UnreadNotificationCounts>;
     "org.matrix.msc3773.unread_thread_notifications"?: Record<string, UnreadNotificationCounts>;
 }
 
@@ -138,15 +138,15 @@ interface IDeviceLists {
 }
 
 export interface ISyncResponse {
-    next_batch: string;
-    rooms: IRooms;
-    presence?: IPresence;
-    account_data: IAccountData;
-    to_device?: IToDevice;
-    device_lists?: IDeviceLists;
-    device_one_time_keys_count?: Record<string, number>;
-
-    device_unused_fallback_key_types?: string[];
+    "next_batch": string;
+    "rooms": IRooms;
+    "presence"?: IPresence;
+    "account_data": IAccountData;
+    "to_device"?: IToDevice;
+    "device_lists"?: IDeviceLists;
+    "device_one_time_keys_count"?: Record<string, number>;
+
+    "device_unused_fallback_key_types"?: string[];
     "org.matrix.msc2732.device_unused_fallback_key_types"?: string[];
 }
 /* eslint-enable camelcase */
@@ -284,7 +284,8 @@ export class SyncAccumulator {
                 break;
 
             case Category.Join:
-                if (this.inviteRooms[roomId]) { // (1)
+                if (this.inviteRooms[roomId]) {
+                    // (1)
                     // was previously invite, now join. We expect /sync to give
                     // the entire state and timeline on 'join', so delete previous
                     // invite state
@@ -295,9 +296,11 @@ export class SyncAccumulator {
                 break;
 
             case Category.Leave:
-                if (this.inviteRooms[roomId]) { // (4)
+                if (this.inviteRooms[roomId]) {
+                    // (4)
                     delete this.inviteRooms[roomId];
-                } else { // (2)
+                } else {
+                    // (2)
                     delete this.joinRooms[roomId];
                 }
                 break;
@@ -308,7 +311,8 @@ export class SyncAccumulator {
     }
 
     private accumulateInviteState(roomId: string, data: IInvitedRoom): void {
-        if (!data.invite_state || !data.invite_state.events) { // no new data
+        if (!data.invite_state || !data.invite_state.events) {
+            // no new data
             return;
         }
         if (!this.inviteRooms[roomId]) {
@@ -400,9 +404,8 @@ export class SyncAccumulator {
         if (data.unread_notifications) {
             currentData._unreadNotifications = data.unread_notifications;
         }
-        currentData._unreadThreadNotifications = data[UNREAD_THREAD_NOTIFICATIONS.stable!]
-            ?? data[UNREAD_THREAD_NOTIFICATIONS.unstable!]
-            ?? undefined;
+        currentData._unreadThreadNotifications =
+            data[UNREAD_THREAD_NOTIFICATIONS.stable!] ?? data[UNREAD_THREAD_NOTIFICATIONS.unstable!] ?? undefined;
 
         if (data.summary) {
             const HEROES_KEY = "m.heroes";
@@ -501,22 +504,18 @@ export class SyncAccumulator {
 
             currentData._timeline.push({
                 event: transformedEvent,
-                token: index === 0 ? (data.timeline.prev_batch ?? null) : null,
+                token: index === 0 ? data.timeline.prev_batch ?? null : null,
             });
         });
 
         // attempt to prune the timeline by jumping between events which have
         // pagination tokens.
         if (currentData._timeline.length > this.opts.maxTimelineEntries!) {
-            const startIndex = (
-                currentData._timeline.length - this.opts.maxTimelineEntries!
-            );
+            const startIndex = currentData._timeline.length - this.opts.maxTimelineEntries!;
             for (let i = startIndex; i < currentData._timeline.length; i++) {
                 if (currentData._timeline[i].token) {
                     // keep all events after this, including this one
-                    currentData._timeline = currentData._timeline.slice(
-                        i, currentData._timeline.length,
-                    );
+                    currentData._timeline = currentData._timeline.slice(i, currentData._timeline.length);
                     break;
                 }
             }
@@ -593,9 +592,7 @@ export class SyncAccumulator {
                 if (!receiptEvent.content[receiptData.eventId][receiptData.type]) {
                     receiptEvent.content[receiptData.eventId][receiptData.type] = {};
                 }
-                receiptEvent.content[receiptData.eventId][receiptData.type][userId] = (
-                    receiptData.data
-                );
+                receiptEvent.content[receiptData.eventId][receiptData.type][userId] = receiptData.data;
             }
 
             for (const threadReceipts of Object.values(roomData._threadReadReceipts)) {
@@ -606,9 +603,7 @@ export class SyncAccumulator {
                     if (!receiptEvent.content[receiptData.eventId][receiptData.type]) {
                         receiptEvent.content[receiptData.eventId][receiptData.type] = {};
                     }
-                    receiptEvent.content[receiptData.eventId][receiptData.type][userId] = (
-                        receiptData.data
-                    );
+                    receiptEvent.content[receiptData.eventId][receiptData.type][userId] = receiptData.data;
                 }
             }
             // add only if we have some receipt data
@@ -654,10 +649,12 @@ export class SyncAccumulator {
             // by "reverse clobbering" from the end of the timeline to the start.
             // Convert maps back into arrays.
             const rollBackState = Object.create(null);
-            for (let i = roomJson.timeline.events.length - 1; i >=0; i--) {
+            for (let i = roomJson.timeline.events.length - 1; i >= 0; i--) {
                 const timelineEvent = roomJson.timeline.events[i];
-                if ((timelineEvent as IStateEvent).state_key === null ||
-                    (timelineEvent as IStateEvent).state_key === undefined) {
+                if (
+                    (timelineEvent as IStateEvent).state_key === null ||
+                    (timelineEvent as IStateEvent).state_key === undefined
+                ) {
                     continue; // not a state event
                 }
                 // since we're going back in time, we need to use the previous
diff --git a/src/sync.ts b/src/sync.ts
index 38325ca8340..0169ff51186 100644
--- a/src/sync.ts
+++ b/src/sync.ts
@@ -32,8 +32,8 @@ import { IDeferred } from "./utils";
 import { Filter } from "./filter";
 import { EventTimeline } from "./models/event-timeline";
 import { PushProcessor } from "./pushprocessor";
-import { logger } from './logger';
-import { InvalidStoreError, InvalidStoreState } from './errors';
+import { logger } from "./logger";
+import { InvalidStoreError, InvalidStoreState } from "./errors";
 import { ClientEvent, IStoredClientOpts, MatrixClient, PendingEventOrdering } from "./client";
 import {
     IEphemeral,
@@ -96,9 +96,7 @@ export enum SyncState {
 // Room versions where "insertion", "batch", and "marker" events are controlled
 // by power-levels. MSC2716 is supported in existing room versions but they
 // should only have special meaning when the room creator sends them.
-const MSC2716_ROOM_VERSIONS = [
-    'org.matrix.msc2716v3',
-];
+const MSC2716_ROOM_VERSIONS = ["org.matrix.msc2716v3"];
 
 function getFilterName(userId: string, suffix?: string): string {
     // scope this on the user ID because people may login on many accounts
@@ -188,7 +186,7 @@ export class SyncApi {
     public constructor(private readonly client: MatrixClient, private readonly opts: Partial<IStoredClientOpts> = {}) {
         this.opts.initialSyncLimit = this.opts.initialSyncLimit ?? 8;
         this.opts.resolveInvitesToProfiles = this.opts.resolveInvitesToProfiles || false;
-        this.opts.pollTimeout = this.opts.pollTimeout || (30 * 1000);
+        this.opts.pollTimeout = this.opts.pollTimeout || 30 * 1000;
         this.opts.pendingEventOrdering = this.opts.pendingEventOrdering || PendingEventOrdering.Chronological;
         this.opts.experimentalThreadSupport = this.opts.experimentalThreadSupport === true;
 
@@ -199,10 +197,7 @@ export class SyncApi {
         }
 
         if (client.getNotifTimelineSet()) {
-            client.reEmitter.reEmit(client.getNotifTimelineSet()!, [
-                RoomEvent.Timeline,
-                RoomEvent.TimelineReset,
-            ]);
+            client.reEmitter.reEmit(client.getNotifTimelineSet()!, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
         }
     }
 
@@ -224,7 +219,7 @@ export class SyncApi {
      * @param markerEvent - The new marker event
      * @param setStateOptions - When `timelineWasEmpty` is set
      * as `true`, the given marker event will be ignored
-    */
+     */
     private onMarkerStateEvent(
         room: Room,
         markerEvent: MatrixEvent,
@@ -238,7 +233,7 @@ export class SyncApi {
         if (timelineWasEmpty) {
             logger.debug(
                 `MarkerState: Ignoring markerEventId=${markerEvent.getId()} in roomId=${room.roomId} ` +
-                `because the timeline was empty before the marker arrived which means there is nothing to refresh.`,
+                    `because the timeline was empty before the marker arrived which means there is nothing to refresh.`,
             );
             return;
         }
@@ -270,15 +265,15 @@ export class SyncApi {
             // refresh the timeline.
             logger.debug(
                 `MarkerState: Timeline needs to be refreshed because ` +
-                `a new markerEventId=${markerEvent.getId()} was sent in roomId=${room.roomId}`,
+                    `a new markerEventId=${markerEvent.getId()} was sent in roomId=${room.roomId}`,
             );
             room.setTimelineNeedsRefresh(true);
             room.emit(RoomEvent.HistoryImportedWithinTimeline, markerEvent, room);
         } else {
             logger.debug(
                 `MarkerState: Ignoring markerEventId=${markerEvent.getId()} in roomId=${room.roomId} because ` +
-                `MSC2716 is not supported in the room version or for any room version, the marker wasn't sent ` +
-                `by the room creator.`,
+                    `MSC2716 is not supported in the room version or for any room version, the marker wasn't sent ` +
+                    `by the room creator.`,
             );
         }
     }
@@ -298,7 +293,8 @@ export class SyncApi {
         const localTimeoutMs = this.opts.pollTimeout! + BUFFER_PERIOD_MS;
 
         const filterId = await client.getOrCreateFilter(
-            getFilterName(client.credentials.userId!, "LEFT_ROOMS"), filter,
+            getFilterName(client.credentials.userId!, "LEFT_ROOMS"),
+            filter,
         );
 
         const qps: ISyncParams = {
@@ -315,40 +311,42 @@ export class SyncApi {
             leaveRooms = this.mapSyncResponseToRoomArray(data.rooms.leave);
         }
 
-        const rooms = await Promise.all(leaveRooms.map(async (leaveObj) => {
-            const room = leaveObj.room;
-            if (!leaveObj.isBrandNewRoom) {
-                // the intention behind syncLeftRooms is to add in rooms which were
-                // *omitted* from the initial /sync. Rooms the user were joined to
-                // but then left whilst the app is running will appear in this list
-                // and we do not want to bother with them since they will have the
-                // current state already (and may get dupe messages if we add
-                // yet more timeline events!), so skip them.
-                // NB: When we persist rooms to localStorage this will be more
-                //     complicated...
-                return;
-            }
-            leaveObj.timeline = leaveObj.timeline || {
-                prev_batch: null,
-                events: [],
-            };
-            const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
+        const rooms = await Promise.all(
+            leaveRooms.map(async (leaveObj) => {
+                const room = leaveObj.room;
+                if (!leaveObj.isBrandNewRoom) {
+                    // the intention behind syncLeftRooms is to add in rooms which were
+                    // *omitted* from the initial /sync. Rooms the user were joined to
+                    // but then left whilst the app is running will appear in this list
+                    // and we do not want to bother with them since they will have the
+                    // current state already (and may get dupe messages if we add
+                    // yet more timeline events!), so skip them.
+                    // NB: When we persist rooms to localStorage this will be more
+                    //     complicated...
+                    return;
+                }
+                leaveObj.timeline = leaveObj.timeline || {
+                    prev_batch: null,
+                    events: [],
+                };
+                const events = this.mapSyncEventsFormat(leaveObj.timeline, room);
 
-            const stateEvents = this.mapSyncEventsFormat(leaveObj.state, room);
+                const stateEvents = this.mapSyncEventsFormat(leaveObj.state, room);
 
-            // set the back-pagination token. Do this *before* adding any
-            // events so that clients can start back-paginating.
-            room.getLiveTimeline().setPaginationToken(leaveObj.timeline.prev_batch, EventTimeline.BACKWARDS);
+                // set the back-pagination token. Do this *before* adding any
+                // events so that clients can start back-paginating.
+                room.getLiveTimeline().setPaginationToken(leaveObj.timeline.prev_batch, EventTimeline.BACKWARDS);
 
-            await this.injectRoomEvents(room, stateEvents, events);
+                await this.injectRoomEvents(room, stateEvents, events);
 
-            room.recalculate();
-            client.store.storeRoom(room);
-            client.emit(ClientEvent.Room, room);
+                room.recalculate();
+                client.store.storeRoom(room);
+                client.emit(ClientEvent.Room, room);
 
-            this.processEventsForNotifs(room, events);
-            return room;
-        }));
+                this.processEventsForNotifs(room, events);
+                return room;
+            }),
+        );
 
         return rooms.filter(Boolean) as Room[];
     }
@@ -375,26 +373,24 @@ export class SyncApi {
 
             // FIXME: Mostly duplicated from injectRoomEvents but not entirely
             // because "state" in this API is at the BEGINNING of the chunk
-            const oldStateEvents = utils.deepCopy(response.state)
-                .map(client.getEventMapper());
+            const oldStateEvents = utils.deepCopy(response.state).map(client.getEventMapper());
             const stateEvents = response.state.map(client.getEventMapper());
             const messages = response.messages.chunk.map(client.getEventMapper());
 
             // XXX: copypasted from /sync until we kill off this minging v1 API stuff)
             // handle presence events (User objects)
             if (Array.isArray(response.presence)) {
-                response.presence.map(client.getEventMapper()).forEach(
-                    function(presenceEvent) {
-                        let user = client.store.getUser(presenceEvent.getContent().user_id);
-                        if (user) {
-                            user.setPresenceEvent(presenceEvent);
-                        } else {
-                            user = createNewUser(client, presenceEvent.getContent().user_id);
-                            user.setPresenceEvent(presenceEvent);
-                            client.store.storeUser(user);
-                        }
-                        client.emit(ClientEvent.Event, presenceEvent);
-                    });
+                response.presence.map(client.getEventMapper()).forEach(function (presenceEvent) {
+                    let user = client.store.getUser(presenceEvent.getContent().user_id);
+                    if (user) {
+                        user.setPresenceEvent(presenceEvent);
+                    } else {
+                        user = createNewUser(client, presenceEvent.getContent().user_id);
+                        user.setPresenceEvent(presenceEvent);
+                        client.store.storeUser(user);
+                    }
+                    client.emit(ClientEvent.Event, presenceEvent);
+                });
             }
 
             // set the pagination token before adding the events in case people
@@ -414,9 +410,12 @@ export class SyncApi {
             // roll backwards to diverge old state. addEventsToTimeline
             // will overwrite the pagination token, so make sure it overwrites
             // it with the right thing.
-            this._peekRoom!.addEventsToTimeline(messages.reverse(), true,
+            this._peekRoom!.addEventsToTimeline(
+                messages.reverse(),
+                true,
                 this._peekRoom!.getLiveTimeline(),
-                response.messages.start);
+                response.messages.start,
+            );
 
             client.store.storeRoom(this._peekRoom!);
             client.emit(ClientEvent.Room, this._peekRoom!);
@@ -445,56 +444,72 @@ export class SyncApi {
         }
 
         // FIXME: gut wrenching; hard-coded timeout values
-        this.client.http.authedRequest<IEventsResponse>(Method.Get, "/events", {
-            room_id: peekRoom.roomId,
-            timeout: String(30 * 1000),
-            from: token,
-        }, undefined, {
-            localTimeoutMs: 50 * 1000,
-            abortSignal: this.abortController?.signal,
-        }).then((res) => {
-            if (this._peekRoom !== peekRoom) {
-                debuglog("Stopped peeking in room %s", peekRoom.roomId);
-                return;
-            }
-            // We have a problem that we get presence both from /events and /sync
-            // however, /sync only returns presence for users in rooms
-            // you're actually joined to.
-            // in order to be sure to get presence for all of the users in the
-            // peeked room, we handle presence explicitly here. This may result
-            // in duplicate presence events firing for some users, which is a
-            // performance drain, but such is life.
-            // XXX: copypasted from /sync until we can kill this minging v1 stuff.
-
-            res.chunk.filter(function(e) {
-                return e.type === "m.presence";
-            }).map(this.client.getEventMapper()).forEach((presenceEvent) => {
-                let user = this.client.store.getUser(presenceEvent.getContent().user_id);
-                if (user) {
-                    user.setPresenceEvent(presenceEvent);
-                } else {
-                    user = createNewUser(this.client, presenceEvent.getContent().user_id);
-                    user.setPresenceEvent(presenceEvent);
-                    this.client.store.storeUser(user);
-                }
-                this.client.emit(ClientEvent.Event, presenceEvent);
-            });
-
-            // strip out events which aren't for the given room_id (e.g presence)
-            // and also ephemeral events (which we're assuming is anything without
-            // and event ID because the /events API doesn't separate them).
-            const events = res.chunk.filter(function(e) {
-                return e.room_id === peekRoom.roomId && e.event_id;
-            }).map(this.client.getEventMapper());
-
-            peekRoom.addLiveEvents(events);
-            this.peekPoll(peekRoom, res.end);
-        }, (err) => {
-            logger.error("[%s] Peek poll failed: %s", peekRoom.roomId, err);
-            setTimeout(() => {
-                this.peekPoll(peekRoom, token);
-            }, 30 * 1000);
-        });
+        this.client.http
+            .authedRequest<IEventsResponse>(
+                Method.Get,
+                "/events",
+                {
+                    room_id: peekRoom.roomId,
+                    timeout: String(30 * 1000),
+                    from: token,
+                },
+                undefined,
+                {
+                    localTimeoutMs: 50 * 1000,
+                    abortSignal: this.abortController?.signal,
+                },
+            )
+            .then(
+                (res) => {
+                    if (this._peekRoom !== peekRoom) {
+                        debuglog("Stopped peeking in room %s", peekRoom.roomId);
+                        return;
+                    }
+                    // We have a problem that we get presence both from /events and /sync
+                    // however, /sync only returns presence for users in rooms
+                    // you're actually joined to.
+                    // in order to be sure to get presence for all of the users in the
+                    // peeked room, we handle presence explicitly here. This may result
+                    // in duplicate presence events firing for some users, which is a
+                    // performance drain, but such is life.
+                    // XXX: copypasted from /sync until we can kill this minging v1 stuff.
+
+                    res.chunk
+                        .filter(function (e) {
+                            return e.type === "m.presence";
+                        })
+                        .map(this.client.getEventMapper())
+                        .forEach((presenceEvent) => {
+                            let user = this.client.store.getUser(presenceEvent.getContent().user_id);
+                            if (user) {
+                                user.setPresenceEvent(presenceEvent);
+                            } else {
+                                user = createNewUser(this.client, presenceEvent.getContent().user_id);
+                                user.setPresenceEvent(presenceEvent);
+                                this.client.store.storeUser(user);
+                            }
+                            this.client.emit(ClientEvent.Event, presenceEvent);
+                        });
+
+                    // strip out events which aren't for the given room_id (e.g presence)
+                    // and also ephemeral events (which we're assuming is anything without
+                    // and event ID because the /events API doesn't separate them).
+                    const events = res.chunk
+                        .filter(function (e) {
+                            return e.room_id === peekRoom.roomId && e.event_id;
+                        })
+                        .map(this.client.getEventMapper());
+
+                    peekRoom.addLiveEvents(events);
+                    this.peekPoll(peekRoom, res.end);
+                },
+                (err) => {
+                    logger.error("[%s] Peek poll failed: %s", peekRoom.roomId, err);
+                    setTimeout(() => {
+                        this.peekPoll(peekRoom, token);
+                    }, 30 * 1000);
+                },
+            );
     }
 
     /**
@@ -598,8 +613,7 @@ export class SyncApi {
                 }
                 this.opts.filter.setLazyLoadMembers(true);
             } else {
-                debuglog("LL: lazy loading requested but not supported " +
-                    "by server, so disabling");
+                debuglog("LL: lazy loading requested but not supported " + "by server, so disabling");
                 this.opts.lazyLoadMembers = false;
             }
         }
@@ -677,19 +691,22 @@ export class SyncApi {
         // all the sync data which could take a while. This will let us send our
         // first incremental sync request before we've processed our saved data.
         debuglog("Getting saved sync token...");
-        const savedSyncTokenPromise = this.client.store.getSavedSyncToken().then(tok => {
+        const savedSyncTokenPromise = this.client.store.getSavedSyncToken().then((tok) => {
             debuglog("Got saved sync token");
             return tok;
         });
 
-        this.savedSyncPromise = this.client.store.getSavedSync().then((savedSync) => {
-            debuglog(`Got reply from saved sync, exists? ${!!savedSync}`);
-            if (savedSync) {
-                return this.syncFromCache(savedSync);
-            }
-        }).catch(err => {
-            logger.error("Getting saved sync failed", err);
-        });
+        this.savedSyncPromise = this.client.store
+            .getSavedSync()
+            .then((savedSync) => {
+                debuglog(`Got reply from saved sync, exists? ${!!savedSync}`);
+                if (savedSync) {
+                    return this.syncFromCache(savedSync);
+                }
+            })
+            .catch((err) => {
+                logger.error("Getting saved sync failed", err);
+            });
 
         // We need to do one-off checks before we can begin the /sync loop.
         // These are:
@@ -985,7 +1002,7 @@ export class SyncApi {
         }
 
         this.failedSyncCount++;
-        logger.log('Number of consecutive failed sync requests:', this.failedSyncCount);
+        logger.log("Number of consecutive failed sync requests:", this.failedSyncCount);
 
         debuglog("Starting keep-alive");
         // Note that we do *not* mark the sync connection as
@@ -1000,8 +1017,7 @@ export class SyncApi {
         this.currentSyncRequest = undefined;
         // Transition from RECONNECTING to ERROR after a given number of failed syncs
         this.updateSyncState(
-            this.failedSyncCount >= FAILED_SYNC_ERROR_THRESHOLD ?
-                SyncState.Error : SyncState.Reconnecting,
+            this.failedSyncCount >= FAILED_SYNC_ERROR_THRESHOLD ? SyncState.Error : SyncState.Reconnecting,
             { error: err },
         );
 
@@ -1076,18 +1092,17 @@ export class SyncApi {
 
         // handle presence events (User objects)
         if (Array.isArray(data.presence?.events)) {
-            data.presence!.events.map(client.getEventMapper()).forEach(
-                function(presenceEvent) {
-                    let user = client.store.getUser(presenceEvent.getSender()!);
-                    if (user) {
-                        user.setPresenceEvent(presenceEvent);
-                    } else {
-                        user = createNewUser(client, presenceEvent.getSender()!);
-                        user.setPresenceEvent(presenceEvent);
-                        client.store.storeUser(user);
-                    }
-                    client.emit(ClientEvent.Event, presenceEvent);
-                });
+            data.presence!.events.map(client.getEventMapper()).forEach(function (presenceEvent) {
+                let user = client.store.getUser(presenceEvent.getSender()!);
+                if (user) {
+                    user.setPresenceEvent(presenceEvent);
+                } else {
+                    user = createNewUser(client, presenceEvent.getSender()!);
+                    user.setPresenceEvent(presenceEvent);
+                    client.store.storeUser(user);
+                }
+                client.emit(ClientEvent.Event, presenceEvent);
+            });
         }
 
         // handle non-room account_data
@@ -1098,49 +1113,45 @@ export class SyncApi {
                 return m;
             }, {});
             client.store.storeAccountDataEvents(events);
-            events.forEach(
-                function(accountDataEvent) {
-                    // Honour push rules that come down the sync stream but also
-                    // honour push rules that were previously cached. Base rules
-                    // will be updated when we receive push rules via getPushRules
-                    // (see sync) before syncing over the network.
-                    if (accountDataEvent.getType() === EventType.PushRules) {
-                        const rules = accountDataEvent.getContent<IPushRules>();
-                        client.pushRules = PushProcessor.rewriteDefaultRules(rules);
-                    }
-                    const prevEvent = prevEventsMap[accountDataEvent.getType()!];
-                    client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);
-                    return accountDataEvent;
-                },
-            );
+            events.forEach(function (accountDataEvent) {
+                // Honour push rules that come down the sync stream but also
+                // honour push rules that were previously cached. Base rules
+                // will be updated when we receive push rules via getPushRules
+                // (see sync) before syncing over the network.
+                if (accountDataEvent.getType() === EventType.PushRules) {
+                    const rules = accountDataEvent.getContent<IPushRules>();
+                    client.pushRules = PushProcessor.rewriteDefaultRules(rules);
+                }
+                const prevEvent = prevEventsMap[accountDataEvent.getType()!];
+                client.emit(ClientEvent.AccountData, accountDataEvent, prevEvent);
+                return accountDataEvent;
+            });
         }
 
         // handle to-device events
         if (Array.isArray(data.to_device?.events) && data.to_device!.events.length > 0) {
             const cancelledKeyVerificationTxns: string[] = [];
-            data.to_device!.events
-                .filter((eventJSON) => {
-                    if (
-                        eventJSON.type === EventType.RoomMessageEncrypted &&
-                        !(["m.olm.v1.curve25519-aes-sha2"].includes(eventJSON.content?.algorithm))
-                    ) {
-                        logger.log(
-                            'Ignoring invalid encrypted to-device event from ' + eventJSON.sender,
-                        );
-                        return false;
-                    }
+            data.to_device!.events.filter((eventJSON) => {
+                if (
+                    eventJSON.type === EventType.RoomMessageEncrypted &&
+                    !["m.olm.v1.curve25519-aes-sha2"].includes(eventJSON.content?.algorithm)
+                ) {
+                    logger.log("Ignoring invalid encrypted to-device event from " + eventJSON.sender);
+                    return false;
+                }
 
-                    return true;
-                })
+                return true;
+            })
                 .map(client.getEventMapper({ toDevice: true }))
-                .map((toDeviceEvent) => { // map is a cheap inline forEach
+                .map((toDeviceEvent) => {
+                    // map is a cheap inline forEach
                     // We want to flag m.key.verification.start events as cancelled
                     // if there's an accompanying m.key.verification.cancel event, so
                     // we pull out the transaction IDs from the cancellation events
                     // so we can flag the verification events as cancelled in the loop
                     // below.
                     if (toDeviceEvent.getType() === "m.key.verification.cancel") {
-                        const txnId: string = toDeviceEvent.getContent()['transaction_id'];
+                        const txnId: string = toDeviceEvent.getContent()["transaction_id"];
                         if (txnId) {
                             cancelledKeyVerificationTxns.push(txnId);
                         }
@@ -1150,32 +1161,26 @@ export class SyncApi {
                     // the unmodified event.
                     return toDeviceEvent;
                 })
-                .forEach(
-                    function(toDeviceEvent) {
-                        const content = toDeviceEvent.getContent();
-                        if (
-                            toDeviceEvent.getType() == "m.room.message" &&
-                            content.msgtype == "m.bad.encrypted"
-                        ) {
-                            // the mapper already logged a warning.
-                            logger.log(
-                                'Ignoring undecryptable to-device event from ' +
-                                toDeviceEvent.getSender(),
-                            );
-                            return;
-                        }
+                .forEach(function (toDeviceEvent) {
+                    const content = toDeviceEvent.getContent();
+                    if (toDeviceEvent.getType() == "m.room.message" && content.msgtype == "m.bad.encrypted") {
+                        // the mapper already logged a warning.
+                        logger.log("Ignoring undecryptable to-device event from " + toDeviceEvent.getSender());
+                        return;
+                    }
 
-                        if (toDeviceEvent.getType() === "m.key.verification.start"
-                            || toDeviceEvent.getType() === "m.key.verification.request") {
-                            const txnId = content['transaction_id'];
-                            if (cancelledKeyVerificationTxns.includes(txnId)) {
-                                toDeviceEvent.flagCancelled();
-                            }
+                    if (
+                        toDeviceEvent.getType() === "m.key.verification.start" ||
+                        toDeviceEvent.getType() === "m.key.verification.request"
+                    ) {
+                        const txnId = content["transaction_id"];
+                        if (cancelledKeyVerificationTxns.includes(txnId)) {
+                            toDeviceEvent.flagCancelled();
                         }
+                    }
 
-                        client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);
-                    },
-                );
+                    client.emit(ClientEvent.ToDeviceEvent, toDeviceEvent);
+                });
         } else {
             // no more to-device events: we can stop polling with a short timeout.
             this.catchingUp = false;
@@ -1237,7 +1242,7 @@ export class SyncApi {
                 // Update room state for invite->reject->invite cycles
                 room.recalculate();
             }
-            stateEvents.forEach(function(e) {
+            stateEvents.forEach(function (e) {
                 client.emit(ClientEvent.Event, e);
             });
         });
@@ -1274,8 +1279,8 @@ export class SyncApi {
                 }
             }
 
-            const unreadThreadNotifications = joinObj[UNREAD_THREAD_NOTIFICATIONS.name]
-                ?? joinObj[UNREAD_THREAD_NOTIFICATIONS.altName!];
+            const unreadThreadNotifications =
+                joinObj[UNREAD_THREAD_NOTIFICATIONS.name] ?? joinObj[UNREAD_THREAD_NOTIFICATIONS.altName!];
             if (unreadThreadNotifications) {
                 // Only partially reset unread notification
                 // We want to keep the client-generated count. Particularly important
@@ -1303,7 +1308,7 @@ export class SyncApi {
                 room.resetThreadUnreadNotificationCount();
             }
 
-            joinObj.timeline = joinObj.timeline || {} as ITimeline;
+            joinObj.timeline = joinObj.timeline || ({} as ITimeline);
 
             if (joinObj.isBrandNewRoom) {
                 // set the back-pagination token. Do this *before* adding any
@@ -1351,8 +1356,7 @@ export class SyncApi {
                 if (limited) {
                     room.resetLiveTimeline(
                         joinObj.timeline.prev_batch,
-                        this.opts.canResetEntireTimeline!(room.roomId) ?
-                            null : (syncEventData.oldSyncToken ?? null),
+                        this.opts.canResetEntireTimeline!(room.roomId) ? null : syncEventData.oldSyncToken ?? null,
                     );
 
                     // We have to assume any gap in any timeline is
@@ -1431,13 +1435,13 @@ export class SyncApi {
 
             this.processEventsForNotifs(room, events);
 
-            stateEvents.forEach(function(e) {
+            stateEvents.forEach(function (e) {
                 client.emit(ClientEvent.Event, e);
             });
-            events.forEach(function(e) {
+            events.forEach(function (e) {
                 client.emit(ClientEvent.Event, e);
             });
-            accountDataEvents.forEach(function(e) {
+            accountDataEvents.forEach(function (e) {
                 client.emit(ClientEvent.Event, e);
             });
         });
@@ -1448,10 +1452,10 @@ export class SyncApi {
         // XXX: we could fix this by making EventTimeline support chronological
         // ordering... but it doesn't, right now.
         if (syncEventData.oldSyncToken && this.notifEvents.length) {
-            this.notifEvents.sort(function(a, b) {
+            this.notifEvents.sort(function (a, b) {
                 return a.getTs() - b.getTs();
             });
-            this.notifEvents.forEach(function(event) {
+            this.notifEvents.forEach(function (event) {
                 client.getNotifTimelineSet()?.addLiveEvent(event);
             });
         }
@@ -1472,18 +1476,17 @@ export class SyncApi {
             const currentCount = data.device_one_time_keys_count.signed_curve25519 || 0;
             this.opts.crypto.updateOneTimeKeyCount(currentCount);
         }
-        if (this.opts.crypto &&
-            (data.device_unused_fallback_key_types ||
-                data["org.matrix.msc2732.device_unused_fallback_key_types"])
+        if (
+            this.opts.crypto &&
+            (data.device_unused_fallback_key_types || data["org.matrix.msc2732.device_unused_fallback_key_types"])
         ) {
             // The presence of device_unused_fallback_key_types indicates that the
             // server supports fallback keys. If there's no unused
             // signed_curve25519 fallback key we need a new one.
-            const unusedFallbackKeys = data.device_unused_fallback_key_types ||
-                data["org.matrix.msc2732.device_unused_fallback_key_types"];
+            const unusedFallbackKeys =
+                data.device_unused_fallback_key_types || data["org.matrix.msc2732.device_unused_fallback_key_types"];
             this.opts.crypto.setNeedsNewFallback(
-                Array.isArray(unusedFallbackKeys) &&
-                !unusedFallbackKeys.includes("signed_curve25519"),
+                Array.isArray(unusedFallbackKeys) && !unusedFallbackKeys.includes("signed_curve25519"),
             );
         }
     }
@@ -1532,40 +1535,46 @@ export class SyncApi {
             }
         };
 
-        this.client.http.request(
-            Method.Get, "/_matrix/client/versions",
-            undefined, // queryParams
-            undefined, // data
-            {
-                prefix: '',
-                localTimeoutMs: 15 * 1000,
-                abortSignal: this.abortController?.signal,
-            },
-        ).then(() => {
-            success();
-        }, (err) => {
-            if (err.httpStatus == 400 || err.httpStatus == 404) {
-                // treat this as a success because the server probably just doesn't
-                // support /versions: point is, we're getting a response.
-                // We wait a short time though, just in case somehow the server
-                // is in a mode where it 400s /versions responses and sync etc.
-                // responses fail, this will mean we don't hammer in a loop.
-                this.keepAliveTimer = setTimeout(success, 2000);
-            } else {
-                connDidFail = true;
-                this.keepAliveTimer = setTimeout(
-                    this.pokeKeepAlive.bind(this, connDidFail),
-                    5000 + Math.floor(Math.random() * 5000),
-                );
-                // A keepalive has failed, so we emit the
-                // error state (whether or not this is the
-                // first failure).
-                // Note we do this after setting the timer:
-                // this lets the unit tests advance the mock
-                // clock when they get the error.
-                this.updateSyncState(SyncState.Error, { error: err });
-            }
-        });
+        this.client.http
+            .request(
+                Method.Get,
+                "/_matrix/client/versions",
+                undefined, // queryParams
+                undefined, // data
+                {
+                    prefix: "",
+                    localTimeoutMs: 15 * 1000,
+                    abortSignal: this.abortController?.signal,
+                },
+            )
+            .then(
+                () => {
+                    success();
+                },
+                (err) => {
+                    if (err.httpStatus == 400 || err.httpStatus == 404) {
+                        // treat this as a success because the server probably just doesn't
+                        // support /versions: point is, we're getting a response.
+                        // We wait a short time though, just in case somehow the server
+                        // is in a mode where it 400s /versions responses and sync etc.
+                        // responses fail, this will mean we don't hammer in a loop.
+                        this.keepAliveTimer = setTimeout(success, 2000);
+                    } else {
+                        connDidFail = true;
+                        this.keepAliveTimer = setTimeout(
+                            this.pokeKeepAlive.bind(this, connDidFail),
+                            5000 + Math.floor(Math.random() * 5000),
+                        );
+                        // A keepalive has failed, so we emit the
+                        // error state (whether or not this is the
+                        // first failure).
+                        // Note we do this after setting the timer:
+                        // this lets the unit tests advance the mock
+                        // clock when they get the error.
+                        this.updateSyncState(SyncState.Error, { error: err });
+                    }
+                },
+            );
     }
 
     private mapSyncResponseToRoomArray<T extends ILeftRoom | IJoinedRoom | IInvitedRoom>(
@@ -1576,7 +1585,7 @@ export class SyncApi {
         // [{stuff+Room+isBrandNewRoom}, {stuff+Room+isBrandNewRoom}]
         const client = this.client;
         return Object.keys(obj).map((roomId) => {
-            const arrObj = obj[roomId] as T & { room: Room, isBrandNewRoom: boolean };
+            const arrObj = obj[roomId] as T & { room: Room; isBrandNewRoom: boolean };
             let room = client.store.getRoom(roomId);
             let isBrandNewRoom = false;
             if (!room) {
@@ -1599,7 +1608,7 @@ export class SyncApi {
         }
         const mapper = this.client.getEventMapper({ decrypt });
         type TaggedEvent = (IStrippedState | IRoomEvent | IStateEvent | IMinimalEvent) & { room_id?: string };
-        return (obj.events as TaggedEvent[]).map(function(e) {
+        return (obj.events as TaggedEvent[]).map(function (e) {
             if (room) {
                 e.room_id = room.roomId;
             }
@@ -1616,7 +1625,7 @@ export class SyncApi {
         const client = this.client;
         // For each invited room member we want to give them a displayname/avatar url
         // if they have one (the m.room.member invites don't contain this).
-        room.getMembersWithMembership("invite").forEach(function(member) {
+        room.getMembersWithMembership("invite").forEach(function (member) {
             if (member.requestedProfileInfo) return;
             member.requestedProfileInfo = true;
             // try to get a cached copy first.
@@ -1630,22 +1639,25 @@ export class SyncApi {
             } else {
                 promise = client.getProfileInfo(member.userId);
             }
-            promise.then(function(info) {
-                // slightly naughty by doctoring the invite event but this means all
-                // the code paths remain the same between invite/join display name stuff
-                // which is a worthy trade-off for some minor pollution.
-                const inviteEvent = member.events.member;
-                if (inviteEvent?.getContent().membership !== "invite") {
-                    // between resolving and now they have since joined, so don't clobber
-                    return;
-                }
-                inviteEvent.getContent().avatar_url = info.avatar_url;
-                inviteEvent.getContent().displayname = info.displayname;
-                // fire listeners
-                member.setMembershipEvent(inviteEvent, room.currentState);
-            }, function(err) {
-                // OH WELL.
-            });
+            promise.then(
+                function (info) {
+                    // slightly naughty by doctoring the invite event but this means all
+                    // the code paths remain the same between invite/join display name stuff
+                    // which is a worthy trade-off for some minor pollution.
+                    const inviteEvent = member.events.member;
+                    if (inviteEvent?.getContent().membership !== "invite") {
+                        // between resolving and now they have since joined, so don't clobber
+                        return;
+                    }
+                    inviteEvent.getContent().avatar_url = info.avatar_url;
+                    inviteEvent.getContent().displayname = info.displayname;
+                    // fire listeners
+                    member.setMembershipEvent(inviteEvent, room.currentState);
+                },
+                function (err) {
+                    // OH WELL.
+                },
+            );
         });
     }
 
diff --git a/src/timeline-window.ts b/src/timeline-window.ts
index 2d0c9da15de..be64c3b8d7c 100644
--- a/src/timeline-window.ts
+++ b/src/timeline-window.ts
@@ -16,8 +16,8 @@ limitations under the License.
 
 import { Optional } from "matrix-events-sdk";
 
-import { Direction, EventTimeline } from './models/event-timeline';
-import { logger } from './logger';
+import { Direction, EventTimeline } from "./models/event-timeline";
+import { logger } from "./logger";
 import { MatrixClient } from "./client";
 import { EventTimelineSet } from "./models/event-timeline-set";
 import { MatrixEvent } from "./models/event";
@@ -31,7 +31,7 @@ const DEBUG = false;
  * @internal
  */
 /* istanbul ignore next */
-const debuglog = DEBUG ? logger.log.bind(logger) : function(): void {};
+const debuglog = DEBUG ? logger.log.bind(logger) : function (): void {};
 
 /**
  * the number of times we ask the server for more events before giving up
@@ -109,7 +109,7 @@ export class TimelineWindow {
                 // we were looking for the live timeline: initialise to the end
                 eventIndex = events.length;
             } else {
-                eventIndex = events.findIndex(e => e.getId() === initialEventId);
+                eventIndex = events.findIndex((e) => e.getId() === initialEventId);
 
                 if (eventIndex < 0) {
                     throw new Error("getEventTimeline result didn't include requested event");
@@ -129,8 +129,7 @@ export class TimelineWindow {
             initFields(this.timelineSet.getTimelineForEvent(initialEventId));
             return Promise.resolve();
         } else if (initialEventId) {
-            return this.client.getEventTimeline(this.timelineSet, initialEventId)
-                .then(initFields);
+            return this.client.getEventTimeline(this.timelineSet, initialEventId).then(initFields);
         } else {
             initFields(this.timelineSet.getLiveTimeline());
             return Promise.resolve();
@@ -175,13 +174,11 @@ export class TimelineWindow {
             return false;
         }
 
-        const count = (direction == EventTimeline.BACKWARDS) ?
-            tl.retreat(size) : tl.advance(size);
+        const count = direction == EventTimeline.BACKWARDS ? tl.retreat(size) : tl.advance(size);
 
         if (count) {
             this.eventCount += count;
-            debuglog("TimelineWindow: increased cap by " + count +
-                " (now " + this.eventCount + ")");
+            debuglog("TimelineWindow: increased cap by " + count + " (now " + this.eventCount + ")");
             // remove some events from the other end, if necessary
             const excess = this.eventCount - this.windowLimit;
             if (excess > 0) {
@@ -290,31 +287,34 @@ export class TimelineWindow {
 
         debuglog("TimelineWindow: starting request");
 
-        const prom = this.client.paginateEventTimeline(tl.timeline, {
-            backwards: direction == EventTimeline.BACKWARDS,
-            limit: size,
-        }).finally(function() {
-            tl.pendingPaginate = undefined;
-        }).then((r) => {
-            debuglog("TimelineWindow: request completed with result " + r);
-            if (!r) {
-                return this.paginate(direction, size, false, 0);
-            }
+        const prom = this.client
+            .paginateEventTimeline(tl.timeline, {
+                backwards: direction == EventTimeline.BACKWARDS,
+                limit: size,
+            })
+            .finally(function () {
+                tl.pendingPaginate = undefined;
+            })
+            .then((r) => {
+                debuglog("TimelineWindow: request completed with result " + r);
+                if (!r) {
+                    return this.paginate(direction, size, false, 0);
+                }
 
-            // recurse to advance the index into the results.
-            //
-            // If we don't get any new events, we want to make sure we keep asking
-            // the server for events for as long as we have a valid pagination
-            // token. In particular, we want to know if we've actually hit the
-            // start of the timeline, or if we just happened to know about all of
-            // the events thanks to https://matrix.org/jira/browse/SYN-645.
-            //
-            // On the other hand, we necessarily want to wait forever for the
-            // server to make its mind up about whether there are other events,
-            // because it gives a bad user experience
-            // (https://github.com/vector-im/vector-web/issues/1204).
-            return this.paginate(direction, size, true, requestLimit - 1);
-        });
+                // recurse to advance the index into the results.
+                //
+                // If we don't get any new events, we want to make sure we keep asking
+                // the server for events for as long as we have a valid pagination
+                // token. In particular, we want to know if we've actually hit the
+                // start of the timeline, or if we just happened to know about all of
+                // the events thanks to https://matrix.org/jira/browse/SYN-645.
+                //
+                // On the other hand, we necessarily want to wait forever for the
+                // server to make its mind up about whether there are other events,
+                // because it gives a bad user experience
+                // (https://github.com/vector-im/vector-web/issues/1204).
+                return this.paginate(direction, size, true, requestLimit - 1);
+            });
         tl.pendingPaginate = prom;
         return prom;
     }
@@ -345,15 +345,12 @@ export class TimelineWindow {
             const count = startOfTimeline ? tl.advance(delta) : tl.retreat(delta);
             if (count <= 0) {
                 // sadness. This shouldn't be possible.
-                throw new Error(
-                    "Unable to unpaginate any further, but still have " +
-                    this.eventCount + " events");
+                throw new Error("Unable to unpaginate any further, but still have " + this.eventCount + " events");
             }
 
             delta -= count;
             this.eventCount -= count;
-            debuglog("TimelineWindow.unpaginate: dropped " + count +
-                " (now " + this.eventCount + ")");
+            debuglog("TimelineWindow.unpaginate: dropped " + count + " (now " + this.eventCount + ")");
         }
     }
 
@@ -479,7 +476,8 @@ export class TimelineIndex {
         //
         // next see if there is a neighbouring timeline to switch to.
         const neighbour = this.timeline.getNeighbouringTimeline(
-            delta < 0 ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS);
+            delta < 0 ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS,
+        );
         if (neighbour) {
             this.timeline = neighbour;
             if (delta < 0) {
diff --git a/src/utils.ts b/src/utils.ts
index 8cf248c783d..5134c8a4d06 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -63,7 +63,7 @@ export function encodeParams(params: QueryDict, urlSearchParams?: URLSearchParam
     for (const [key, val] of Object.entries(params)) {
         if (val !== undefined && val !== null) {
             if (Array.isArray(val)) {
-                val.forEach(v => {
+                val.forEach((v) => {
                     searchParams.append(key, String(v));
                 });
             } else {
@@ -79,11 +79,7 @@ export type QueryDict = Record<string, string[] | string | number | boolean | un
 /**
  * Replace a stable parameter with the unstable naming for params
  */
-export function replaceParam(
-    stable: string,
-    unstable: string,
-    dict: QueryDict,
-): QueryDict {
+export function replaceParam(stable: string, unstable: string, dict: QueryDict): QueryDict {
     const result = {
         ...dict,
         [unstable]: dict[stable],
@@ -128,9 +124,7 @@ export function encodeUri(pathTemplate: string, variables: Record<string, Option
         if (value === undefined || value === null) {
             continue;
         }
-        pathTemplate = pathTemplate.replace(
-            key, encodeURIComponent(value),
-        );
+        pathTemplate = pathTemplate.replace(key, encodeURIComponent(value));
     }
     return pathTemplate;
 }
@@ -145,11 +139,7 @@ export function encodeUri(pathTemplate: string, variables: Record<string, Option
  * @param reverse - True to search in reverse order.
  * @returns True if an element was removed.
  */
-export function removeElement<T>(
-    array: T[],
-    fn: (t: T, i?: number, a?: T[]) => boolean,
-    reverse?: boolean,
-): boolean {
+export function removeElement<T>(array: T[], fn: (t: T, i?: number, a?: T[]) => boolean, reverse?: boolean): boolean {
     let i: number;
     if (reverse) {
         for (i = array.length - 1; i >= 0; i--) {
@@ -226,7 +216,7 @@ export function deepCompare(x: any, y: any): boolean {
     }
 
     // special-case NaN (since NaN !== NaN)
-    if (typeof x === 'number' && isNaN(x) && isNaN(y)) {
+    if (typeof x === "number" && isNaN(x) && isNaN(y)) {
         return true;
     }
 
@@ -290,7 +280,7 @@ export function deepCompare(x: any, y: any): boolean {
  * @returns The entries, sorted by key.
  */
 export function deepSortedObjectEntries(obj: any): [string, any][] {
-    if (typeof(obj) !== "object") return obj;
+    if (typeof obj !== "object") return obj;
 
     // Apparently these are object types...
     if (obj === null || obj === undefined || Array.isArray(obj)) return obj;
@@ -313,7 +303,7 @@ export function deepSortedObjectEntries(obj: any): [string, any][] {
  * @returns whether or not value is a finite number without type-coercion
  */
 export function isNumber(value: any): value is number {
-    return typeof value === 'number' && isFinite(value);
+    return typeof value === "number" && isFinite(value);
 }
 
 /**
@@ -324,7 +314,7 @@ export function isNumber(value: any): value is number {
  */
 export function removeHiddenChars(str: string): string {
     if (typeof str === "string") {
-        return unhomoglyph(str.normalize('NFD').replace(removeHiddenCharsRegex, ''));
+        return unhomoglyph(str.normalize("NFD").replace(removeHiddenCharsRegex, ""));
     }
     return "";
 }
@@ -335,7 +325,7 @@ export function removeHiddenChars(str: string): string {
  */
 export function removeDirectionOverrideChars(str: string): string {
     if (typeof str === "string") {
-        return str.replace(/[\u202d-\u202e]/g, '');
+        return str.replace(/[\u202d-\u202e]/g, "");
     }
     return "";
 }
@@ -343,11 +333,13 @@ export function removeDirectionOverrideChars(str: string): string {
 export function normalize(str: string): string {
     // Note: we have to match the filter with the removeHiddenChars() because the
     // function strips spaces and other characters (M becomes RN for example, in lowercase).
-    return removeHiddenChars(str.toLowerCase())
-        // Strip all punctuation
-        .replace(/[\\'!"#$%&()*+,\-./:;<=>?@[\]^_`{|}~\u2000-\u206f\u2e00-\u2e7f]/g, "")
-        // We also doubly convert to lowercase to work around oddities of the library.
-        .toLowerCase();
+    return (
+        removeHiddenChars(str.toLowerCase())
+            // Strip all punctuation
+            .replace(/[\\'!"#$%&()*+,\-./:;<=>?@[\]^_`{|}~\u2000-\u206f\u2e00-\u2e7f]/g, "")
+            // We also doubly convert to lowercase to work around oddities of the library.
+            .toLowerCase()
+    );
 }
 
 // Regex matching bunch of unicode control characters and otherwise misleading/invisible characters.
@@ -371,24 +363,20 @@ export function globToRegexp(glob: string, extended = false): string {
     // https://github.com/matrix-org/synapse/blob/abbee6b29be80a77e05730707602f3bbfc3f38cb/synapse/push/__init__.py#L132
     // Because micromatch is about 130KB with dependencies,
     // and minimatch is not much better.
-    const replacements: ([RegExp, string | ((substring: string, ...args: any[]) => string) ])[] = [
-        [/\\\*/g, '.*'],
-        [/\?/g, '.'],
+    const replacements: [RegExp, string | ((substring: string, ...args: any[]) => string)][] = [
+        [/\\\*/g, ".*"],
+        [/\?/g, "."],
     ];
     if (!extended) {
         replacements.push([
             /\\\[(!|)(.*)\\]/g,
-            (_match: string, neg: string, pat: string): string => [
-                '[',
-                neg ? '^' : '',
-                pat.replace(/\\-/, '-'),
-                ']',
-            ].join(''),
+            (_match: string, neg: string, pat: string): string =>
+                ["[", neg ? "^" : "", pat.replace(/\\-/, "-"), "]"].join(""),
         ]);
     }
     return replacements.reduce(
         // https://github.com/microsoft/TypeScript/issues/30134
-        (pat, args) => args ? pat.replace(args[0], args[1] as any) : pat,
+        (pat, args) => (args ? pat.replace(args[0], args[1] as any) : pat),
         escapeRegExp(glob),
     );
 }
@@ -406,9 +394,9 @@ export function ensureNoTrailingSlash(url?: string): string | undefined {
 
 // Returns a promise which resolves with a given value after the given number of ms
 export function sleep<T>(ms: number, value?: T): Promise<T> {
-    return new Promise((resolve => {
+    return new Promise((resolve) => {
         setTimeout(resolve, ms, value);
-    }));
+    });
 }
 
 export function isNullOrUndefined(val: any): boolean {
@@ -451,7 +439,7 @@ export function promiseTry<T>(fn: () => T | Promise<T>): Promise<T> {
 export async function chunkPromises<T>(fns: (() => Promise<T>)[], chunkSize: number): Promise<T[]> {
     const results: T[] = [];
     for (let i = 0; i < fns.length; i += chunkSize) {
-        results.push(...(await Promise.all(fns.slice(i, i + chunkSize).map(fn => fn()))));
+        results.push(...(await Promise.all(fns.slice(i, i + chunkSize).map((fn) => fn()))));
     }
     return results;
 }
@@ -466,14 +454,17 @@ export async function chunkPromises<T>(fns: (() => Promise<T>)[], chunkSize: num
  * @returns The promise for the retried operation.
  */
 export function simpleRetryOperation<T>(promiseFn: (attempt: number) => Promise<T>): Promise<T> {
-    return promiseRetry((attempt: number) => {
-        return promiseFn(attempt);
-    }, {
-        forever: true,
-        factor: 2,
-        minTimeout: 3000, // ms
-        maxTimeout: 15000, // ms
-    });
+    return promiseRetry(
+        (attempt: number) => {
+            return promiseFn(attempt);
+        },
+        {
+            forever: true,
+            factor: 2,
+            minTimeout: 3000, // ms
+            maxTimeout: 15000, // ms
+        },
+    );
 }
 
 // String averaging inspired by https://stackoverflow.com/a/2510816
@@ -487,7 +478,7 @@ export function simpleRetryOperation<T>(promiseFn: (attempt: number) => Promise<
  */
 export const DEFAULT_ALPHABET = ((): string => {
     let str = "";
-    for (let c = 0x20; c <= 0x7E; c++) {
+    for (let c = 0x20; c <= 0x7e; c++) {
         str += String.fromCharCode(c);
     }
     return str;
@@ -570,7 +561,7 @@ export function stringToBase(s: string, alphabet = DEFAULT_ALPHABET): bigint {
 
         // We add 1 to the char index to offset the whole numbering scheme. We unpack this in
         // the baseToString() function.
-        result += BigInt(1 + charIndex) * (len ** j);
+        result += BigInt(1 + charIndex) * len ** j;
     }
     return result;
 }
diff --git a/src/webrtc/call.ts b/src/webrtc/call.ts
index 0d1af81a369..e9276f44fc8 100644
--- a/src/webrtc/call.ts
+++ b/src/webrtc/call.ts
@@ -24,12 +24,12 @@ limitations under the License.
 import { v4 as uuidv4 } from "uuid";
 import { parse as parseSdp, write as writeSdp } from "sdp-transform";
 
-import { logger } from '../logger';
-import * as utils from '../utils';
-import { IContent, MatrixEvent } from '../models/event';
-import { EventType, ToDeviceMessageId } from '../@types/event';
-import { RoomMember } from '../models/room-member';
-import { randomString } from '../randomstring';
+import { logger } from "../logger";
+import * as utils from "../utils";
+import { IContent, MatrixEvent } from "../models/event";
+import { EventType, ToDeviceMessageId } from "../@types/event";
+import { RoomMember } from "../models/room-member";
+import { randomString } from "../randomstring";
 import {
     MCallReplacesEvent,
     MCallAnswer,
@@ -44,12 +44,12 @@ import {
     MCallCandidates,
     MCallBase,
     MCallHangupReject,
-} from './callEventTypes';
-import { CallFeed } from './callFeed';
+} from "./callEventTypes";
+import { CallFeed } from "./callFeed";
 import { MatrixClient } from "../client";
 import { EventEmitterEvents, TypedEventEmitter } from "../models/typed-event-emitter";
-import { DeviceInfo } from '../crypto/deviceinfo';
-import { GroupCallUnknownDeviceError } from './groupCall';
+import { DeviceInfo } from "../crypto/deviceinfo";
+import { GroupCallUnknownDeviceError } from "./groupCall";
 import { IScreensharingOpts } from "./mediaHandler";
 import { MatrixError } from "../http-api";
 
@@ -103,145 +103,145 @@ interface CodecParamsMod {
 }
 
 export enum CallState {
-    Fledgling = 'fledgling',
-    InviteSent = 'invite_sent',
-    WaitLocalMedia = 'wait_local_media',
-    CreateOffer = 'create_offer',
-    CreateAnswer = 'create_answer',
-    Connecting = 'connecting',
-    Connected = 'connected',
-    Ringing = 'ringing',
-    Ended = 'ended',
+    Fledgling = "fledgling",
+    InviteSent = "invite_sent",
+    WaitLocalMedia = "wait_local_media",
+    CreateOffer = "create_offer",
+    CreateAnswer = "create_answer",
+    Connecting = "connecting",
+    Connected = "connected",
+    Ringing = "ringing",
+    Ended = "ended",
 }
 
 export enum CallType {
-    Voice = 'voice',
-    Video = 'video',
+    Voice = "voice",
+    Video = "video",
 }
 
 export enum CallDirection {
-    Inbound = 'inbound',
-    Outbound = 'outbound',
+    Inbound = "inbound",
+    Outbound = "outbound",
 }
 
 export enum CallParty {
-    Local = 'local',
-    Remote = 'remote',
+    Local = "local",
+    Remote = "remote",
 }
 
 export enum CallEvent {
-    Hangup = 'hangup',
-    State = 'state',
-    Error = 'error',
-    Replaced = 'replaced',
+    Hangup = "hangup",
+    State = "state",
+    Error = "error",
+    Replaced = "replaced",
 
     // The value of isLocalOnHold() has changed
-    LocalHoldUnhold = 'local_hold_unhold',
+    LocalHoldUnhold = "local_hold_unhold",
     // The value of isRemoteOnHold() has changed
-    RemoteHoldUnhold = 'remote_hold_unhold',
+    RemoteHoldUnhold = "remote_hold_unhold",
     // backwards compat alias for LocalHoldUnhold: remove in a major version bump
-    HoldUnhold = 'hold_unhold',
+    HoldUnhold = "hold_unhold",
     // Feeds have changed
-    FeedsChanged = 'feeds_changed',
+    FeedsChanged = "feeds_changed",
 
-    AssertedIdentityChanged = 'asserted_identity_changed',
+    AssertedIdentityChanged = "asserted_identity_changed",
 
-    LengthChanged = 'length_changed',
+    LengthChanged = "length_changed",
 
-    DataChannel = 'datachannel',
+    DataChannel = "datachannel",
 
     SendVoipEvent = "send_voip_event",
 }
 
 export enum CallErrorCode {
     /** The user chose to end the call */
-    UserHangup = 'user_hangup',
+    UserHangup = "user_hangup",
 
     /** An error code when the local client failed to create an offer. */
-    LocalOfferFailed = 'local_offer_failed',
+    LocalOfferFailed = "local_offer_failed",
     /**
      * An error code when there is no local mic/camera to use. This may be because
      * the hardware isn't plugged in, or the user has explicitly denied access.
      */
-    NoUserMedia = 'no_user_media',
+    NoUserMedia = "no_user_media",
 
     /**
      * Error code used when a call event failed to send
      * because unknown devices were present in the room
      */
-    UnknownDevices = 'unknown_devices',
+    UnknownDevices = "unknown_devices",
 
     /**
      * Error code used when we fail to send the invite
      * for some reason other than there being unknown devices
      */
-    SendInvite = 'send_invite',
+    SendInvite = "send_invite",
 
     /**
      * An answer could not be created
      */
-    CreateAnswer = 'create_answer',
+    CreateAnswer = "create_answer",
 
     /**
      * An offer could not be created
      */
-    CreateOffer = 'create_offer',
+    CreateOffer = "create_offer",
 
     /**
      * Error code used when we fail to send the answer
      * for some reason other than there being unknown devices
      */
-    SendAnswer = 'send_answer',
+    SendAnswer = "send_answer",
 
     /**
      * The session description from the other side could not be set
      */
-    SetRemoteDescription = 'set_remote_description',
+    SetRemoteDescription = "set_remote_description",
 
     /**
      * The session description from this side could not be set
      */
-    SetLocalDescription = 'set_local_description',
+    SetLocalDescription = "set_local_description",
 
     /**
      * A different device answered the call
      */
-    AnsweredElsewhere = 'answered_elsewhere',
+    AnsweredElsewhere = "answered_elsewhere",
 
     /**
      * No media connection could be established to the other party
      */
-    IceFailed = 'ice_failed',
+    IceFailed = "ice_failed",
 
     /**
      * The invite timed out whilst waiting for an answer
      */
-    InviteTimeout = 'invite_timeout',
+    InviteTimeout = "invite_timeout",
 
     /**
      * The call was replaced by another call
      */
-    Replaced = 'replaced',
+    Replaced = "replaced",
 
     /**
      * Signalling for the call could not be sent (other than the initial invite)
      */
-    SignallingFailed = 'signalling_timeout',
+    SignallingFailed = "signalling_timeout",
 
     /**
      * The remote party is busy
      */
-    UserBusy = 'user_busy',
+    UserBusy = "user_busy",
 
     /**
      * We transferred the call off to somewhere else
      */
-    Transfered = 'transferred',
+    Transfered = "transferred",
 
     /**
      * A call from the same user was found with a new session id
      */
-    NewSession = 'new_session',
+    NewSession = "new_session",
 }
 
 /**
@@ -250,7 +250,7 @@ export enum CallErrorCode {
 const VOIP_PROTO_VERSION = "1";
 
 /** The fallback ICE server to use for STUN or TURN protocols. */
-const FALLBACK_ICE_SERVER = 'stun:turn.matrix.org';
+const FALLBACK_ICE_SERVER = "stun:turn.matrix.org";
 
 /** The length of time a call can be ringing for. */
 const CALL_TIMEOUT_MS = 60 * 1000; // ms
@@ -310,7 +310,7 @@ type TransceiverKey = string;
 // kind is unfortunately a string rather than MediaType as this is the type of
 // track.kind
 function getTransceiverKey(purpose: SDPStreamMetadataPurpose, kind: TransceiverKey): string {
-    return purpose + ':' + kind;
+    return purpose + ":" + kind;
 }
 
 export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap> {
@@ -480,9 +480,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     }
 
     public get type(): CallType {
-        return (this.hasLocalUserMediaVideoTrack || this.hasRemoteUserMediaVideoTrack)
-            ? CallType.Video
-            : CallType.Voice;
+        return this.hasLocalUserMediaVideoTrack || this.hasRemoteUserMediaVideoTrack ? CallType.Video : CallType.Voice;
     }
 
     public get hasLocalUserMediaVideoTrack(): boolean {
@@ -631,8 +629,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         const videoMuted = this.remoteSDPStreamMetadata![stream.id].video_muted;
 
         if (!purpose) {
-            logger.warn(`Call ${this.callId} Ignoring stream with id ${
-                stream.id} because we didn't get any metadata about it`);
+            logger.warn(
+                `Call ${this.callId} Ignoring stream with id ${stream.id} because we didn't get any metadata about it`,
+            );
             return;
         }
 
@@ -641,23 +640,25 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             return;
         }
 
-        this.feeds.push(new CallFeed({
-            client: this.client,
-            call: this,
-            roomId: this.roomId,
-            userId,
-            deviceId: this.getOpponentDeviceId(),
-            stream,
-            purpose,
-            audioMuted,
-            videoMuted,
-        }));
+        this.feeds.push(
+            new CallFeed({
+                client: this.client,
+                call: this,
+                roomId: this.roomId,
+                userId,
+                deviceId: this.getOpponentDeviceId(),
+                stream,
+                purpose,
+                audioMuted,
+                videoMuted,
+            }),
+        );
 
         this.emit(CallEvent.FeedsChanged, this.feeds);
 
         logger.info(
             `Call ${this.callId} pushed remote stream (id="${stream.id}", ` +
-            `active="${stream.active}", purpose=${purpose})`,
+                `active="${stream.active}", purpose=${purpose})`,
         );
     }
 
@@ -675,8 +676,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // status of streams change - Dave
         // If we already have a stream, check this stream has the same id
         if (oldRemoteStream && stream.id !== oldRemoteStream.id) {
-            logger.warn(`Call ${this.callId} Ignoring new stream ID ${
-                stream.id}: we already have stream ID ${oldRemoteStream.id}`);
+            logger.warn(
+                `Call ${this.callId} Ignoring new stream ID ${stream.id}: we already have stream ID ${oldRemoteStream.id}`,
+            );
             return;
         }
 
@@ -685,17 +687,19 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             return;
         }
 
-        this.feeds.push(new CallFeed({
-            client: this.client,
-            call: this,
-            roomId: this.roomId,
-            audioMuted: false,
-            videoMuted: false,
-            userId,
-            deviceId: this.getOpponentDeviceId(),
-            stream,
-            purpose,
-        }));
+        this.feeds.push(
+            new CallFeed({
+                client: this.client,
+                call: this,
+                roomId: this.roomId,
+                audioMuted: false,
+                videoMuted: false,
+                userId,
+                deviceId: this.getOpponentDeviceId(),
+                stream,
+                purpose,
+            }),
+        );
 
         this.emit(CallEvent.FeedsChanged, this.feeds);
 
@@ -748,13 +752,13 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             for (const track of callFeed.stream.getTracks()) {
                 logger.info(
                     `Call ${this.callId} ` +
-                    `Adding track (` +
-                    `id="${track.id}", ` +
-                    `kind="${track.kind}", ` +
-                    `streamId="${callFeed.stream.id}", ` +
-                    `streamPurpose="${callFeed.purpose}", ` +
-                    `enabled=${track.enabled}` +
-                    `) to peer connection`,
+                        `Adding track (` +
+                        `id="${track.id}", ` +
+                        `kind="${track.kind}", ` +
+                        `streamId="${callFeed.stream.id}", ` +
+                        `streamPurpose="${callFeed.purpose}", ` +
+                        `enabled=${track.enabled}` +
+                        `) to peer connection`,
                 );
 
                 const tKey = getTransceiverKey(callFeed.purpose, track.kind);
@@ -782,7 +786,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                     const newSender = this.peerConn!.addTrack(track, callFeed.stream);
 
                     // now go & fish for the new transceiver
-                    const newTransciever = this.peerConn!.getTransceivers().find(t => t.sender === newSender);
+                    const newTransciever = this.peerConn!.getTransceivers().find((t) => t.sender === newSender);
                     if (newTransciever) {
                         this.transceivers.set(tKey, newTransciever);
                     } else {
@@ -794,10 +798,10 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         logger.info(
             `Call ${this.callId} ` +
-            `Pushed local stream `+
-            `(id="${callFeed.stream.id}", `+
-            `active="${callFeed.stream.active}", `+
-            `purpose="${callFeed.purpose}")`,
+                `Pushed local stream ` +
+                `(id="${callFeed.stream.id}", ` +
+                `active="${callFeed.stream.active}", ` +
+                `purpose="${callFeed.purpose}")`,
         );
 
         this.emit(CallEvent.FeedsChanged, this.feeds);
@@ -871,7 +875,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         const statsReport = await this.peerConn.getStats();
         const stats: any[] = [];
-        statsReport.forEach(item => {
+        statsReport.forEach((item) => {
             stats.push(item);
         });
 
@@ -897,8 +901,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         if (sdpStreamMetadata) {
             this.updateRemoteSDPStreamMetadata(sdpStreamMetadata);
         } else {
-            logger.debug(`Call ${
-                this.callId} did not get any SDPStreamMetadata! Can not send/receive multiple streams`);
+            logger.debug(
+                `Call ${this.callId} did not get any SDPStreamMetadata! Can not send/receive multiple streams`,
+            );
         }
 
         this.peerConn = this.createPeerConnection();
@@ -937,7 +942,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                     this.hangupParty = CallParty.Remote; // effectively
                     this.state = CallState.Ended;
                     this.stopAllMedia();
-                    if (this.peerConn!.signalingState != 'closed') {
+                    if (this.peerConn!.signalingState != "closed") {
                         this.peerConn!.close();
                     }
                     this.emit(CallEvent.Hangup, this);
@@ -972,8 +977,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     ): boolean {
         if (wantedValue && !valueOfTheOtherSide) {
             // TODO: Figure out how to do this
-            logger.warn(`Call ${this.callId} Unable to answer with ${
-                type} because the other side isn't sending it either.`);
+            logger.warn(
+                `Call ${this.callId} Unable to answer with ${type} because the other side isn't sending it either.`,
+            );
             return false;
         } else if (
             !utils.isNullOrUndefined(wantedValue) &&
@@ -981,9 +987,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             !this.opponentSupportsSDPStreamMetadata()
         ) {
             logger.warn(
-                `Call ${this.callId} Unable to answer with ${type}=${
-                    wantedValue} because the other side doesn't support it. Answering with ${
-                    type}=${valueOfTheOtherSide}.`,
+                `Call ${this.callId} Unable to answer with ${type}=${wantedValue} because the other side doesn't support it. Answering with ${type}=${valueOfTheOtherSide}.`,
             );
             return valueOfTheOtherSide!;
         }
@@ -1007,9 +1011,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             this.waitForLocalAVStream = true;
 
             try {
-                const stream = await this.client.getMediaHandler().getUserMediaStream(
-                    answerWithAudio, answerWithVideo,
-                );
+                const stream = await this.client.getMediaHandler().getUserMediaStream(answerWithAudio, answerWithVideo);
                 this.waitForLocalAVStream = false;
                 const usermediaFeed = new CallFeed({
                     client: this.client,
@@ -1067,7 +1069,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 newCall.queueGotCallFeedsForAnswer([]);
             } else {
                 logger.debug(`Call ${this.callId} handing local stream to new call ${newCall.callId}`);
-                newCall.queueGotCallFeedsForAnswer(this.getLocalFeeds().map(feed => feed.clone()));
+                newCall.queueGotCallFeedsForAnswer(this.getLocalFeeds().map((feed) => feed.clone()));
             }
         }
         this.successor = newCall;
@@ -1107,8 +1109,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         if (this.opponentVersion === 0) {
             logger.info(
-                `Call ${this.callId} Opponent version is less than 1 (${
-                    this.opponentVersion}): sending hangup instead of reject`,
+                `Call ${this.callId} Opponent version is less than 1 (${this.opponentVersion}): sending hangup instead of reject`,
             );
             this.hangup(CallErrorCode.UserHangup, true);
             return;
@@ -1124,9 +1125,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      * @param audio - should add an audio track
      * @param video - should add an video track
      */
-    private async upgradeCall(
-        audio: boolean, video: boolean,
-    ): Promise<void> {
+    private async upgradeCall(audio: boolean, video: boolean): Promise<void> {
         // We don't do call downgrades
         if (!audio && !video) return;
         if (!this.opponentSupportsSDPStreamMetadata()) return;
@@ -1142,7 +1141,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             await this.updateLocalUsermediaStream(stream, audio, video);
         } catch (error) {
             logger.error(`Call ${this.callId} Failed to upgrade the call`, error);
-            this.emit(CallEvent.Error,
+            this.emit(
+                CallEvent.Error,
                 new CallError(CallErrorCode.NoUserMedia, "Failed to get camera access: ", <Error>error),
             );
         }
@@ -1197,12 +1197,12 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 return false;
             }
         } else {
-            const audioTransceiver = this.transceivers.get(getTransceiverKey(
-                SDPStreamMetadataPurpose.Screenshare, "audio",
-            ));
-            const videoTransceiver = this.transceivers.get(getTransceiverKey(
-                SDPStreamMetadataPurpose.Screenshare, "video",
-            ));
+            const audioTransceiver = this.transceivers.get(
+                getTransceiverKey(SDPStreamMetadataPurpose.Screenshare, "audio"),
+            );
+            const videoTransceiver = this.transceivers.get(
+                getTransceiverKey(SDPStreamMetadataPurpose.Screenshare, "video"),
+            );
 
             for (const transceiver of [audioTransceiver, videoTransceiver]) {
                 // this is slightly mixing the track and transceiver API but is basically just shorthand
@@ -1224,7 +1224,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      * @returns new screensharing state
      */
     private async setScreensharingEnabledWithoutMetadataSupport(
-        enabled: boolean, opts?: IScreensharingOpts,
+        enabled: boolean,
+        opts?: IScreensharingOpts,
     ): Promise<boolean> {
         logger.debug(`Call ${this.callId} Set screensharing enabled? ${enabled} using replaceTrack()`);
         if (enabled) {
@@ -1232,11 +1233,11 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 const stream = await this.client.getMediaHandler().getScreensharingStream(opts);
                 if (!stream) return false;
 
-                const track = stream.getTracks().find(track => track.kind === "video");
+                const track = stream.getTracks().find((track) => track.kind === "video");
 
-                const sender = this.transceivers.get(getTransceiverKey(
-                    SDPStreamMetadataPurpose.Usermedia, "video",
-                ))?.sender;
+                const sender = this.transceivers.get(
+                    getTransceiverKey(SDPStreamMetadataPurpose.Usermedia, "video"),
+                )?.sender;
 
                 sender?.replaceTrack(track ?? null);
 
@@ -1249,9 +1250,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             }
         } else {
             const track = this.localUsermediaStream?.getTracks().find((track) => track.kind === "video");
-            const sender = this.transceivers.get(getTransceiverKey(
-                SDPStreamMetadataPurpose.Usermedia, "video",
-            ))?.sender;
+            const sender = this.transceivers.get(
+                getTransceiverKey(SDPStreamMetadataPurpose.Usermedia, "video"),
+            )?.sender;
             sender?.replaceTrack(track ?? null);
 
             this.client.getMediaHandler().stopScreensharingStream(this.localScreensharingStream!);
@@ -1266,13 +1267,16 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      * @param stream - to use a replacement for the local usermedia stream
      */
     public async updateLocalUsermediaStream(
-        stream: MediaStream, forceAudio = false, forceVideo = false,
+        stream: MediaStream,
+        forceAudio = false,
+        forceVideo = false,
     ): Promise<void> {
         const callFeed = this.localUsermediaFeed!;
         const audioEnabled = forceAudio || (!callFeed.isAudioMuted() && !this.remoteOnHold);
         const videoEnabled = forceVideo || (!callFeed.isVideoMuted() && !this.remoteOnHold);
-        logger.log(`call ${this.callId} updateLocalUsermediaStream stream ${
-            stream.id} audioEnabled ${audioEnabled} videoEnabled ${videoEnabled}`);
+        logger.log(
+            `call ${this.callId} updateLocalUsermediaStream stream ${stream.id} audioEnabled ${audioEnabled} videoEnabled ${videoEnabled}`,
+        );
         setTracksEnabled(stream.getAudioTracks(), audioEnabled);
         setTracksEnabled(stream.getVideoTracks(), videoEnabled);
 
@@ -1293,13 +1297,13 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             if (oldSender) {
                 try {
                     logger.info(
-                        `Call ${this.callId} `+
-                        `Replacing track (` +
-                        `id="${track.id}", ` +
-                        `kind="${track.kind}", ` +
-                        `streamId="${stream.id}", ` +
-                        `streamPurpose="${callFeed.purpose}"` +
-                        `) to peer connection`,
+                        `Call ${this.callId} ` +
+                            `Replacing track (` +
+                            `id="${track.id}", ` +
+                            `kind="${track.kind}", ` +
+                            `streamId="${stream.id}", ` +
+                            `streamPurpose="${callFeed.purpose}"` +
+                            `) to peer connection`,
                     );
                     await oldSender.replaceTrack(track);
                     added = true;
@@ -1310,17 +1314,17 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
             if (!added) {
                 logger.info(
-                    `Call ${this.callId} `+
-                    `Adding track (` +
-                    `id="${track.id}", ` +
-                    `kind="${track.kind}", ` +
-                    `streamId="${stream.id}", ` +
-                    `streamPurpose="${callFeed.purpose}"` +
-                    `) to peer connection`,
+                    `Call ${this.callId} ` +
+                        `Adding track (` +
+                        `id="${track.id}", ` +
+                        `kind="${track.kind}", ` +
+                        `streamId="${stream.id}", ` +
+                        `streamPurpose="${callFeed.purpose}"` +
+                        `) to peer connection`,
                 );
 
                 const newSender = this.peerConn!.addTrack(track, this.localUsermediaStream!);
-                const newTransciever = this.peerConn!.getTransceivers().find(t => t.sender === newSender);
+                const newTransciever = this.peerConn!.getTransceivers().find((t) => t.sender === newSender);
                 if (newTransciever) {
                     this.transceivers.set(tKey, newTransciever);
                 } else {
@@ -1337,7 +1341,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      */
     public async setLocalVideoMuted(muted: boolean): Promise<boolean> {
         logger.log(`call ${this.callId} setLocalVideoMuted ${muted}`);
-        if (!await this.client.getMediaHandler().hasVideoDevice()) {
+        if (!(await this.client.getMediaHandler().hasVideoDevice())) {
             return this.isLocalVideoMuted();
         }
 
@@ -1371,7 +1375,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      */
     public async setMicrophoneMuted(muted: boolean): Promise<boolean> {
         logger.log(`call ${this.callId} setMicrophoneMuted ${muted}`);
-        if (!await this.client.getMediaHandler().hasAudioDevice()) {
+        if (!(await this.client.getMediaHandler().hasAudioDevice())) {
             return this.isMicrophoneMuted();
         }
 
@@ -1414,7 +1418,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             // We don't send hold music or anything so we're not actually
             // sending anything, but sendrecv is fairly standard for hold and
             // it makes it a lot easier to figure out who's put who on hold.
-            transceiver.direction = onHold ? 'sendonly' : 'sendrecv';
+            transceiver.direction = onHold ? "sendonly" : "sendrecv";
         }
         this.updateMuteStatus();
         this.sendMetadataUpdate();
@@ -1435,7 +1439,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // We consider a call to be on hold only if *all* the tracks are on hold
         // (is this the right thing to do?)
         for (const transceiver of this.peerConn!.getTransceivers()) {
-            const trackOnHold = ['inactive', 'recvonly'].includes(transceiver.currentDirection!);
+            const trackOnHold = ["inactive", "recvonly"].includes(transceiver.currentDirection!);
 
             if (!trackOnHold) callOnHold = false;
         }
@@ -1449,7 +1453,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
      */
     public sendDtmfDigit(digit: string): void {
         for (const sender of this.peerConn!.getSenders()) {
-            if (sender.track?.kind === 'audio' && sender.dtmf) {
+            if (sender.track?.kind === "audio" && sender.dtmf) {
                 sender.dtmf.insertDTMF(digit);
                 return;
             }
@@ -1462,8 +1466,11 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         const micShouldBeMuted = this.isMicrophoneMuted() || this.remoteOnHold;
         const vidShouldBeMuted = this.isLocalVideoMuted() || this.remoteOnHold;
 
-        logger.log(`call ${this.callId} updateMuteStatus stream ${this.localUsermediaStream!.id} micShouldBeMuted ${
-            micShouldBeMuted} vidShouldBeMuted ${vidShouldBeMuted}`);
+        logger.log(
+            `call ${this.callId} updateMuteStatus stream ${
+                this.localUsermediaStream!.id
+            } micShouldBeMuted ${micShouldBeMuted} vidShouldBeMuted ${vidShouldBeMuted}`,
+        );
         setTracksEnabled(this.localUsermediaStream!.getAudioTracks(), !micShouldBeMuted);
         setTracksEnabled(this.localUsermediaStream!.getVideoTracks(), !vidShouldBeMuted);
     }
@@ -1512,8 +1519,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         } as MCallAnswer;
 
         answerContent.capabilities = {
-            'm.call.transferee': this.client.supportsCallTransfer,
-            'm.call.dtmf': false,
+            "m.call.transferee": this.client.supportsCallTransfer,
+            "m.call.dtmf": false,
         };
 
         // We have just taken the local description from the peerConn which will
@@ -1534,7 +1541,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
             let code = CallErrorCode.SendAnswer;
             let message = "Failed to send answer";
-            if ((<Error>error).name == 'UnknownDeviceError') {
+            if ((<Error>error).name == "UnknownDeviceError") {
                 code = CallErrorCode.UnknownDevices;
                 message = "Unknown devices present in the room";
             }
@@ -1550,8 +1557,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     private queueGotCallFeedsForAnswer(callFeeds: CallFeed[]): void {
         // Ensure only one negotiate/answer event is being processed at a time.
         if (this.responsePromiseChain) {
-            this.responsePromiseChain =
-                this.responsePromiseChain.then(() => this.gotCallFeedsForAnswer(callFeeds));
+            this.responsePromiseChain = this.responsePromiseChain.then(() => this.gotCallFeedsForAnswer(callFeeds));
         } else {
             this.responsePromiseChain = this.gotCallFeedsForAnswer(callFeeds);
         }
@@ -1563,7 +1569,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // The only way to enable DTX at this time is through SDP munging
         const sdp = parseSdp(description.sdp!);
 
-        sdp.media.forEach(media => {
+        sdp.media.forEach((media) => {
             const payloadTypeToCodecMap = new Map<number, string>();
             const codecToPayloadTypeMap = new Map<string, number>();
             for (const rtp of media.rtp) {
@@ -1581,7 +1587,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
                 const extraconfig: string[] = [];
                 if (mod.enableDtx !== undefined) {
-                    extraconfig.push(`usedtx=${mod.enableDtx ? '1' : '0'}`);
+                    extraconfig.push(`usedtx=${mod.enableDtx ? "1" : "0"}`);
                 }
                 if (mod.maxAverageBitrate !== undefined) {
                     extraconfig.push(`maxaveragebitrate=${mod.maxAverageBitrate}`);
@@ -1647,7 +1653,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             this.state = CallState.Connecting;
 
             // Allow a short time for initial candidates to be gathered
-            await new Promise(resolve => {
+            await new Promise((resolve) => {
                 setTimeout(resolve, 200);
             });
 
@@ -1673,15 +1679,19 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             }
 
             logger.debug(
-                "Call " + this.callId + " got local ICE " + event.candidate.sdpMid + " candidate: " +
-                event.candidate.candidate,
+                "Call " +
+                    this.callId +
+                    " got local ICE " +
+                    event.candidate.sdpMid +
+                    " candidate: " +
+                    event.candidate.candidate,
             );
 
             if (this.callHasEnded()) return;
 
             // As with the offer, note we need to make a copy of this object, not
             // pass the original: that broke in Chrome ~m43.
-            if (event.candidate.candidate === '') {
+            if (event.candidate.candidate === "") {
                 this.queueCandidate(null);
             } else {
                 this.queueCandidate(event.candidate);
@@ -1691,7 +1701,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     private onIceGatheringStateChange = (event: Event): void => {
         logger.debug(`Call ${this.callId} ice gathering state changed to  ${this.peerConn!.iceGatheringState}`);
-        if (this.peerConn?.iceGatheringState === 'complete') {
+        if (this.peerConn?.iceGatheringState === "complete") {
             this.queueCandidate(null);
         }
     };
@@ -1724,9 +1734,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         if (!this.partyIdMatches(content)) {
             logger.info(
-                `Call ${this.callId} `+
-                `Ignoring candidates from party ID ${content.party_id}: ` +
-                `we have chosen party ID ${this.opponentPartyId}`,
+                `Call ${this.callId} ` +
+                    `Ignoring candidates from party ID ${content.party_id}: ` +
+                    `we have chosen party ID ${this.opponentPartyId}`,
             );
 
             return;
@@ -1750,8 +1760,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         if (this.opponentPartyId !== undefined) {
             logger.info(
                 `Call ${this.callId} ` +
-                `Ignoring answer from party ID ${content.party_id}: ` +
-                `we already have an answer/reject from ${this.opponentPartyId}`,
+                    `Ignoring answer from party ID ${content.party_id}: ` +
+                    `we already have an answer/reject from ${this.opponentPartyId}`,
             );
             return;
         }
@@ -1801,14 +1811,16 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         const selectedPartyId = event.getContent<MCallSelectAnswer>().selected_party_id;
 
         if (selectedPartyId === undefined || selectedPartyId === null) {
-            logger.warn(`Call ${
-                this.callId} Got nonsensical select_answer with null/undefined selected_party_id: ignoring`);
+            logger.warn(
+                `Call ${this.callId} Got nonsensical select_answer with null/undefined selected_party_id: ignoring`,
+            );
             return;
         }
 
         if (selectedPartyId !== this.ourPartyId) {
-            logger.info(`Call ${this.callId} Got select_answer for party ID ${
-                selectedPartyId}: we are party ID ${this.ourPartyId}.`);
+            logger.info(
+                `Call ${this.callId} Got select_answer for party ID ${selectedPartyId}: we are party ID ${this.ourPartyId}.`,
+            );
             // The other party has picked somebody else's answer
             await this.terminate(CallParty.Remote, CallErrorCode.AnsweredElsewhere, true);
         }
@@ -1828,10 +1840,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         // Here we follow the perfect negotiation logic from
         // https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Perfect_negotiation
-        const offerCollision = (
-            (description.type === 'offer') &&
-            (this.makingOffer || this.peerConn!.signalingState !== 'stable')
-        );
+        const offerCollision =
+            description.type === "offer" && (this.makingOffer || this.peerConn!.signalingState !== "stable");
 
         this.ignoreOffer = !polite && offerCollision;
         if (this.ignoreOffer) {
@@ -1851,7 +1861,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         try {
             await this.peerConn!.setRemoteDescription(description);
 
-            if (description.type === 'offer') {
+            if (description.type === "offer") {
                 let answer: RTCSessionDescriptionInit;
                 try {
                     this.getRidOfRTXCodecs();
@@ -1919,8 +1929,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     private queueGotLocalOffer(): void {
         // Ensure only one negotiate/answer event is being processed at a time.
         if (this.responsePromiseChain) {
-            this.responsePromiseChain =
-                this.responsePromiseChain.then(() => this.wrappedGotLocalOffer());
+            this.responsePromiseChain = this.responsePromiseChain.then(() => this.wrappedGotLocalOffer());
         } else {
             this.responsePromiseChain = this.wrappedGotLocalOffer();
         }
@@ -1942,8 +1951,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         logger.debug(`Call ${this.callId} Setting local description`);
 
         if (this.callHasEnded()) {
-            logger.debug("Ignoring newly created offer on call ID " + this.callId +
-                " because the call has ended");
+            logger.debug("Ignoring newly created offer on call ID " + this.callId + " because the call has ended");
             return;
         }
 
@@ -1965,9 +1973,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             return;
         }
 
-        if (this.peerConn!.iceGatheringState === 'gathering') {
+        if (this.peerConn!.iceGatheringState === "gathering") {
             // Allow a short time for initial candidates to be gathered
-            await new Promise(resolve => {
+            await new Promise((resolve) => {
                 setTimeout(resolve, 200);
             });
         }
@@ -1992,8 +2000,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         }
 
         content.capabilities = {
-            'm.call.transferee': this.client.supportsCallTransfer,
-            'm.call.dtmf': false,
+            "m.call.transferee": this.client.supportsCallTransfer,
+            "m.call.dtmf": false,
         };
 
         content[SDPStreamMetadataKey] = this.getLocalSDPStreamMetadata(true);
@@ -2015,7 +2023,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 code = CallErrorCode.SendInvite;
                 message = "Failed to send invite";
             }
-            if ((<Error>error).name == 'UnknownDeviceError') {
+            if ((<Error>error).name == "UnknownDeviceError") {
                 code = CallErrorCode.UnknownDevices;
                 message = "Unknown devices present in the room";
             }
@@ -2044,13 +2052,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
     private getLocalOfferFailed = (err: Error): void => {
         logger.error(`Call ${this.callId} Failed to get local offer`, err);
 
-        this.emit(
-            CallEvent.Error,
-            new CallError(
-                CallErrorCode.LocalOfferFailed,
-                "Failed to get local offer!", err,
-            ),
-        );
+        this.emit(CallEvent.Error, new CallError(CallErrorCode.LocalOfferFailed, "Failed to get local offer!", err));
         this.terminate(CallParty.Local, CallErrorCode.LocalOfferFailed, false);
     };
 
@@ -2066,8 +2068,8 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             CallEvent.Error,
             new CallError(
                 CallErrorCode.NoUserMedia,
-                "Couldn't start capturing media! Is your microphone set up and " +
-                "does this app have permission?", err,
+                "Couldn't start capturing media! Is your microphone set up and " + "does this app have permission?",
+                err,
             ),
         );
         this.terminate(CallParty.Local, CallErrorCode.NoUserMedia, false);
@@ -2083,7 +2085,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
         // ideally we'd consider the call to be connected when we get media but
         // chrome doesn't implement any of the 'onstarted' events yet
-        if (["connected", "completed"].includes(this.peerConn?.iceConnectionState ?? '')) {
+        if (["connected", "completed"].includes(this.peerConn?.iceConnectionState ?? "")) {
             clearTimeout(this.iceDisconnectedTimeout);
             this.state = CallState.Connected;
 
@@ -2094,7 +2096,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                     this.emit(CallEvent.LengthChanged, Math.round((Date.now() - this.callStartTime!) / 1000));
                 }, CALL_LENGTH_INTERVAL);
             }
-        } else if (this.peerConn?.iceConnectionState == 'failed') {
+        } else if (this.peerConn?.iceConnectionState == "failed") {
             // Firefox for Android does not yet have support for restartIce()
             // (the types say it's always defined though, so we have to cast
             // to prevent typescript from warning).
@@ -2105,7 +2107,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 logger.info(`Hanging up call ${this.callId} (ICE failed and no ICE restart method)`);
                 this.hangup(CallErrorCode.IceFailed, false);
             }
-        } else if (this.peerConn?.iceConnectionState == 'disconnected') {
+        } else if (this.peerConn?.iceConnectionState == "disconnected") {
             this.iceDisconnectedTimeout = setTimeout(() => {
                 logger.info(`Hanging up call ${this.callId} (ICE disconnected for too long)`);
                 this.hangup(CallErrorCode.IceFailed, false);
@@ -2183,9 +2185,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             }
         }
 
-        const screenshareVideoTransceiver = this.transceivers.get(getTransceiverKey(
-            SDPStreamMetadataPurpose.Screenshare, "video",
-        ));
+        const screenshareVideoTransceiver = this.transceivers.get(
+            getTransceiverKey(SDPStreamMetadataPurpose.Screenshare, "video"),
+        );
         if (screenshareVideoTransceiver) screenshareVideoTransceiver.setCodecPreferences(codecs);
     }
 
@@ -2193,8 +2195,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         logger.info(`Call ${this.callId} Negotiation is needed!`);
 
         if (this.state !== CallState.CreateOffer && this.opponentVersion === 0) {
-            logger.info(`Call ${
-                this.callId} Opponent does not support renegotiation: ignoring negotiationneeded event`);
+            logger.info(
+                `Call ${this.callId} Opponent does not support renegotiation: ignoring negotiationneeded event`,
+            );
             return;
         }
 
@@ -2210,8 +2213,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             // default reason is user_hangup
             this.terminate(CallParty.Remote, msg.reason || CallErrorCode.UserHangup, true);
         } else {
-            logger.info(`Call ${this.callId} Ignoring message from party ID ${
-                msg.party_id}: our partner is ${this.opponentPartyId}`);
+            logger.info(
+                `Call ${this.callId} Ignoring message from party ID ${msg.party_id}: our partner is ${this.opponentPartyId}`,
+            );
         }
     };
 
@@ -2221,14 +2225,13 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         // No need to check party_id for reject because if we'd received either
         // an answer or reject, we wouldn't be in state InviteSent
 
-        const shouldTerminate = (
+        const shouldTerminate =
             // reject events also end the call if it's ringing: it's another of
             // our devices rejecting the call.
             [CallState.InviteSent, CallState.Ringing].includes(this.state) ||
             // also if we're in the init state and it's an inbound call, since
             // this means we just haven't entered the ringing state yet
-            (this.state === CallState.Fledgling && this.direction === CallDirection.Inbound)
-        );
+            (this.state === CallState.Fledgling && this.direction === CallDirection.Inbound);
 
         if (shouldTerminate) {
             this.terminate(CallParty.Remote, msg.reason || CallErrorCode.UserHangup, true);
@@ -2274,13 +2277,18 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
             const userId = this.invitee || this.getOpponentMember()!.userId;
             if (this.client.getUseE2eForGroupCall()) {
-                await this.client.encryptAndSendToDevices([{
-                    userId,
-                    deviceInfo: this.opponentDeviceInfo!,
-                }], {
-                    type: eventType,
-                    content,
-                });
+                await this.client.encryptAndSendToDevices(
+                    [
+                        {
+                            userId,
+                            deviceInfo: this.opponentDeviceInfo!,
+                        },
+                    ],
+                    {
+                        type: eventType,
+                        content,
+                    },
+                );
             } else {
                 await this.client.sendToDevice(eventType, {
                     [userId]: {
@@ -2456,7 +2464,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         this.stopAllMedia();
         this.deleteAllFeeds();
 
-        if (this.peerConn && this.peerConn.signalingState !== 'closed') {
+        if (this.peerConn && this.peerConn.signalingState !== "closed") {
             this.peerConn.close();
         }
         if (shouldEmit) {
@@ -2468,22 +2476,15 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     private stopAllMedia(): void {
         logger.debug(
-            !this.groupCallId ?
-                `Call ${this.callId} stopping all media` :
-                `Call ${this.callId} stopping all media except local feeds`);
+            !this.groupCallId
+                ? `Call ${this.callId} stopping all media`
+                : `Call ${this.callId} stopping all media except local feeds`,
+        );
 
         for (const feed of this.feeds) {
-            if (
-                feed.isLocal() &&
-                feed.purpose === SDPStreamMetadataPurpose.Usermedia &&
-                !this.groupCallId
-            ) {
+            if (feed.isLocal() && feed.purpose === SDPStreamMetadataPurpose.Usermedia && !this.groupCallId) {
                 this.client.getMediaHandler().stopUserMediaStream(feed.stream);
-            } else if (
-                feed.isLocal() &&
-                feed.purpose === SDPStreamMetadataPurpose.Screenshare &&
-                !this.groupCallId
-            ) {
+            } else if (feed.isLocal() && feed.purpose === SDPStreamMetadataPurpose.Screenshare && !this.groupCallId) {
                 this.client.getMediaHandler().stopScreensharingStream(feed.stream);
             } else if (!feed.isLocal() || !this.groupCallId) {
                 logger.debug("Stopping remote stream", feed.stream.id);
@@ -2496,9 +2497,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     private checkForErrorListener(): void {
         if (this.listeners(EventEmitterEvents.Error).length === 0) {
-            throw new Error(
-                "You MUST attach an error listener using call.on('error', function() {})",
-            );
+            throw new Error("You MUST attach an error listener using call.on('error', function() {})");
         }
     }
 
@@ -2510,11 +2509,11 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
         const candidates = this.candidateSendQueue;
         this.candidateSendQueue = [];
         ++this.candidateSendTries;
-        const content = { candidates: candidates.map(candidate => candidate.toJSON()) };
+        const content = { candidates: candidates.map((candidate) => candidate.toJSON()) };
         if (this.candidatesEnded) {
             // If there are no more candidates, signal this by adding an empty string candidate
             content.candidates.push({
-                candidate: '',
+                candidate: "",
             });
         }
         logger.debug(`Call ${this.callId} attempting to send ${candidates.length} candidates`);
@@ -2536,8 +2535,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
             if (this.candidateSendTries > 5) {
                 logger.debug(
-                    `Call ${this.callId} failed to send candidates on attempt ${
-                        this.candidateSendTries}. Giving up on this call.`,
+                    `Call ${this.callId} failed to send candidates on attempt ${this.candidateSendTries}. Giving up on this call.`,
                     error,
                 );
 
@@ -2625,20 +2623,20 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
 
     private createPeerConnection(): RTCPeerConnection {
         const pc = new window.RTCPeerConnection({
-            iceTransportPolicy: this.forceTURN ? 'relay' : undefined,
+            iceTransportPolicy: this.forceTURN ? "relay" : undefined,
             iceServers: this.turnServers,
             iceCandidatePoolSize: this.client.iceCandidatePoolSize,
-            bundlePolicy: 'max-bundle',
+            bundlePolicy: "max-bundle",
         });
 
         // 'connectionstatechange' would be better, but firefox doesn't implement that.
-        pc.addEventListener('iceconnectionstatechange', this.onIceConnectionStateChanged);
-        pc.addEventListener('signalingstatechange', this.onSignallingStateChanged);
-        pc.addEventListener('icecandidate', this.gotLocalIceCandidate);
-        pc.addEventListener('icegatheringstatechange', this.onIceGatheringStateChange);
-        pc.addEventListener('track', this.onTrack);
-        pc.addEventListener('negotiationneeded', this.onNegotiationNeeded);
-        pc.addEventListener('datachannel', this.onDataChannel);
+        pc.addEventListener("iceconnectionstatechange", this.onIceConnectionStateChanged);
+        pc.addEventListener("signalingstatechange", this.onSignallingStateChanged);
+        pc.addEventListener("icecandidate", this.gotLocalIceCandidate);
+        pc.addEventListener("icegatheringstatechange", this.onIceGatheringStateChange);
+        pc.addEventListener("track", this.onTrack);
+        pc.addEventListener("negotiationneeded", this.onNegotiationNeeded);
+        pc.addEventListener("datachannel", this.onDataChannel);
 
         return pc;
     }
@@ -2671,15 +2669,16 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             // party ID
             this.opponentPartyId = msg.party_id || null;
         }
-        this.opponentCaps = msg.capabilities || {} as CallCapabilities;
+        this.opponentCaps = msg.capabilities || ({} as CallCapabilities);
         this.opponentMember = this.client.getRoom(this.roomId)!.getMember(ev.getSender()!) ?? undefined;
     }
 
     private async addBufferedIceCandidates(): Promise<void> {
         const bufferedCandidates = this.remoteCandidateBuffer.get(this.opponentPartyId!);
         if (bufferedCandidates) {
-            logger.info(`Call ${this.callId} Adding ${
-                bufferedCandidates.length} buffered candidates for opponent ${this.opponentPartyId}`);
+            logger.info(
+                `Call ${this.callId} Adding ${bufferedCandidates.length} buffered candidates for opponent ${this.opponentPartyId}`,
+            );
             await this.addIceCandidates(bufferedCandidates);
         }
         this.remoteCandidateBuffer.clear();
@@ -2693,8 +2692,9 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
             ) {
                 logger.debug(`Call ${this.callId} got remote ICE end-of-candidates`);
             } else {
-                logger.debug(`Call ${this.callId} got remote ICE ${
-                    candidate.sdpMid} candidate: ${candidate.candidate}`);
+                logger.debug(
+                    `Call ${this.callId} got remote ICE ${candidate.sdpMid} candidate: ${candidate.candidate}`,
+                );
             }
 
             try {
@@ -2720,7 +2720,7 @@ export function setTracksEnabled(tracks: Array<MediaStreamTrack>, enabled: boole
 
 export function supportsMatrixCall(): boolean {
     // typeof prevents Node from erroring on an undefined reference
-    if (typeof(window) === 'undefined' || typeof(document) === 'undefined') {
+    if (typeof window === "undefined" || typeof document === "undefined") {
         // NB. We don't log here as apps try to create a call object as a test for
         // whether calls are supported, so we shouldn't fill the logs up.
         return false;
@@ -2731,8 +2731,10 @@ export function supportsMatrixCall(): boolean {
     // is that the browser throwing a SecurityError will brick the client creation process.
     try {
         const supported = Boolean(
-            window.RTCPeerConnection || window.RTCSessionDescription ||
-            window.RTCIceCandidate || navigator.mediaDevices,
+            window.RTCPeerConnection ||
+                window.RTCSessionDescription ||
+                window.RTCIceCandidate ||
+                navigator.mediaDevices,
         );
         if (!supported) {
             /* istanbul ignore if */ // Adds a lot of noise to test runs, so disable logging there.
diff --git a/src/webrtc/callEventHandler.ts b/src/webrtc/callEventHandler.ts
index 281b29b0e65..cb027349957 100644
--- a/src/webrtc/callEventHandler.ts
+++ b/src/webrtc/callEventHandler.ts
@@ -14,13 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MatrixEvent } from '../models/event';
-import { logger } from '../logger';
-import { CallDirection, CallError, CallErrorCode, CallState, createNewMatrixCall, MatrixCall } from './call';
-import { EventType } from '../@types/event';
-import { ClientEvent, MatrixClient } from '../client';
+import { MatrixEvent } from "../models/event";
+import { logger } from "../logger";
+import { CallDirection, CallError, CallErrorCode, CallState, createNewMatrixCall, MatrixCall } from "./call";
+import { EventType } from "../@types/event";
+import { ClientEvent, MatrixClient } from "../client";
 import { MCallAnswer, MCallHangupReject } from "./callEventTypes";
-import { GroupCall, GroupCallErrorCode, GroupCallEvent, GroupCallUnknownDeviceError } from './groupCall';
+import { GroupCall, GroupCallErrorCode, GroupCallEvent, GroupCallUnknownDeviceError } from "./groupCall";
 import { RoomEvent } from "../models/room";
 
 // Don't ring unless we'd be ringing for at least 3 seconds: the user needs some
@@ -90,8 +90,9 @@ export class CallEventHandler {
 
         // Ensure correct ordering by only processing this queue after the previous one has finished processing
         if (this.eventBufferPromiseChain) {
-            this.eventBufferPromiseChain =
-                this.eventBufferPromiseChain.then(() => this.evaluateEventBuffer(currentEventBuffer));
+            this.eventBufferPromiseChain = this.eventBufferPromiseChain.then(() =>
+                this.evaluateEventBuffer(currentEventBuffer),
+            );
         } else {
             this.eventBufferPromiseChain = this.evaluateEventBuffer(currentEventBuffer);
         }
@@ -112,7 +113,7 @@ export class CallEventHandler {
         for (const event of callEvents) {
             const eventType = event.getType();
 
-            if (eventType=== EventType.CallAnswer || eventType === EventType.CallHangup) {
+            if (eventType === EventType.CallAnswer || eventType === EventType.CallHangup) {
                 ignoreCallIds.add(event.getContent().call_id);
             }
         }
@@ -192,10 +193,8 @@ export class CallEventHandler {
         this.client.emit(ClientEvent.ReceivedVoipEvent, event);
 
         const content = event.getContent();
-        const callRoomId = (
-            event.getRoomId() ||
-            this.client.groupCallEventHandler!.getGroupCallById(content.conf_id)?.room?.roomId
-        );
+        const callRoomId =
+            event.getRoomId() || this.client.groupCallEventHandler!.getGroupCallById(content.conf_id)?.room?.roomId;
         const groupCallId = content.conf_id;
         const type = event.getType() as EventType;
         const senderId = event.getSender()!;
@@ -216,10 +215,7 @@ export class CallEventHandler {
 
             if (!opponentDeviceId) {
                 logger.warn(`Cannot find a device id for ${senderId}. Ignoring event.`);
-                groupCall.emit(
-                    GroupCallEvent.Error,
-                    new GroupCallUnknownDeviceError(senderId),
-                );
+                groupCall.emit(GroupCallEvent.Error, new GroupCallUnknownDeviceError(senderId));
                 return;
             }
 
@@ -229,8 +225,9 @@ export class CallEventHandler {
             }
         }
 
-        const weSentTheEvent = senderId === this.client.credentials.userId
-            && (opponentDeviceId === undefined || opponentDeviceId === this.client.getDeviceId()!);
+        const weSentTheEvent =
+            senderId === this.client.credentials.userId &&
+            (opponentDeviceId === undefined || opponentDeviceId === this.client.getDeviceId()!);
 
         if (!callRoomId) return;
 
@@ -244,8 +241,7 @@ export class CallEventHandler {
 
             if (call) {
                 logger.log(
-                    `WARN: Already have a MatrixCall with id ${content.call_id} but got an ` +
-                    `invite. Clobbering.`,
+                    `WARN: Already have a MatrixCall with id ${content.call_id} but got an ` + `invite. Clobbering.`,
                 );
             }
 
@@ -255,20 +251,15 @@ export class CallEventHandler {
 
             const timeUntilTurnCresExpire = (this.client.getTurnServersExpiry() ?? 0) - Date.now();
             logger.info("Current turn creds expire in " + timeUntilTurnCresExpire + " ms");
-            call = createNewMatrixCall(
-                this.client,
-                callRoomId,
-                {
-                    forceTURN: this.client.forceTURN, opponentDeviceId,
+            call =
+                createNewMatrixCall(this.client, callRoomId, {
+                    forceTURN: this.client.forceTURN,
+                    opponentDeviceId,
                     groupCallId,
                     opponentSessionId: content.sender_session_id,
-                },
-            ) ?? undefined;
+                }) ?? undefined;
             if (!call) {
-                logger.log(
-                    "Incoming call ID " + content.call_id + " but this client " +
-                    "doesn't support WebRTC",
-                );
+                logger.log("Incoming call ID " + content.call_id + " but this client " + "doesn't support WebRTC");
                 // don't hang up the call: there could be other clients
                 // connected that do support WebRTC and declining the
                 // the call on their behalf would be really annoying.
@@ -317,14 +308,18 @@ export class CallEventHandler {
             if (existingCall) {
                 if (existingCall.callId > call.callId) {
                     logger.log(
-                        "Glare detected: answering incoming call " + call.callId +
-                        " and canceling outgoing call " + existingCall.callId,
+                        "Glare detected: answering incoming call " +
+                            call.callId +
+                            " and canceling outgoing call " +
+                            existingCall.callId,
                     );
                     existingCall.replacedBy(call);
                 } else {
                     logger.log(
-                        "Glare detected: rejecting incoming call " + call.callId +
-                        " and keeping outgoing call " + existingCall.callId,
+                        "Glare detected: rejecting incoming call " +
+                            call.callId +
+                            " and keeping outgoing call " +
+                            existingCall.callId,
                     );
                     call.hangup(CallErrorCode.Replaced, true);
                 }
@@ -352,14 +347,11 @@ export class CallEventHandler {
                 // if not live, store the fact that the call has ended because
                 // we're probably getting events backwards so
                 // the hangup will come before the invite
-                call = createNewMatrixCall(
-                    this.client,
-                    callRoomId,
-                    {
+                call =
+                    createNewMatrixCall(this.client, callRoomId, {
                         opponentDeviceId,
                         opponentSessionId: content.sender_session_id,
-                    },
-                ) ?? undefined;
+                    }) ?? undefined;
                 if (call) {
                     call.callId = content.call_id;
                     call.initWithHangup(event);
diff --git a/src/webrtc/callEventTypes.ts b/src/webrtc/callEventTypes.ts
index 4f43a70a1d5..f06ed5b0db7 100644
--- a/src/webrtc/callEventTypes.ts
+++ b/src/webrtc/callEventTypes.ts
@@ -22,8 +22,8 @@ export interface SDPStreamMetadata {
 }
 
 export interface CallCapabilities {
-    'm.call.transferee': boolean;
-    'm.call.dtmf': boolean;
+    "m.call.transferee": boolean;
+    "m.call.dtmf": boolean;
 }
 
 export interface CallReplacesTarget {
diff --git a/src/webrtc/callFeed.ts b/src/webrtc/callFeed.ts
index 3ed84a58620..fa02775d033 100644
--- a/src/webrtc/callFeed.ts
+++ b/src/webrtc/callFeed.ts
@@ -192,8 +192,10 @@ export class CallFeed extends TypedEventEmitter<CallFeedEvent, EventHandlerMap>
      * @returns is local?
      */
     public isLocal(): boolean {
-        return this.userId === this.client.getUserId()
-            && (this.deviceId === undefined || this.deviceId === this.client.getDeviceId());
+        return (
+            this.userId === this.client.getUserId() &&
+            (this.deviceId === undefined || this.deviceId === this.client.getDeviceId())
+        );
     }
 
     /**
diff --git a/src/webrtc/groupCall.ts b/src/webrtc/groupCall.ts
index 58281b0e9eb..34a35e5a686 100644
--- a/src/webrtc/groupCall.ts
+++ b/src/webrtc/groupCall.ts
@@ -59,7 +59,9 @@ export type GroupCallEventHandlerMap = {
     [GroupCallEvent.UserMediaFeedsChanged]: (feeds: CallFeed[]) => void;
     [GroupCallEvent.ScreenshareFeedsChanged]: (feeds: CallFeed[]) => void;
     [GroupCallEvent.LocalScreenshareStateChanged]: (
-        isScreensharing: boolean, feed?: CallFeed, sourceId?: string,
+        isScreensharing: boolean,
+        feed?: CallFeed,
+        sourceId?: string,
     ) => void;
     [GroupCallEvent.LocalMuteStateChanged]: (audioMuted: boolean, videoMuted: boolean) => void;
     [GroupCallEvent.ParticipantsChanged]: (participants: Map<RoomMember, Map<string, ParticipantState>>) => void;
@@ -84,7 +86,7 @@ export type GroupCallEventHandlerMap = {
 export enum GroupCallErrorCode {
     NoUserMedia = "no_user_media",
     UnknownDevice = "unknown_device",
-    PlaceCallFailed = "place_call_failed"
+    PlaceCallFailed = "place_call_failed",
 }
 
 export class GroupCallError extends Error {
@@ -135,10 +137,10 @@ export interface IGroupCallRoomMemberFeed {
 }
 
 export interface IGroupCallRoomMemberDevice {
-    "device_id": string;
-    "session_id": string;
-    "expires_ts": number;
-    "feeds": IGroupCallRoomMemberFeed[];
+    device_id: string;
+    session_id: string;
+    expires_ts: number;
+    feeds: IGroupCallRoomMemberFeed[];
 }
 
 export interface IGroupCallRoomMemberCallState {
@@ -220,9 +222,8 @@ export class GroupCall extends TypedEventEmitter<
         super();
         this.reEmitter = new ReEmitter(this);
         this.groupCallId = groupCallId ?? genCallID();
-        this.creationTs = room.currentState.getStateEvents(
-            EventType.GroupCallPrefix, this.groupCallId,
-        )?.getTs() ?? null;
+        this.creationTs =
+            room.currentState.getStateEvents(EventType.GroupCallPrefix, this.groupCallId)?.getTs() ?? null;
         this.updateParticipants();
 
         room.on(RoomStateEvent.Update, this.onRoomState);
@@ -245,12 +246,7 @@ export class GroupCall extends TypedEventEmitter<
             "dataChannelOptions": this.dataChannelsEnabled ? this.dataChannelOptions : undefined,
         };
 
-        await this.client.sendStateEvent(
-            this.room.roomId,
-            EventType.GroupCallPrefix,
-            groupCallState,
-            this.groupCallId,
-        );
+        await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallPrefix, groupCallState, this.groupCallId);
 
         return this;
     }
@@ -345,9 +341,10 @@ export class GroupCall extends TypedEventEmitter<
     }
 
     public hasLocalParticipant(): boolean {
-        return this.participants.get(
-            this.room.getMember(this.client.getUserId()!)!,
-        )?.has(this.client.getDeviceId()!) ?? false;
+        return (
+            this.participants.get(this.room.getMember(this.client.getUserId()!)!)?.has(this.client.getDeviceId()!) ??
+            false
+        );
     }
 
     public async initLocalCallFeed(): Promise<CallFeed> {
@@ -409,9 +406,9 @@ export class GroupCall extends TypedEventEmitter<
             this.localCallFeed.setNewStream(stream);
             const micShouldBeMuted = this.localCallFeed.isAudioMuted();
             const vidShouldBeMuted = this.localCallFeed.isVideoMuted();
-            logger.log(`groupCall ${this.groupCallId} updateLocalUsermediaStream oldStream ${
-                oldStream.id} newStream ${stream.id} micShouldBeMuted ${
-                micShouldBeMuted} vidShouldBeMuted ${vidShouldBeMuted}`);
+            logger.log(
+                `groupCall ${this.groupCallId} updateLocalUsermediaStream oldStream ${oldStream.id} newStream ${stream.id} micShouldBeMuted ${micShouldBeMuted} vidShouldBeMuted ${vidShouldBeMuted}`,
+            );
             setTracksEnabled(stream.getAudioTracks(), !micShouldBeMuted);
             setTracksEnabled(stream.getVideoTracks(), !vidShouldBeMuted);
             this.client.getMediaHandler().stopUserMediaStream(oldStream);
@@ -438,10 +435,7 @@ export class GroupCall extends TypedEventEmitter<
 
         this.activeSpeaker = undefined;
         this.onActiveSpeakerLoop();
-        this.activeSpeakerLoopInterval = setInterval(
-            this.onActiveSpeakerLoop,
-            this.activeSpeakerInterval,
-        );
+        this.activeSpeakerLoopInterval = setInterval(this.onActiveSpeakerLoop, this.activeSpeakerInterval);
     }
 
     private dispose(): void {
@@ -473,7 +467,7 @@ export class GroupCall extends TypedEventEmitter<
             return;
         }
 
-        this.forEachCall(call => this.disposeCall(call, CallErrorCode.UserHangup));
+        this.forEachCall((call) => this.disposeCall(call, CallErrorCode.UserHangup));
         this.calls.clear();
 
         this.activeSpeaker = undefined;
@@ -500,7 +494,8 @@ export class GroupCall extends TypedEventEmitter<
 
         if (emitStateEvent) {
             const existingStateEvent = this.room.currentState.getStateEvents(
-                EventType.GroupCallPrefix, this.groupCallId,
+                EventType.GroupCallPrefix,
+                this.groupCallId,
             )!;
 
             await this.client.sendStateEvent(
@@ -544,7 +539,7 @@ export class GroupCall extends TypedEventEmitter<
         // hasAudioDevice can block indefinitely if the window has lost focus,
         // and it doesn't make much sense to keep a device from being muted, so
         // we always allow muted = true changes to go through
-        if (!muted && !await this.client.getMediaHandler().hasAudioDevice()) {
+        if (!muted && !(await this.client.getMediaHandler().hasAudioDevice())) {
             return false;
         }
 
@@ -563,22 +558,21 @@ export class GroupCall extends TypedEventEmitter<
             }
         }
 
-        this.forEachCall(call => call.localUsermediaFeed?.setAudioVideoMuted(muted, null));
+        this.forEachCall((call) => call.localUsermediaFeed?.setAudioVideoMuted(muted, null));
 
         const sendUpdates = async (): Promise<void> => {
             const updates: Promise<void>[] = [];
-            this.forEachCall(call => updates.push(call.sendMetadataUpdate()));
+            this.forEachCall((call) => updates.push(call.sendMetadataUpdate()));
 
-            await Promise.all(updates).catch(
-                e => logger.info("Failed to send some metadata updates", e),
-            );
+            await Promise.all(updates).catch((e) => logger.info("Failed to send some metadata updates", e));
         };
 
         if (sendUpdatesBefore) await sendUpdates();
 
         if (this.localCallFeed) {
-            logger.log(`groupCall ${this.groupCallId} setMicrophoneMuted stream ${
-                this.localCallFeed.stream.id} muted ${muted}`);
+            logger.log(
+                `groupCall ${this.groupCallId} setMicrophoneMuted stream ${this.localCallFeed.stream.id} muted ${muted}`,
+            );
             this.localCallFeed.setAudioVideoMuted(muted, null);
             // I don't believe its actually necessary to enable these tracks: they
             // are the one on the groupcall's own CallFeed and are cloned before being
@@ -590,7 +584,7 @@ export class GroupCall extends TypedEventEmitter<
             this.initWithAudioMuted = muted;
         }
 
-        this.forEachCall(call => setTracksEnabled(call.localUsermediaFeed!.stream.getAudioTracks(), !muted));
+        this.forEachCall((call) => setTracksEnabled(call.localUsermediaFeed!.stream.getAudioTracks(), !muted));
         this.emit(GroupCallEvent.LocalMuteStateChanged, muted, this.isLocalVideoMuted());
 
         if (!sendUpdatesBefore) await sendUpdates();
@@ -607,13 +601,14 @@ export class GroupCall extends TypedEventEmitter<
         // hasAudioDevice can block indefinitely if the window has lost focus,
         // and it doesn't make much sense to keep a device from being muted, so
         // we always allow muted = true changes to go through
-        if (!muted && !await this.client.getMediaHandler().hasVideoDevice()) {
+        if (!muted && !(await this.client.getMediaHandler().hasVideoDevice())) {
             return false;
         }
 
         if (this.localCallFeed) {
-            logger.log(`groupCall ${this.groupCallId} setLocalVideoMuted stream ${
-                this.localCallFeed.stream.id} muted ${muted}`);
+            logger.log(
+                `groupCall ${this.groupCallId} setLocalVideoMuted stream ${this.localCallFeed.stream.id} muted ${muted}`,
+            );
             this.localCallFeed.setAudioVideoMuted(null, muted);
             setTracksEnabled(this.localCallFeed.stream.getVideoTracks(), !muted);
         } else {
@@ -622,7 +617,7 @@ export class GroupCall extends TypedEventEmitter<
         }
 
         const updates: Promise<unknown>[] = [];
-        this.forEachCall(call => updates.push(call.setLocalVideoMuted(muted)));
+        this.forEachCall((call) => updates.push(call.setLocalVideoMuted(muted)));
         await Promise.all(updates);
 
         this.emit(GroupCallEvent.LocalMuteStateChanged, this.isMicrophoneMuted(), muted);
@@ -630,9 +625,7 @@ export class GroupCall extends TypedEventEmitter<
         return true;
     }
 
-    public async setScreensharingEnabled(
-        enabled: boolean, opts: IScreensharingOpts = {},
-    ): Promise<boolean> {
+    public async setScreensharingEnabled(enabled: boolean, opts: IScreensharingOpts = {}): Promise<boolean> {
         if (enabled === this.isScreensharing()) {
             return enabled;
         }
@@ -674,22 +667,24 @@ export class GroupCall extends TypedEventEmitter<
                 );
 
                 // TODO: handle errors
-                this.forEachCall(call => call.pushLocalFeed(this.localScreenshareFeed!.clone()));
+                this.forEachCall((call) => call.pushLocalFeed(this.localScreenshareFeed!.clone()));
 
                 return true;
             } catch (error) {
                 if (opts.throwOnFail) throw error;
                 logger.error("Enabling screensharing error", error);
-                this.emit(GroupCallEvent.Error,
+                this.emit(
+                    GroupCallEvent.Error,
                     new GroupCallError(
                         GroupCallErrorCode.NoUserMedia,
-                        "Failed to get screen-sharing stream: ", error as Error,
+                        "Failed to get screen-sharing stream: ",
+                        error as Error,
                     ),
                 );
                 return false;
             }
         } else {
-            this.forEachCall(call => {
+            this.forEachCall((call) => {
                 if (call.localScreensharingFeed) call.removeLocalFeed(call.localScreensharingFeed);
             });
             this.client.getMediaHandler().stopScreensharingStream(this.localScreenshareFeed!.stream);
@@ -726,8 +721,9 @@ export class GroupCall extends TypedEventEmitter<
         }
 
         if (!newCall.groupCallId || newCall.groupCallId !== this.groupCallId) {
-            logger.log(`Incoming call with groupCallId ${
-                newCall.groupCallId} ignored because it doesn't match the current group call`);
+            logger.log(
+                `Incoming call with groupCallId ${newCall.groupCallId} ignored because it doesn't match the current group call`,
+            );
             newCall.reject();
             return;
         }
@@ -767,9 +763,9 @@ export class GroupCall extends TypedEventEmitter<
         const localDeviceId = this.client.getDeviceId()!;
         return (
             // If a user's ID is less than our own, they'll call us
-            userId >= localUserId
+            userId >= localUserId &&
             // If this is another one of our devices, compare device IDs to tell whether it'll call us
-            && (userId !== localUserId || deviceId > localDeviceId)
+            (userId !== localUserId || deviceId > localDeviceId)
         );
     }
 
@@ -786,8 +782,8 @@ export class GroupCall extends TypedEventEmitter<
                 const prevCall = callMap.get(deviceId);
 
                 if (
-                    prevCall?.getOpponentSessionId() !== participant.sessionId
-                    && this.wantsOutgoingCall(member.userId, deviceId)
+                    prevCall?.getOpponentSessionId() !== participant.sessionId &&
+                    this.wantsOutgoingCall(member.userId, deviceId)
                 ) {
                     callsChanged = true;
 
@@ -796,16 +792,12 @@ export class GroupCall extends TypedEventEmitter<
                         this.disposeCall(prevCall, CallErrorCode.NewSession);
                     }
 
-                    const newCall = createNewMatrixCall(
-                        this.client,
-                        this.room.roomId,
-                        {
-                            invitee: member.userId,
-                            opponentDeviceId: deviceId,
-                            opponentSessionId: participant.sessionId,
-                            groupCallId: this.groupCallId,
-                        },
-                    );
+                    const newCall = createNewMatrixCall(this.client, this.room.roomId, {
+                        invitee: member.userId,
+                        opponentDeviceId: deviceId,
+                        opponentSessionId: participant.sessionId,
+                        groupCallId: this.groupCallId,
+                    });
 
                     if (newCall === null) {
                         logger.error(`Failed to create call with ${member.userId} ${deviceId}`);
@@ -814,35 +806,36 @@ export class GroupCall extends TypedEventEmitter<
                         this.initCall(newCall);
                         callMap.set(deviceId, newCall);
 
-                        logger.debug(
-                            `Placing call to ${member.userId} ${deviceId} (session ${participant.sessionId})`,
-                        );
-
-                        newCall.placeCallWithCallFeeds(
-                            this.getLocalFeeds().map(feed => feed.clone()),
-                            participant.screensharing,
-                        ).then(() => {
-                            if (this.dataChannelsEnabled) {
-                                newCall.createDataChannel("datachannel", this.dataChannelOptions);
-                            }
-                        }).catch(e => {
-                            logger.warn(`Failed to place call to ${member.userId}`, e);
-
-                            if (e instanceof CallError && e.code === GroupCallErrorCode.UnknownDevice) {
-                                this.emit(GroupCallEvent.Error, e);
-                            } else {
-                                this.emit(
-                                    GroupCallEvent.Error,
-                                    new GroupCallError(
-                                        GroupCallErrorCode.PlaceCallFailed,
-                                        `Failed to place call to ${member.userId}`,
-                                    ),
-                                );
-                            }
-
-                            this.disposeCall(newCall, CallErrorCode.SignallingFailed);
-                            if (callMap.get(deviceId) === newCall) callMap.delete(deviceId);
-                        });
+                        logger.debug(`Placing call to ${member.userId} ${deviceId} (session ${participant.sessionId})`);
+
+                        newCall
+                            .placeCallWithCallFeeds(
+                                this.getLocalFeeds().map((feed) => feed.clone()),
+                                participant.screensharing,
+                            )
+                            .then(() => {
+                                if (this.dataChannelsEnabled) {
+                                    newCall.createDataChannel("datachannel", this.dataChannelOptions);
+                                }
+                            })
+                            .catch((e) => {
+                                logger.warn(`Failed to place call to ${member.userId}`, e);
+
+                                if (e instanceof CallError && e.code === GroupCallErrorCode.UnknownDevice) {
+                                    this.emit(GroupCallEvent.Error, e);
+                                } else {
+                                    this.emit(
+                                        GroupCallEvent.Error,
+                                        new GroupCallError(
+                                            GroupCallErrorCode.PlaceCallFailed,
+                                            `Failed to place call to ${member.userId}`,
+                                        ),
+                                    );
+                                }
+
+                                this.disposeCall(newCall, CallErrorCode.SignallingFailed);
+                                if (callMap.get(deviceId) === newCall) callMap.delete(deviceId);
+                            });
                     }
                 }
             }
@@ -881,9 +874,9 @@ export class GroupCall extends TypedEventEmitter<
                 const retries = retriesMap?.get(deviceId) ?? 0;
 
                 if (
-                    call?.getOpponentSessionId() !== participant.sessionId
-                    && this.wantsOutgoingCall(member.userId, deviceId)
-                    && retries < 3
+                    call?.getOpponentSessionId() !== participant.sessionId &&
+                    this.wantsOutgoingCall(member.userId, deviceId) &&
+                    retries < 3
                 ) {
                     if (retriesMap === undefined) {
                         retriesMap = new Map();
@@ -906,10 +899,8 @@ export class GroupCall extends TypedEventEmitter<
         }
 
         const onCallFeedsChanged = (): void => this.onCallFeedsChanged(call);
-        const onCallStateChanged = (
-            state: CallState,
-            oldState?: CallState,
-        ): void => this.onCallStateChanged(call, state, oldState);
+        const onCallStateChanged = (state: CallState, oldState?: CallState): void =>
+            this.onCallStateChanged(call, state, oldState);
         const onCallHangup = this.onCallHangup;
         const onCallReplaced = (newCall: MatrixCall): void => this.onCallReplaced(call, newCall);
 
@@ -947,12 +938,8 @@ export class GroupCall extends TypedEventEmitter<
         }
 
         const deviceMap = this.callHandlers.get(opponentMemberId)!;
-        const {
-            onCallFeedsChanged,
-            onCallStateChanged,
-            onCallHangup,
-            onCallReplaced,
-        } = deviceMap.get(opponentDeviceId)!;
+        const { onCallFeedsChanged, onCallStateChanged, onCallHangup, onCallReplaced } =
+            deviceMap.get(opponentDeviceId)!;
 
         call.removeListener(CallEvent.FeedsChanged, onCallFeedsChanged);
         call.removeListener(CallEvent.State, onCallStateChanged);
@@ -1023,19 +1010,13 @@ export class GroupCall extends TypedEventEmitter<
     private onCallStateChanged = (call: MatrixCall, state: CallState, _oldState: CallState | undefined): void => {
         const audioMuted = this.localCallFeed!.isAudioMuted();
 
-        if (
-            call.localUsermediaStream &&
-            call.isMicrophoneMuted() !== audioMuted
-        ) {
+        if (call.localUsermediaStream && call.isMicrophoneMuted() !== audioMuted) {
             call.setMicrophoneMuted(audioMuted);
         }
 
         const videoMuted = this.localCallFeed!.isVideoMuted();
 
-        if (
-            call.localUsermediaStream &&
-            call.isLocalVideoMuted() !== videoMuted
-        ) {
+        if (call.localUsermediaStream && call.isLocalVideoMuted() !== videoMuted) {
             call.setLocalVideoMuted(videoMuted);
         }
 
@@ -1082,7 +1063,7 @@ export class GroupCall extends TypedEventEmitter<
      */
 
     public getUserMediaFeed(userId: string, deviceId: string): CallFeed | undefined {
-        return this.userMediaFeeds.find(f => f.userId === userId && f.deviceId! === deviceId);
+        return this.userMediaFeeds.find((f) => f.userId === userId && f.deviceId! === deviceId);
     }
 
     private addUserMediaFeed(callFeed: CallFeed): void {
@@ -1093,7 +1074,7 @@ export class GroupCall extends TypedEventEmitter<
 
     private replaceUserMediaFeed(existingFeed: CallFeed, replacementFeed: CallFeed): void {
         const feedIndex = this.userMediaFeeds.findIndex(
-            f => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,
+            (f) => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,
         );
 
         if (feedIndex === -1) {
@@ -1109,7 +1090,7 @@ export class GroupCall extends TypedEventEmitter<
 
     private removeUserMediaFeed(callFeed: CallFeed): void {
         const feedIndex = this.userMediaFeeds.findIndex(
-            f => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,
+            (f) => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,
         );
 
         if (feedIndex === -1) {
@@ -1156,7 +1137,7 @@ export class GroupCall extends TypedEventEmitter<
      */
 
     public getScreenshareFeed(userId: string, deviceId: string): CallFeed | undefined {
-        return this.screenshareFeeds.find(f => f.userId === userId && f.deviceId! === deviceId);
+        return this.screenshareFeeds.find((f) => f.userId === userId && f.deviceId! === deviceId);
     }
 
     private addScreenshareFeed(callFeed: CallFeed): void {
@@ -1166,7 +1147,7 @@ export class GroupCall extends TypedEventEmitter<
 
     private replaceScreenshareFeed(existingFeed: CallFeed, replacementFeed: CallFeed): void {
         const feedIndex = this.screenshareFeeds.findIndex(
-            f => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,
+            (f) => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,
         );
 
         if (feedIndex === -1) {
@@ -1181,7 +1162,7 @@ export class GroupCall extends TypedEventEmitter<
 
     private removeScreenshareFeed(callFeed: CallFeed): void {
         const feedIndex = this.screenshareFeeds.findIndex(
-            f => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,
+            (f) => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,
         );
 
         if (feedIndex === -1) {
@@ -1217,21 +1198,22 @@ export class GroupCall extends TypedEventEmitter<
             const member = this.room.getMember(e.getStateKey()!);
             const content = e.getContent<Record<any, unknown>>();
             const calls: Record<any, unknown>[] = Array.isArray(content["m.calls"]) ? content["m.calls"] : [];
-            const call = calls.find(call => call["m.call_id"] === this.groupCallId);
+            const call = calls.find((call) => call["m.call_id"] === this.groupCallId);
             const devices: Record<any, unknown>[] = Array.isArray(call?.["m.devices"]) ? call!["m.devices"] : [];
 
             // Filter out invalid and expired devices
-            let validDevices = devices.filter(d => (
-                typeof d.device_id === "string"
-                && typeof d.session_id === "string"
-                && typeof d.expires_ts === "number"
-                && d.expires_ts > now
-                && Array.isArray(d.feeds)
-            )) as unknown as IGroupCallRoomMemberDevice[];
+            let validDevices = devices.filter(
+                (d) =>
+                    typeof d.device_id === "string" &&
+                    typeof d.session_id === "string" &&
+                    typeof d.expires_ts === "number" &&
+                    d.expires_ts > now &&
+                    Array.isArray(d.feeds),
+            ) as unknown as IGroupCallRoomMemberDevice[];
 
             // Apply local echo for the unentered case
             if (!entered && member?.userId === this.client.getUserId()!) {
-                validDevices = validDevices.filter(d => d.device_id !== this.client.getDeviceId()!);
+                validDevices = validDevices.filter((d) => d.device_id !== this.client.getDeviceId()!);
             }
 
             // Must have a connected device and be joined to the room
@@ -1242,7 +1224,7 @@ export class GroupCall extends TypedEventEmitter<
                 for (const d of validDevices) {
                     deviceMap.set(d.device_id, {
                         sessionId: d.session_id,
-                        screensharing: d.feeds.some(f => f.purpose === SDPStreamMetadataPurpose.Screenshare),
+                        screensharing: d.feeds.some((f) => f.purpose === SDPStreamMetadataPurpose.Screenshare),
                     });
                     if (d.expires_ts < nextExpiration) nextExpiration = d.expires_ts;
                 }
@@ -1261,7 +1243,7 @@ export class GroupCall extends TypedEventEmitter<
             if (!deviceMap.has(this.client.getDeviceId()!)) {
                 deviceMap.set(this.client.getDeviceId()!, {
                     sessionId: this.client.getSessionId(),
-                    screensharing: this.getLocalFeeds().some(f => f.purpose === SDPStreamMetadataPurpose.Screenshare),
+                    screensharing: this.getLocalFeeds().some((f) => f.purpose === SDPStreamMetadataPurpose.Screenshare),
                 });
             }
         }
@@ -1303,18 +1285,19 @@ export class GroupCall extends TypedEventEmitter<
         const devices: Record<any, unknown>[] = Array.isArray(call["m.devices"]) ? call["m.devices"] : [];
 
         // Filter out invalid and expired devices
-        const validDevices = devices.filter(d => (
-            typeof d.device_id === "string"
-            && typeof d.session_id === "string"
-            && typeof d.expires_ts === "number"
-            && d.expires_ts > now
-            && Array.isArray(d.feeds)
-        )) as unknown as IGroupCallRoomMemberDevice[];
+        const validDevices = devices.filter(
+            (d) =>
+                typeof d.device_id === "string" &&
+                typeof d.session_id === "string" &&
+                typeof d.expires_ts === "number" &&
+                d.expires_ts > now &&
+                Array.isArray(d.feeds),
+        ) as unknown as IGroupCallRoomMemberDevice[];
 
         const newDevices = fn(validDevices);
         if (newDevices === null) return;
 
-        const newCalls = [...otherCalls as unknown as IGroupCallRoomMemberCallState[]];
+        const newCalls = [...(otherCalls as unknown as IGroupCallRoomMemberCallState[])];
         if (newDevices.length > 0) {
             newCalls.push({
                 ...call,
@@ -1325,19 +1308,19 @@ export class GroupCall extends TypedEventEmitter<
 
         const newContent: IGroupCallRoomMemberState = { "m.calls": newCalls };
 
-        await this.client.sendStateEvent(
-            this.room.roomId, EventType.GroupCallMemberPrefix, newContent, localUserId, { keepAlive },
-        );
+        await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, newContent, localUserId, {
+            keepAlive,
+        });
     }
 
     private async addDeviceToMemberState(): Promise<void> {
-        await this.updateDevices(devices => [
-            ...devices.filter(d => d.device_id !== this.client.getDeviceId()!),
+        await this.updateDevices((devices) => [
+            ...devices.filter((d) => d.device_id !== this.client.getDeviceId()!),
             {
-                "device_id": this.client.getDeviceId()!,
-                "session_id": this.client.getSessionId(),
-                "expires_ts": Date.now() + DEVICE_TIMEOUT,
-                "feeds": this.getLocalFeeds().map(feed => ({ purpose: feed.purpose })),
+                device_id: this.client.getDeviceId()!,
+                session_id: this.client.getSessionId(),
+                expires_ts: Date.now() + DEVICE_TIMEOUT,
+                feeds: this.getLocalFeeds().map((feed) => ({ purpose: feed.purpose })),
                 // TODO: Add data channels
             },
         ]);
@@ -1362,11 +1345,11 @@ export class GroupCall extends TypedEventEmitter<
                 } catch (e) {
                     logger.error("Failed to resend call member state", e);
                 }
-            }, DEVICE_TIMEOUT * 3 / 4);
+            }, (DEVICE_TIMEOUT * 3) / 4);
         } else {
             // Remove the local device
             await this.updateDevices(
-                devices => devices.filter(d => d.device_id !== this.client.getDeviceId()!),
+                (devices) => devices.filter((d) => d.device_id !== this.client.getDeviceId()!),
                 true,
             );
         }
@@ -1378,16 +1361,19 @@ export class GroupCall extends TypedEventEmitter<
      */
     public async cleanMemberState(): Promise<void> {
         const { devices: myDevices } = await this.client.getDevices();
-        const deviceMap = new Map<string, IMyDevice>(myDevices.map(d => [d.device_id, d]));
+        const deviceMap = new Map<string, IMyDevice>(myDevices.map((d) => [d.device_id, d]));
 
         // updateDevices takes care of filtering out inactive devices for us
-        await this.updateDevices(devices => {
-            const newDevices = devices.filter(d => {
+        await this.updateDevices((devices) => {
+            const newDevices = devices.filter((d) => {
                 const device = deviceMap.get(d.device_id);
-                return device?.last_seen_ts !== undefined && !(
-                    d.device_id === this.client.getDeviceId()!
-                    && this.state !== GroupCallState.Entered
-                    && !this.enteredViaAnotherSession
+                return (
+                    device?.last_seen_ts !== undefined &&
+                    !(
+                        d.device_id === this.client.getDeviceId()! &&
+                        this.state !== GroupCallState.Entered &&
+                        !this.enteredViaAnotherSession
+                    )
                 );
             });
 
@@ -1404,19 +1390,19 @@ export class GroupCall extends TypedEventEmitter<
 
     private onStateChanged = (newState: GroupCallState, oldState: GroupCallState): void => {
         if (
-            newState === GroupCallState.Entered
-            || oldState === GroupCallState.Entered
-            || newState === GroupCallState.Ended
+            newState === GroupCallState.Entered ||
+            oldState === GroupCallState.Entered ||
+            newState === GroupCallState.Ended
         ) {
             // We either entered, left, or ended the call
             this.updateParticipants();
-            this.updateMemberState().catch(e => logger.error("Failed to update member state devices", e));
+            this.updateMemberState().catch((e) => logger.error("Failed to update member state devices", e));
         }
     };
 
     private onLocalFeedsChanged = (): void => {
         if (this.state === GroupCallState.Entered) {
-            this.updateMemberState().catch(e => logger.error("Failed to update member state feeds", e));
+            this.updateMemberState().catch((e) => logger.error("Failed to update member state feeds", e));
         }
     };
 }
diff --git a/src/webrtc/groupCallEventHandler.ts b/src/webrtc/groupCallEventHandler.ts
index b1768ee90dd..d96d5ef8686 100644
--- a/src/webrtc/groupCallEventHandler.ts
+++ b/src/webrtc/groupCallEventHandler.ts
@@ -14,20 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { MatrixEvent } from '../models/event';
-import { MatrixClient, ClientEvent } from '../client';
-import {
-    GroupCall,
-    GroupCallIntent,
-    GroupCallType,
-    IGroupCallDataChannelOptions,
-} from "./groupCall";
+import { MatrixEvent } from "../models/event";
+import { MatrixClient, ClientEvent } from "../client";
+import { GroupCall, GroupCallIntent, GroupCallType, IGroupCallDataChannelOptions } from "./groupCall";
 import { Room } from "../models/room";
 import { RoomState, RoomStateEvent } from "../models/room-state";
 import { RoomMember } from "../models/room-member";
-import { logger } from '../logger';
+import { logger } from "../logger";
 import { EventType } from "../@types/event";
-import { SyncState } from '../sync';
+import { SyncState } from "../sync";
 
 export enum GroupCallEventHandlerEvent {
     Incoming = "GroupCall.incoming",
@@ -57,7 +52,7 @@ export class GroupCallEventHandler {
     // and get
     private roomDeferreds = new Map<string, RoomDeferred>();
 
-    public constructor(private client: MatrixClient) { }
+    public constructor(private client: MatrixClient) {}
 
     public async start(): Promise<void> {
         // We wait until the client has started syncing for real.
@@ -67,7 +62,7 @@ export class GroupCallEventHandler {
         // the group call we create is really the latest one.
         if (this.client.getSyncState() !== SyncState.Syncing) {
             logger.debug("Waiting for client to start syncing...");
-            await new Promise<void>(resolve => {
+            await new Promise<void>((resolve) => {
                 const onSync = (): void => {
                     if (this.client.getSyncState() === SyncState.Syncing) {
                         this.client.off(ClientEvent.Sync, onSync);
@@ -97,7 +92,7 @@ export class GroupCallEventHandler {
         if (deferred === undefined) {
             let resolveFunc: () => void;
             deferred = {
-                prom: new Promise<void>(resolve => {
+                prom: new Promise<void>((resolve) => {
                     resolveFunc = resolve;
                 }),
             };
@@ -129,7 +124,7 @@ export class GroupCallEventHandler {
 
             logger.debug(
                 `Choosing group call ${callEvent.getStateKey()} with TS ` +
-                `${callEvent.getTs()} for room ${room.roomId} from ${callEvents.length} possible calls.`,
+                    `${callEvent.getTs()} for room ${room.roomId} from ${callEvents.length} possible calls.`,
             );
 
             this.createGroupCallFromRoomStateEvent(callEvent);
@@ -214,13 +209,15 @@ export class GroupCallEventHandler {
                     currentGroupCall.terminate(false);
                 } else if (content["m.type"] !== currentGroupCall.type) {
                     // TODO: Handle the callType changing when the room state changes
-                    logger.warn(`The group call type changed for room: ${
-                        state.roomId}. Changing the group call type is currently unsupported.`);
+                    logger.warn(
+                        `The group call type changed for room: ${state.roomId}. Changing the group call type is currently unsupported.`,
+                    );
                 }
             } else if (currentGroupCall && currentGroupCall.groupCallId !== groupCallId) {
                 // TODO: Handle new group calls and multiple group calls
-                logger.warn(`Multiple group calls detected for room: ${
-                    state.roomId}. Multiple group calls are currently unsupported.`);
+                logger.warn(
+                    `Multiple group calls detected for room: ${state.roomId}. Multiple group calls are currently unsupported.`,
+                );
             }
         }
     };
diff --git a/src/webrtc/mediaHandler.ts b/src/webrtc/mediaHandler.ts
index 46943ae386a..ca311e4a5a3 100644
--- a/src/webrtc/mediaHandler.ts
+++ b/src/webrtc/mediaHandler.ts
@@ -23,7 +23,7 @@ import { logger } from "../logger";
 import { MatrixClient } from "../client";
 
 export enum MediaHandlerEvent {
-    LocalStreamsChanged = "local_streams_changed"
+    LocalStreamsChanged = "local_streams_changed",
 }
 
 export type MediaHandlerEventHandlerMap = {
@@ -47,7 +47,8 @@ export interface AudioSettings {
 }
 
 export class MediaHandler extends TypedEventEmitter<
-    MediaHandlerEvent.LocalStreamsChanged, MediaHandlerEventHandlerMap
+    MediaHandlerEvent.LocalStreamsChanged,
+    MediaHandlerEventHandlerMap
 > {
     private audioInput?: string;
     private audioSettings?: AudioSettings;
@@ -123,7 +124,7 @@ export class MediaHandler extends TypedEventEmitter<
     public async updateLocalUsermediaStreams(): Promise<void> {
         if (this.userMediaStreams.length === 0) return;
 
-        const callMediaStreamParams: Map<string, { audio: boolean, video: boolean }> = new Map();
+        const callMediaStreamParams: Map<string, { audio: boolean; video: boolean }> = new Map();
         for (const call of this.client.callEventHandler!.calls.values()) {
             callMediaStreamParams.set(call.callId, {
                 audio: call.hasLocalUserMediaAudioTrack,
@@ -163,12 +164,10 @@ export class MediaHandler extends TypedEventEmitter<
                 continue;
             }
 
-            logger.log(`mediaHandler updateLocalUsermediaStreams getUserMediaStream groupCall ${
-                groupCall.groupCallId}`);
-            const stream = await this.getUserMediaStream(
-                true,
-                groupCall.type === GroupCallType.Video,
+            logger.log(
+                `mediaHandler updateLocalUsermediaStreams getUserMediaStream groupCall ${groupCall.groupCallId}`,
             );
+            const stream = await this.getUserMediaStream(true, groupCall.type === GroupCallType.Video);
 
             if (groupCall.state === GroupCallState.Ended) {
                 continue;
@@ -182,12 +181,12 @@ export class MediaHandler extends TypedEventEmitter<
 
     public async hasAudioDevice(): Promise<boolean> {
         const devices = await navigator.mediaDevices.enumerateDevices();
-        return devices.filter(device => device.kind === "audioinput").length > 0;
+        return devices.filter((device) => device.kind === "audioinput").length > 0;
     }
 
     public async hasVideoDevice(): Promise<boolean> {
         const devices = await navigator.mediaDevices.enumerateDevices();
-        return devices.filter(device => device.kind === "videoinput").length > 0;
+        return devices.filter((device) => device.kind === "videoinput").length > 0;
     }
 
     /**
@@ -197,8 +196,8 @@ export class MediaHandler extends TypedEventEmitter<
      * @returns based on passed parameters
      */
     public async getUserMediaStream(audio: boolean, video: boolean, reusable = true): Promise<MediaStream> {
-        const shouldRequestAudio = audio && await this.hasAudioDevice();
-        const shouldRequestVideo = video && await this.hasVideoDevice();
+        const shouldRequestAudio = audio && (await this.hasAudioDevice());
+        const shouldRequestVideo = video && (await this.hasVideoDevice());
 
         let stream: MediaStream;
 
@@ -218,7 +217,8 @@ export class MediaHandler extends TypedEventEmitter<
             if (shouldRequestVideo) {
                 if (
                     this.localUserMediaStream.getVideoTracks().length === 0 ||
-                    this.localUserMediaStream.getVideoTracks()[0]?.getSettings()?.deviceId !== this.videoInput) {
+                    this.localUserMediaStream.getVideoTracks()[0]?.getSettings()?.deviceId !== this.videoInput
+                ) {
                     canReuseStream = false;
                 }
             }
@@ -229,8 +229,10 @@ export class MediaHandler extends TypedEventEmitter<
         if (!canReuseStream) {
             const constraints = this.getUserMediaContraints(shouldRequestAudio, shouldRequestVideo);
             stream = await navigator.mediaDevices.getUserMedia(constraints);
-            logger.log(`mediaHandler getUserMediaStream streamId ${stream.id} shouldRequestAudio ${
-                shouldRequestAudio} shouldRequestVideo ${shouldRequestVideo}`, constraints);
+            logger.log(
+                `mediaHandler getUserMediaStream streamId ${stream.id} shouldRequestAudio ${shouldRequestAudio} shouldRequestVideo ${shouldRequestVideo}`,
+                constraints,
+            );
 
             for (const track of stream.getTracks()) {
                 const settings = track.getSettings();
@@ -247,8 +249,9 @@ export class MediaHandler extends TypedEventEmitter<
             }
         } else {
             stream = this.localUserMediaStream!.clone();
-            logger.log(`mediaHandler clone userMediaStream ${this.localUserMediaStream?.id} new stream ${
-                stream.id} shouldRequestAudio ${shouldRequestAudio} shouldRequestVideo ${shouldRequestVideo}`);
+            logger.log(
+                `mediaHandler clone userMediaStream ${this.localUserMediaStream?.id} new stream ${stream.id} shouldRequestAudio ${shouldRequestAudio} shouldRequestVideo ${shouldRequestVideo}`,
+            );
 
             if (!shouldRequestAudio) {
                 for (const track of stream.getAudioTracks()) {
@@ -379,23 +382,23 @@ export class MediaHandler extends TypedEventEmitter<
         return {
             audio: audio
                 ? {
-                    deviceId: this.audioInput ? { ideal: this.audioInput } : undefined,
-                    autoGainControl: this.audioSettings ? { ideal: this.audioSettings.autoGainControl } : undefined,
-                    echoCancellation: this.audioSettings ? { ideal: this.audioSettings.echoCancellation } : undefined,
-                    noiseSuppression: this.audioSettings ? { ideal: this.audioSettings.noiseSuppression } : undefined,
-                }
+                      deviceId: this.audioInput ? { ideal: this.audioInput } : undefined,
+                      autoGainControl: this.audioSettings ? { ideal: this.audioSettings.autoGainControl } : undefined,
+                      echoCancellation: this.audioSettings ? { ideal: this.audioSettings.echoCancellation } : undefined,
+                      noiseSuppression: this.audioSettings ? { ideal: this.audioSettings.noiseSuppression } : undefined,
+                  }
                 : false,
             video: video
                 ? {
-                    deviceId: this.videoInput ? { ideal: this.videoInput } : undefined,
-                    /* We want 640x360.  Chrome will give it only if we ask exactly,
+                      deviceId: this.videoInput ? { ideal: this.videoInput } : undefined,
+                      /* We want 640x360.  Chrome will give it only if we ask exactly,
                    FF refuses entirely if we ask exactly, so have to ask for ideal
                    instead
                    XXX: Is this still true?
                  */
-                    width: isWebkit ? { exact: 640 } : { ideal: 640 },
-                    height: isWebkit ? { exact: 360 } : { ideal: 360 },
-                }
+                      width: isWebkit ? { exact: 640 } : { ideal: 640 },
+                      height: isWebkit ? { exact: 360 } : { ideal: 360 },
+                  }
                 : false,
         };
     }
diff --git a/tsconfig-build.json b/tsconfig-build.json
index 42a4cf697b0..3108314a4d6 100644
--- a/tsconfig-build.json
+++ b/tsconfig-build.json
@@ -1,14 +1,12 @@
 {
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "declarationMap": true,
-    "sourceMap": true,
-    "noEmit": false,
-    "emitDecoratorMetadata": true,
-    "outDir": "./lib",
-    "rootDir": "src"
-  },
-  "exclude": [
-    "./spec/**/*.ts"
-  ]
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "declarationMap": true,
+        "sourceMap": true,
+        "noEmit": false,
+        "emitDecoratorMetadata": true,
+        "outDir": "./lib",
+        "rootDir": "src"
+    },
+    "exclude": ["./spec/**/*.ts"]
 }
diff --git a/tsconfig.json b/tsconfig.json
index f34858ce9e4..839dba04aab 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,22 +1,19 @@
 {
-  "compilerOptions": {
-    "target": "es2016",
-    "experimentalDecorators": true,
-    "esModuleInterop": true,
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "noUnusedLocals": true,
-    "noEmit": true,
-    "declaration": true,
-    "strict": true
-  },
-  "include": [
-    "./src/**/*.ts",
-    "./spec/**/*.ts"
-  ],
-  "typedocOptions": {
-    "entryPoints": ["src/index.ts"],
-    "excludeExternals": true,
-    "out": "_docs"
-  }
+    "compilerOptions": {
+        "target": "es2016",
+        "experimentalDecorators": true,
+        "esModuleInterop": true,
+        "module": "commonjs",
+        "moduleResolution": "node",
+        "noUnusedLocals": true,
+        "noEmit": true,
+        "declaration": true,
+        "strict": true
+    },
+    "include": ["./src/**/*.ts", "./spec/**/*.ts"],
+    "typedocOptions": {
+        "entryPoints": ["src/index.ts"],
+        "excludeExternals": true,
+        "out": "_docs"
+    }
 }

From 72dac9a10738935495f4f29ec5030170f36d29b7 Mon Sep 17 00:00:00 2001
From: Michael Weimann <michaelw@matrix.org>
Date: Fri, 9 Dec 2022 09:39:03 +0100
Subject: [PATCH 37/60] Apply manual code style fixes after prettier

---
 spec/unit/location.spec.ts         | 2 +-
 spec/unit/webrtc/groupCall.spec.ts | 3 +++
 src/client.ts                      | 5 +++--
 src/crypto/index.ts                | 4 ++--
 src/models/room.ts                 | 4 ++--
 5 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/spec/unit/location.spec.ts b/spec/unit/location.spec.ts
index b2d2a50d701..953d3b611b1 100644
--- a/spec/unit/location.spec.ts
+++ b/spec/unit/location.spec.ts
@@ -43,9 +43,9 @@ describe("Location", function () {
     const modernEventContent = { ...modernProperties };
 
     const legacyEventContent = {
-        // eslint-disable-next-line camelcase
         body,
         msgtype,
+        // eslint-disable-next-line camelcase
         geo_uri,
     } as LocationEventWireContent;
 
diff --git a/spec/unit/webrtc/groupCall.spec.ts b/spec/unit/webrtc/groupCall.spec.ts
index fc09c353788..59cdbac129d 100644
--- a/spec/unit/webrtc/groupCall.spec.ts
+++ b/spec/unit/webrtc/groupCall.spec.ts
@@ -843,6 +843,7 @@ describe("Group Call", function () {
                 call.getOpponentMember = () => ({ userId: call.invitee } as RoomMember);
                 // @ts-ignore Mock
                 call.pushRemoteFeed(
+                    // @ts-ignore Mock
                     new MockMediaStream("stream", [
                         new MockMediaStreamTrack("audio_track", "audio"),
                         new MockMediaStreamTrack("video_track", "video"),
@@ -869,6 +870,7 @@ describe("Group Call", function () {
                 call.getOpponentMember = () => ({ userId: call.invitee } as RoomMember);
                 // @ts-ignore Mock
                 call.pushRemoteFeed(
+                    // @ts-ignore Mock
                     new MockMediaStream("stream", [
                         new MockMediaStreamTrack("audio_track", "audio"),
                         new MockMediaStreamTrack("video_track", "video"),
@@ -1054,6 +1056,7 @@ describe("Group Call", function () {
             } as MatrixEvent);
             // @ts-ignore Mock
             call.pushRemoteFeed(
+                // @ts-ignore Mock
                 new MockMediaStream("screensharing_stream", [new MockMediaStreamTrack("video_track", "video")]),
             );
 
diff --git a/src/client.ts b/src/client.ts
index 68df4595d17..3ff3b2c009b 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -2837,8 +2837,9 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             algorithm: wireContent.algorithm,
             room_id: event.getRoomId()!,
         };
-        if (!requestBody.session_id || !requestBody.sender_key || !requestBody.algorithm || !requestBody.room_id)
+        if (!requestBody.session_id || !requestBody.sender_key || !requestBody.algorithm || !requestBody.room_id) {
             return Promise.resolve(null);
+        }
         return this.crypto.cryptoStore.getOutgoingRoomKeyRequest(requestBody);
     }
 
@@ -6837,8 +6838,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns Promise which resolves to a set of rooms
      * @returns Rejects: with an error response.
      */
+    // eslint-disable-next-line
     public async _unstable_getSharedRooms(userId: string): Promise<string[]> {
-        // eslint-disable-line
         const sharedRoomsSupport = await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666");
         const mutualRoomsSupport = await this.doesServerSupportUnstableFeature("uk.half-shot.msc2666.mutual_rooms");
 
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 74df3b5a13a..391e6975e7d 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -338,10 +338,10 @@ export type CryptoEventHandlerMap = {
         failures: IUploadKeySignaturesResponse["failures"],
         source: "checkOwnCrossSigningTrust" | "afterCrossSigningLocalKeyChange" | "setDeviceVerification",
         upload: (opts: { shouldEmit: boolean }) => Promise<void>,
-    ) => void
+    ) => void;
     /**
      * Fires when a key verification is requested.
-     */;
+     */
     [CryptoEvent.VerificationRequest]: (request: VerificationRequest<any>) => void;
     /**
      * Fires when the app may wish to warn the user about something related
diff --git a/src/models/room.ts b/src/models/room.ts
index 6d3c14398ff..f81c63a1e91 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -207,7 +207,7 @@ export type RoomEventHandlerMap = {
      * });
      * ```
      */
-    [RoomEvent.Receipt]: (event: MatrixEvent, room: Room) => void
+    [RoomEvent.Receipt]: (event: MatrixEvent, room: Room) => void;
     /**
      * Fires whenever the name of a room is updated.
      * @param room - The room whose Room.name was updated.
@@ -217,7 +217,7 @@ export type RoomEventHandlerMap = {
      *   var newName = room.name;
      * });
      * ```
-     */;
+     */
     [RoomEvent.Name]: (room: Room) => void;
     /**
      * Fires when an event we had previously received is redacted.

From 559fbdda268289420d05ffe7e2cd694946b4d3c4 Mon Sep 17 00:00:00 2001
From: Michael Weimann <michaelw@matrix.org>
Date: Fri, 9 Dec 2022 09:54:36 +0100
Subject: [PATCH 38/60] Update eslint-plugin-matrix-org

---
 yarn.lock | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/yarn.lock b/yarn.lock
index d562f256aee..d60a1bec464 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3387,7 +3387,7 @@ eslint-plugin-jsdoc@^39.6.4:
 
 "eslint-plugin-matrix-org@https://github.com/matrix-org/eslint-plugin-matrix-org.git#weeman1337/prettier":
   version "0.8.0"
-  resolved "https://github.com/matrix-org/eslint-plugin-matrix-org.git#4c5e82dc6daa70b5d71ca8f8a55ff2e2cb6f802e"
+  resolved "https://github.com/matrix-org/eslint-plugin-matrix-org.git#e5b593c4e1f32e7597ba4e417239aaba9b96da8e"
 
 eslint-plugin-tsdoc@^0.2.17:
   version "0.2.17"

From 6e0901258c38949105aa2fb9bb6db93d0896401b Mon Sep 17 00:00:00 2001
From: Michael Weimann <michaelw@matrix.org>
Date: Fri, 9 Dec 2022 10:51:15 +0100
Subject: [PATCH 39/60] Switch to eslint-plugin-matrix-org 0.9

---
 package.json | 2 +-
 yarn.lock    | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/package.json b/package.json
index 3b58bb25633..128de735ea3 100644
--- a/package.json
+++ b/package.json
@@ -103,7 +103,7 @@
         "eslint-import-resolver-typescript": "^3.5.1",
         "eslint-plugin-import": "^2.26.0",
         "eslint-plugin-jsdoc": "^39.6.4",
-        "eslint-plugin-matrix-org": "https://github.com/matrix-org/eslint-plugin-matrix-org.git#weeman1337/prettier",
+        "eslint-plugin-matrix-org": "^0.9.0",
         "eslint-plugin-tsdoc": "^0.2.17",
         "eslint-plugin-unicorn": "^45.0.0",
         "exorcist": "^2.0.0",
diff --git a/yarn.lock b/yarn.lock
index d60a1bec464..c4d494579ad 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3385,9 +3385,10 @@ eslint-plugin-jsdoc@^39.6.4:
     semver "^7.3.8"
     spdx-expression-parse "^3.0.1"
 
-"eslint-plugin-matrix-org@https://github.com/matrix-org/eslint-plugin-matrix-org.git#weeman1337/prettier":
-  version "0.8.0"
-  resolved "https://github.com/matrix-org/eslint-plugin-matrix-org.git#e5b593c4e1f32e7597ba4e417239aaba9b96da8e"
+eslint-plugin-matrix-org@^0.9.0:
+  version "0.9.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-matrix-org/-/eslint-plugin-matrix-org-0.9.0.tgz#b2a5186052ddbfa7dc9878779bafa5d68681c7b4"
+  integrity sha512-+j6JuMnFH421Z2vOxc+0YMt5Su5vD76RSatviy3zHBaZpgd+sOeAWoCLBHD5E7mMz5oKae3Y3wewCt9LRzq2Nw==
 
 eslint-plugin-tsdoc@^0.2.17:
   version "0.2.17"

From 5b6bebc1d7ebce4aaf152e6e70b0cb928e5b5f5a Mon Sep 17 00:00:00 2001
From: Germain <germains@element.io>
Date: Fri, 9 Dec 2022 12:41:51 +0000
Subject: [PATCH 40/60] Do not calculate highlight notifs for threads unknown
 to the room (#2957)

---
 spec/unit/notifications.spec.ts | 23 +++++++++++++++++++++++
 src/client.ts                   | 18 +++++++++++++++---
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/spec/unit/notifications.spec.ts b/spec/unit/notifications.spec.ts
index b94f9cd9c10..144afb70f12 100644
--- a/spec/unit/notifications.spec.ts
+++ b/spec/unit/notifications.spec.ts
@@ -141,6 +141,29 @@ describe("fixNotificationCountOnDecryption", () => {
         expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight)).toBe(0);
     });
 
+    it("does not calculate for threads unknown to the room", () => {
+        room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total, 0);
+        room.setThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight, 0);
+
+        const unknownThreadEvent = mkEvent({
+            type: EventType.RoomMessage,
+            content: {
+                "m.relates_to": {
+                    rel_type: RelationType.Thread,
+                    event_id: "$unknownthread",
+                },
+                "msgtype": MsgType.Text,
+                "body": "Thread reply",
+            },
+            event: true,
+        });
+
+        fixNotificationCountOnDecryption(mockClient, unknownThreadEvent);
+
+        expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Total)).toBe(0);
+        expect(room.getThreadUnreadNotificationCount(THREAD_ID, NotificationCountType.Highlight)).toBe(0);
+    });
+
     it("emits events", () => {
         const cb = jest.fn();
         room.on(RoomEvent.UnreadNotifications, cb);
diff --git a/src/client.ts b/src/client.ts
index 3ff3b2c009b..64c6e15c425 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -9297,9 +9297,21 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
     if (oldHighlight !== newHighlight || currentCount > 0) {
         // TODO: Handle mentions received while the client is offline
         // See also https://github.com/vector-im/element-web/issues/9069
-        const hasReadEvent = isThreadEvent
-            ? room.getThread(event.threadRootId)?.hasUserReadEvent(cli.getUserId()!, event.getId()!)
-            : room.hasUserReadEvent(cli.getUserId()!, event.getId()!);
+        let hasReadEvent;
+        if (isThreadEvent) {
+            const thread = room.getThread(event.threadRootId);
+            hasReadEvent = thread
+                ? thread.hasUserReadEvent(cli.getUserId()!, event.getId()!)
+                // If the thread object does not exist in the room yet, we don't
+                // want to calculate notification for this event yet. We have not
+                // restored the read receipts yet and can't accurately calculate
+                // highlight notifications at this stage.
+                //
+                // This issue can likely go away when MSC3874 is implemented
+                : true;
+        } else {
+            hasReadEvent = room.hasUserReadEvent(cli.getUserId()!, event.getId()!);
+        }
 
         if (!hasReadEvent) {
             let newCount = currentCount;

From 41d762171eef529a588ce79b0b203b9c80b38cd9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Damir=20Jeli=C4=87?= <poljar@termina.org.uk>
Date: Fri, 9 Dec 2022 15:03:49 +0100
Subject: [PATCH 41/60] Apply prettier to the client.ts file (#2959)

---
 src/client.ts | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/client.ts b/src/client.ts
index 64c6e15c425..66b16903039 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -9302,13 +9302,13 @@ export function fixNotificationCountOnDecryption(cli: MatrixClient, event: Matri
             const thread = room.getThread(event.threadRootId);
             hasReadEvent = thread
                 ? thread.hasUserReadEvent(cli.getUserId()!, event.getId()!)
-                // If the thread object does not exist in the room yet, we don't
-                // want to calculate notification for this event yet. We have not
-                // restored the read receipts yet and can't accurately calculate
-                // highlight notifications at this stage.
-                //
-                // This issue can likely go away when MSC3874 is implemented
-                : true;
+                : // If the thread object does not exist in the room yet, we don't
+                  // want to calculate notification for this event yet. We have not
+                  // restored the read receipts yet and can't accurately calculate
+                  // highlight notifications at this stage.
+                  //
+                  // This issue can likely go away when MSC3874 is implemented
+                  true;
         } else {
             hasReadEvent = room.hasUserReadEvent(cli.getUserId()!, event.getId()!);
         }

From ada401f4c010bc0227add921e2647e751430e624 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Damir=20Jeli=C4=87?= <poljar@termina.org.uk>
Date: Fri, 9 Dec 2022 15:46:33 +0100
Subject: [PATCH 42/60] Make sure that MegolmEncryption.setupPromise always
 resolves  (#2960)

ensureOutboundSession uses and modifies the setupPromise of the
MegolmEncryption class. Some comments suggest that setupPromise will
always resolve, in other words it should never contain a promise that
will get rejected.

Other comments also seem to suggest that the return value of
ensureOutboundSession, a promise as well, may fail.

The critical error here is that the promise that gets set as
the next setupPromise, as well as the promise that ensureOutboundSession
returns, is the same promise.

It seems that the intention was for setupPromise to contain a promise
that will always resolve to either `null` or `OutboundSessionInfo`.

We can see that a couple of lines before we set setupPromise to its new
value we construct a promise that logs and discards errors using the
`Promise.catch()` method.

The `Promise.catch()` method does not mutate the promise, instead it
returns a new promise. The intention of the original author might have
been to set the next setupPromise to the promise which `Promise.catch()`
produces.

This patch modifies the updating of setupPromise in the
ensureOutboundSession so that setupPromise discards errors correctly.

Using `>>=` to represent the promise chaining operation, setupPromise is
now updated using the following logic:

    setupPromise = previousSetupPromise >>= setup >>= discardErrors
---
 spec/unit/crypto/algorithms/megolm.spec.ts | 20 +++++++++++++
 src/crypto/algorithms/megolm.ts            | 33 +++++++++++++++++-----
 2 files changed, 46 insertions(+), 7 deletions(-)

diff --git a/spec/unit/crypto/algorithms/megolm.spec.ts b/spec/unit/crypto/algorithms/megolm.spec.ts
index 5b00466d826..2dca6765d1c 100644
--- a/spec/unit/crypto/algorithms/megolm.spec.ts
+++ b/spec/unit/crypto/algorithms/megolm.spec.ts
@@ -490,6 +490,26 @@ describe("MegolmDecryption", function () {
 
                 expect(mockBaseApis.queueToDevice).not.toHaveBeenCalled();
             });
+
+            it("shouldn't wedge the setup promise if sharing a room key fails", async () => {
+                // @ts-ignore - private field access
+                const initialSetupPromise = await megolmEncryption.setupPromise;
+                expect(initialSetupPromise).toBe(null);
+
+                // @ts-ignore - private field access
+                megolmEncryption.prepareSession = () => {
+                    throw new Error("Can't prepare session");
+                };
+
+                await expect(() =>
+                    // @ts-ignore - private field access
+                    megolmEncryption.ensureOutboundSession(mockRoom, {}, {}, true),
+                ).rejects.toThrow();
+
+                // @ts-ignore - private field access
+                const finalSetupPromise = await megolmEncryption.setupPromise;
+                expect(finalSetupPromise).toBe(null);
+            });
         });
     });
 
diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index aed0ab28fef..e002ffa3d91 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -248,6 +248,23 @@ export class MegolmEncryption extends EncryptionAlgorithm {
      * @param singleOlmCreationPhase - Only perform one round of olm
      *     session creation
      *
+     * This method updates the setupPromise field of the class by chaining a new
+     * call on top of the existing promise, and then catching and discarding any
+     * errors that might happen while setting up the outbound group session. This
+     * is done to ensure that `setupPromise` always resolves to `null` or the
+     * `OutboundSessionInfo`.
+     *
+     * Using `>>=` to represent the promise chaining operation, it does the
+     * following:
+     *
+     * ```
+     * setupPromise = previousSetupPromise >>= setup >>= discardErrors
+     * ```
+     *
+     * The initial value for the `setupPromise` is a promise that resolves to
+     * `null`. The forceDiscardSession() resets setupPromise to this initial
+     * promise.
+     *
      * @returns Promise which resolves to the
      *    OutboundSessionInfo when setup is complete.
      */
@@ -278,18 +295,20 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         };
 
         // first wait for the previous share to complete
-        const prom = this.setupPromise.then(setup);
+        const fallible = this.setupPromise.then(setup);
 
-        // Ensure any failures are logged for debugging
-        prom.catch((e) => {
+        // Ensure any failures are logged for debugging and make sure that the
+        // promise chain remains unbroken
+        //
+        // setupPromise resolves to `null` or the `OutboundSessionInfo` whether
+        // or not the share succeeds
+        this.setupPromise = fallible.catch((e) => {
             logger.error(`Failed to setup outbound session in ${this.roomId}`, e);
+            return null;
         });
 
-        // setupPromise resolves to `session` whether or not the share succeeds
-        this.setupPromise = prom;
-
         // but we return a promise which only resolves if the share was successful.
-        return prom;
+        return fallible;
     }
 
     private async prepareSession(

From fc501de081f30706474aef51272564262ef5b814 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Damir=20Jeli=C4=87?= <poljar@termina.org.uk>
Date: Fri, 9 Dec 2022 16:07:42 +0100
Subject: [PATCH 43/60] Don't swallow up errors coming from the shareSession
 call (#2962)

A call to ensureSession() has two steps:
    1. prepareSession(), where an outbound group session might get created
       or rotated
    2. shareSession(), where an outbound group session might get
       encrypted and queued up to be sent to other devices

Both of those calls may mostly fail due to storage errors, yet only the
errors from prepareSession get propagated to the caller.

Errors from prepareSession will mean that you can't get an
outbound group session so you can't encrypt an event.

Errors from shareSession, especially if the error happens in the part
where the to-device requests are queued up to be sent out, mean that
other people will not be able to decrypt the events that will get
encrypted using the outbound group session.

Both of those cases are catastrophic, the second case is just much
harder to debug, since the error happens on another device at some
arbitrary point in the future.

Let's just return the error instead, people can then retry and the
storage issue might have been resolved, or at least the error becomes
visible when it happens.
---
 src/crypto/algorithms/megolm.ts | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index e002ffa3d91..e8816569339 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -277,19 +277,12 @@ export class MegolmEncryption extends EncryptionAlgorithm {
         // takes the previous OutboundSessionInfo, and considers whether to create
         // a new one. Also shares the key with any (new) devices in the room.
         //
-        // Returns the successful session whether keyshare succeeds or not.
-        //
         // returns a promise which resolves once the keyshare is successful.
         const setup = async (oldSession: OutboundSessionInfo | null): Promise<OutboundSessionInfo> => {
             const sharedHistory = isRoomSharedHistory(room);
-
             const session = await this.prepareSession(devicesInRoom, sharedHistory, oldSession);
 
-            try {
-                await this.shareSession(devicesInRoom, sharedHistory, singleOlmCreationPhase, blocked, session);
-            } catch (e) {
-                logger.error(`Failed to ensure outbound session in ${this.roomId}`, e);
-            }
+            await this.shareSession(devicesInRoom, sharedHistory, singleOlmCreationPhase, blocked, session);
 
             return session;
         };

From 2dd06e368ece682d0bbcef128f8931b972525167 Mon Sep 17 00:00:00 2001
From: Germain <germains@element.io>
Date: Fri, 9 Dec 2022 15:20:50 +0000
Subject: [PATCH 44/60] Fix infinite loop when restoring cached read receipts
 (#2963)

---
 src/models/room.ts   | 16 +++++-----------
 src/models/thread.ts | 25 ++++++++++++++++++++++++-
 2 files changed, 29 insertions(+), 12 deletions(-)

diff --git a/src/models/room.ts b/src/models/room.ts
index f81c63a1e91..8b88b984226 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -2079,8 +2079,13 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
             room: this,
             client: this.client,
             pendingEventOrdering: this.opts.pendingEventOrdering,
+            receipts: this.cachedThreadReadReceipts.get(threadId) ?? [],
         });
 
+        // All read receipts should now come down from sync, we do not need to keep
+        // a reference to the cached receipts anymore.
+        this.cachedThreadReadReceipts.delete(threadId);
+
         // This is necessary to be able to jump to events in threads:
         // If we jump to an event in a thread where neither the event, nor the root,
         // nor any thread event are loaded yet, we'll load the event as well as the thread root, create the thread,
@@ -2110,17 +2115,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         if (this.threadsReady) {
             this.updateThreadRootEvents(thread, toStartOfTimeline, false);
         }
-
-        // Pulling all the cached thread read receipts we've discovered when we
-        // did an initial sync, and applying them to the thread now that it exists
-        // on the client side
-        if (this.cachedThreadReadReceipts.has(threadId)) {
-            for (const { event, synthetic } of this.cachedThreadReadReceipts.get(threadId)!) {
-                this.addReceipt(event, synthetic);
-            }
-            this.cachedThreadReadReceipts.delete(threadId);
-        }
-
         this.emit(ThreadEvent.New, thread, toStartOfTimeline);
 
         return thread;
diff --git a/src/models/thread.ts b/src/models/thread.ts
index 998c2156912..8237e0a5bc7 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -27,7 +27,7 @@ import { RoomState } from "./room-state";
 import { ServerControlledNamespacedValue } from "../NamespacedValue";
 import { logger } from "../logger";
 import { ReadReceipt } from "./read-receipt";
-import { ReceiptType } from "../@types/read_receipts";
+import { Receipt, ReceiptContent, ReceiptType } from "../@types/read_receipts";
 
 export enum ThreadEvent {
     New = "Thread.new",
@@ -50,6 +50,7 @@ interface IThreadOpts {
     room: Room;
     client: MatrixClient;
     pendingEventOrdering?: PendingEventOrdering;
+    receipts?: { event: MatrixEvent; synthetic: boolean }[];
 }
 
 export enum FeatureSupport {
@@ -127,6 +128,8 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         this.room.on(RoomEvent.LocalEchoUpdated, this.onEcho);
         this.timelineSet.on(RoomEvent.Timeline, this.onTimelineEvent);
 
+        this.processReceipts(opts.receipts);
+
         // even if this thread is thought to be originating from this client, we initialise it as we may be in a
         // gappy sync and a thread around this event may already exist.
         this.updateThreadMetadata();
@@ -284,6 +287,26 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         this.timeline = this.events;
     }
 
+    /**
+     * Processes the receipts that were caught during initial sync
+     * When clients become aware of a thread, they try to retrieve those read receipts
+     * and apply them to the current thread
+     * @param receipts - A collection of the receipts cached from initial sync
+     */
+    private processReceipts(receipts: { event: MatrixEvent; synthetic: boolean }[] = []): void {
+        for (const { event, synthetic } of receipts) {
+            const content = event.getContent<ReceiptContent>();
+            Object.keys(content).forEach((eventId: string) => {
+                Object.keys(content[eventId]).forEach((receiptType: ReceiptType | string) => {
+                    Object.keys(content[eventId][receiptType]).forEach((userId: string) => {
+                        const receipt = content[eventId][receiptType][userId] as Receipt;
+                        this.addReceiptToStructure(eventId, receiptType as ReceiptType, userId, receipt, synthetic);
+                    });
+                });
+            });
+        }
+    }
+
     private getRootEventBundledRelationship(rootEvent = this.rootEvent): IThreadBundledRelationship | undefined {
         return rootEvent?.getServerAggregatedRelation<IThreadBundledRelationship>(THREAD_RELATION_TYPE.name);
     }

From 8a892ede23aa72450bb2541218b2850b0c1d0468 Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Mon, 12 Dec 2022 10:37:52 +0000
Subject: [PATCH 45/60] Exclude generated files from prettier (#2961)

The example directories include symlinks to the generated matrix.js, which we
should not prettify.
---
 .prettierignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.prettierignore b/.prettierignore
index 4e86facef78..5a329d581e6 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -11,6 +11,9 @@ lib-cov
 out
 /dist
 /lib
+/examples/browser/lib
+/examples/crypto-browser/lib
+/examples/voip/lib
 
 # version file and tarball created by `npm pack` / `yarn pack`
 /git-revision.txt

From 66c678e9fb52ea12be853ab41973f94e9a78346b Mon Sep 17 00:00:00 2001
From: Janne Mareike Koschinski <jannemk@element.io>
Date: Mon, 12 Dec 2022 16:30:48 +0100
Subject: [PATCH 46/60] Fix #23919: Root message for new thread loaded from
 network (#2965)

* Load root events of threads without additional network roundtrip
---
 src/models/thread.ts | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/models/thread.ts b/src/models/thread.ts
index 8237e0a5bc7..ec1bd167685 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -20,7 +20,7 @@ import { MatrixClient, PendingEventOrdering } from "../client";
 import { TypedReEmitter } from "../ReEmitter";
 import { RelationType } from "../@types/event";
 import { EventStatus, IThreadBundledRelationship, MatrixEvent, MatrixEventEvent } from "./event";
-import { EventTimeline } from "./event-timeline";
+import { Direction, EventTimeline } from "./event-timeline";
 import { EventTimelineSet, EventTimelineSetHandlerMap } from "./event-timeline-set";
 import { NotificationCountType, Room, RoomEvent } from "./room";
 import { RoomState } from "./room-state";
@@ -358,7 +358,15 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             try {
                 // if the thread has regular events, this will just load the last reply.
                 // if the thread is newly created, this will load the root event.
-                await this.client.paginateEventTimeline(this.liveTimeline, { backwards: true, limit: 1 });
+                if (this.replyCount === 0 && this.rootEvent) {
+                    this.timelineSet.addEventsToTimeline([this.rootEvent], true, this.liveTimeline, null);
+                    this.liveTimeline.setPaginationToken(null, Direction.Backward);
+                } else {
+                    await this.client.paginateEventTimeline(this.liveTimeline, {
+                        backwards: true,
+                        limit: Math.max(1, this.length),
+                    });
+                }
                 // just to make sure that, if we've created a timeline window for this thread before the thread itself
                 // existed (e.g. when creating a new thread), we'll make sure the panel is force refreshed correctly.
                 this.emit(RoomEvent.TimelineReset, this.room, this.timelineSet, true);

From 4c5f416b329f3922b786c41375c7bff4779d2472 Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Mon, 12 Dec 2022 16:31:56 +0000
Subject: [PATCH 47/60] Factor out some utility functions in the megolm
 integration tests (#2958)

There's a lot of repetition here, which can be reduced with some utility functions.
---
 spec/integ/megolm-integ.spec.ts | 291 ++++++++++++++++----------------
 1 file changed, 147 insertions(+), 144 deletions(-)

diff --git a/spec/integ/megolm-integ.spec.ts b/spec/integ/megolm-integ.spec.ts
index 1280cc98cb6..fcdfa8694fa 100644
--- a/spec/integ/megolm-integ.spec.ts
+++ b/spec/integ/megolm-integ.spec.ts
@@ -1,6 +1,6 @@
 /*
 Copyright 2016 OpenMarket Ltd
-Copyright 2019 The Matrix.org Foundation C.I.C.
+Copyright 2019-2022 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.
@@ -16,6 +16,7 @@ limitations under the License.
 */
 
 import anotherjson from "another-json";
+import MockHttpBackend from "matrix-mock-request";
 
 import * as testUtils from "../test-utils/test-utils";
 import { TestClient } from "../TestClient";
@@ -203,6 +204,117 @@ function getSyncResponse(roomMembers: string[]): ISyncResponse {
     };
 }
 
+/**
+ * Establish an Olm Session with the test user
+ *
+ * Waits for the test user to upload their keys, then sends a /sync response with a to-device message which will
+ * establish an Olm session.
+ *
+ * @param testClient: a TestClient for the user under test, which we expect to upload account keys, and to make a
+ *    /sync request which we will respond to.
+ * @param peerOlmAccount: an OlmAccount which will be used to initiate the Olm session.
+ */
+async function establishOlmSession(testClient: TestClient, peerOlmAccount: Olm.Account): Promise<Olm.Session> {
+    const peerE2EKeys = JSON.parse(peerOlmAccount.identity_keys());
+    const p2pSession = await createOlmSession(peerOlmAccount, testClient);
+    const olmEvent = encryptOlmEvent({
+        senderKey: peerE2EKeys.curve25519,
+        recipient: testClient,
+        p2pSession: p2pSession,
+    });
+    testClient.httpBackend.when("GET", "/sync").respond(200, {
+        next_batch: 1,
+        to_device: { events: [olmEvent] },
+    });
+    await testClient.flushSync();
+    return p2pSession;
+}
+
+/**
+ * Expect that the client shares keys with the given recipient
+ *
+ * Waits for an HTTP request to send the encrypted m.room_key to-device message; decrypts it and uses it
+ * to establish an Olm InboundGroupSession.
+ *
+ * @param senderMockHttpBackend - MockHttpBackend for the sender
+ *
+ * @param recipientUserID - the user id of the expected recipient
+ *
+ * @param recipientOlmAccount - Olm.Account for the recipient
+ *
+ * @param recipientOlmSession - an Olm.Session for the recipient, which must already have exchanged pre-key
+ *    messages with the sender. Alternatively, null, in which case we will expect a pre-key message.
+ *
+ * @returns the established inbound group session
+ */
+async function expectSendRoomKey(
+    senderMockHttpBackend: MockHttpBackend,
+    recipientUserID: string,
+    recipientOlmAccount: Olm.Account,
+    recipientOlmSession: Olm.Session | null = null,
+): Promise<Olm.InboundGroupSession> {
+    const Olm = global.Olm;
+    const testRecipientKey = JSON.parse(recipientOlmAccount.identity_keys())["curve25519"];
+
+    let inboundGroupSession: Olm.InboundGroupSession;
+
+    senderMockHttpBackend.when("PUT", "/sendToDevice/m.room.encrypted/").respond(200, (_path, content: any) => {
+        const m = content.messages[recipientUserID].DEVICE_ID;
+        const ct = m.ciphertext[testRecipientKey];
+
+        if (!recipientOlmSession) {
+            expect(ct.type).toEqual(0); // pre-key message
+            recipientOlmSession = new Olm.Session();
+            recipientOlmSession.create_inbound(recipientOlmAccount, ct.body);
+        } else {
+            expect(ct.type).toEqual(1); // regular message
+        }
+
+        const decrypted = JSON.parse(recipientOlmSession.decrypt(ct.type, ct.body));
+        expect(decrypted.type).toEqual("m.room_key");
+        inboundGroupSession = new Olm.InboundGroupSession();
+        inboundGroupSession.create(decrypted.content.session_key);
+        return {};
+    });
+
+    expect(await senderMockHttpBackend.flush("/sendToDevice/m.room.encrypted/", 1, 1000)).toEqual(1);
+    return inboundGroupSession!;
+}
+
+/**
+ * Expect that the client sends an encrypted event
+ *
+ * Waits for an HTTP request to send an encrypted message in the test room.
+ *
+ * @param senderMockHttpBackend - MockHttpBackend for the sender
+ *
+ * @param inboundGroupSessionPromise - a promise for an Olm InboundGroupSession, which will
+ *    be used to decrypt the event. We will wait for this to resolve once the HTTP request has been processed.
+ *
+ * @returns The content of the successfully-decrypted event
+ */
+async function expectSendMegolmMessage(
+    senderMockHttpBackend: MockHttpBackend,
+    inboundGroupSessionPromise: Promise<Olm.InboundGroupSession>,
+): Promise<Partial<IEvent>> {
+    let encryptedMessageContent: IContent | null = null;
+    senderMockHttpBackend.when("PUT", "/send/m.room.encrypted/").respond(200, function (_path, content: IContent) {
+        encryptedMessageContent = content;
+        return {
+            event_id: "$event_id",
+        };
+    });
+
+    expect(await senderMockHttpBackend.flush("/send/m.room.encrypted/", 1, 1000)).toEqual(1);
+
+    // In some of the tests, the room key is sent *after* the actual event, so we may need to wait for it now.
+    const inboundGroupSession = await inboundGroupSessionPromise;
+
+    const r: any = inboundGroupSession.decrypt(encryptedMessageContent!.ciphertext);
+    logger.log("Decrypted received megolm message", r);
+    return JSON.parse(r.plaintext);
+}
+
 describe("megolm", () => {
     if (!global.Olm) {
         logger.warn("not running megolm tests: Olm not present");
@@ -463,20 +575,9 @@ describe("megolm", () => {
     it("Alice sends a megolm message", async () => {
         aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
-        // establish an olm session with alice
-        const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
-
-        const syncResponse = getSyncResponse(["@bob:xyz"]);
-
-        const olmEvent = encryptOlmEvent({
-            senderKey: testSenderKey,
-            recipient: aliceTestClient,
-            p2pSession: p2pSession,
-        });
-
-        syncResponse.to_device = { events: [olmEvent] };
+        const p2pSession = await establishOlmSession(aliceTestClient, testOlmAccount);
 
-        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
         await aliceTestClient.flushSync();
 
         // start out with the device unknown - the send should be rejected.
@@ -498,60 +599,28 @@ describe("megolm", () => {
         // mark the device as known, and resend.
         aliceTestClient.client.setDeviceKnown("@bob:xyz", "DEVICE_ID");
 
-        let inboundGroupSession: Olm.InboundGroupSession;
-        aliceTestClient.httpBackend
-            .when("PUT", "/sendToDevice/m.room.encrypted/")
-            .respond(200, function (_path, content: any) {
-                const m = content.messages["@bob:xyz"].DEVICE_ID;
-                const ct = m.ciphertext[testSenderKey];
-                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
-
-                expect(decrypted.type).toEqual("m.room_key");
-                inboundGroupSession = new Olm.InboundGroupSession();
-                inboundGroupSession.create(decrypted.content.session_key);
-                return {};
-            });
-
-        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, (_path, content: IContent) => {
-            const ct = content.ciphertext;
-            const r: any = inboundGroupSession.decrypt(ct);
-            logger.log("Decrypted received megolm message", r);
-
-            expect(r.message_index).toEqual(0);
-            const decrypted = JSON.parse(r.plaintext);
-            expect(decrypted.type).toEqual("m.room.message");
-            expect(decrypted.content.body).toEqual("test");
-
-            return { event_id: "$event_id" };
-        });
-
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
         const pendingMsg = room.getPendingEvents()[0];
 
+        const inboundGroupSessionPromise = expectSendRoomKey(
+            aliceTestClient.httpBackend,
+            "@bob:xyz",
+            testOlmAccount,
+            p2pSession,
+        );
+
         await Promise.all([
             aliceTestClient.client.resendEvent(pendingMsg, room),
-
-            // the crypto stuff can take a while, so give the requests a whole second.
-            aliceTestClient.httpBackend.flushAllExpected({ timeout: 1000 }),
+            expectSendMegolmMessage(aliceTestClient.httpBackend, inboundGroupSessionPromise),
         ]);
     });
 
     it("We shouldn't attempt to send to blocked devices", async () => {
         aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
-        // establish an olm session with alice
-        const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
-        const syncResponse = getSyncResponse(["@bob:xyz"]);
-
-        const olmEvent = encryptOlmEvent({
-            senderKey: testSenderKey,
-            recipient: aliceTestClient,
-            p2pSession: p2pSession,
-        });
-
-        syncResponse.to_device = { events: [olmEvent] };
-        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+        await establishOlmSession(aliceTestClient, testOlmAccount);
 
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
         await aliceTestClient.flushSync();
 
         logger.log("Forcing alice to download our device keys");
@@ -584,20 +653,9 @@ describe("megolm", () => {
     it("We should start a new megolm session when a device is blocked", async () => {
         aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
-        // establish an olm session with alice
-        const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
-
-        const syncResponse = getSyncResponse(["@bob:xyz"]);
-
-        const olmEvent = encryptOlmEvent({
-            senderKey: testSenderKey,
-            recipient: aliceTestClient,
-            p2pSession: p2pSession,
-        });
-
-        syncResponse.to_device = { events: [olmEvent] };
-        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+        const p2pSession = await establishOlmSession(aliceTestClient, testOlmAccount);
 
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
         await aliceTestClient.flushSync();
 
         logger.log("Fetching bob's devices and marking known");
@@ -614,33 +672,19 @@ describe("megolm", () => {
         logger.log("Telling alice to send a megolm message");
 
         let megolmSessionId: string;
-        aliceTestClient.httpBackend
-            .when("PUT", "/sendToDevice/m.room.encrypted/")
-            .respond(200, function (_path, content: any) {
-                logger.log("sendToDevice: ", content);
-                const m = content.messages["@bob:xyz"].DEVICE_ID;
-                const ct = m.ciphertext[testSenderKey];
-                expect(ct.type).toEqual(1); // normal message
-                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
-                logger.log("decrypted sendToDevice:", decrypted);
-                expect(decrypted.type).toEqual("m.room_key");
-                megolmSessionId = decrypted.content.session_id;
-                return {};
-            });
-
-        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, function (_path, content) {
-            logger.log("/send:", content);
-            expect(content.session_id).toEqual(megolmSessionId);
-            return {
-                event_id: "$event_id",
-            };
+        const inboundGroupSessionPromise = expectSendRoomKey(
+            aliceTestClient.httpBackend,
+            "@bob:xyz",
+            testOlmAccount,
+            p2pSession,
+        );
+        inboundGroupSessionPromise.then((igs) => {
+            megolmSessionId = igs.session_id();
         });
 
         await Promise.all([
             aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
-
-            // the crypto stuff can take a while, so give the requests a whole second.
-            aliceTestClient.httpBackend.flushAllExpected({ timeout: 1000 }),
+            expectSendMegolmMessage(aliceTestClient.httpBackend, inboundGroupSessionPromise),
         ]);
 
         logger.log("Telling alice to block our device");
@@ -649,6 +693,7 @@ describe("megolm", () => {
         logger.log("Telling alice to send another megolm message");
         aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, function (_path, content) {
             logger.log("/send:", content);
+            // make sure that a new session is used
             expect(content.session_id).not.toEqual(megolmSessionId);
             return {
                 event_id: "$event_id",
@@ -718,43 +763,13 @@ describe("megolm", () => {
                 return getTestKeysClaimResponse(aliceTestClient.userId!);
             });
 
-        let p2pSession: Olm.Session;
-        let inboundGroupSession: Olm.InboundGroupSession;
-        aliceTestClient.httpBackend.when("PUT", "/sendToDevice/m.room.encrypted/").respond(
-            200,
-            function (
-                _path,
-                content: {
-                    messages: { [userId: string]: { [deviceId: string]: Record<string, any> } };
-                },
-            ) {
-                logger.log("sendToDevice: ", content);
-                const m = content.messages[aliceTestClient.userId!].DEVICE_ID;
-                const ct = m.ciphertext[testSenderKey];
-                expect(ct.type).toEqual(0); // pre-key message
-
-                p2pSession = new Olm.Session();
-                p2pSession.create_inbound(testOlmAccount, ct.body);
-                const decrypted = JSON.parse(p2pSession.decrypt(ct.type, ct.body));
-
-                expect(decrypted.type).toEqual("m.room_key");
-                inboundGroupSession = new Olm.InboundGroupSession();
-                inboundGroupSession.create(decrypted.content.session_key);
-                return {};
-            },
+        const inboundGroupSessionPromise = expectSendRoomKey(
+            aliceTestClient.httpBackend,
+            aliceTestClient.userId!,
+            testOlmAccount,
         );
 
         let decrypted: Partial<IEvent> = {};
-        aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, function (_path, content: IContent) {
-            const ct = content.ciphertext;
-            const r: any = inboundGroupSession.decrypt(ct);
-            logger.log("Decrypted received megolm message", r);
-            decrypted = JSON.parse(r.plaintext);
-
-            return {
-                event_id: "$event_id",
-            };
-        });
 
         // Grab the event that we'll need to resend
         const room = aliceTestClient.client.getRoom(ROOM_ID)!;
@@ -763,12 +778,11 @@ describe("megolm", () => {
         const unsentEvent = pendingEvents[0];
 
         await Promise.all([
-            aliceTestClient.client.resendEvent(unsentEvent, room),
-
-            // the crypto stuff can take a while, so give the requests a whole second.
-            aliceTestClient.httpBackend.flushAllExpected({
-                timeout: 1000,
+            aliceTestClient.httpBackend.flush("/keys/claim", 1, 1000),
+            expectSendMegolmMessage(aliceTestClient.httpBackend, inboundGroupSessionPromise).then((d) => {
+                decrypted = d;
             }),
+            aliceTestClient.client.resendEvent(unsentEvent, room),
         ]);
 
         expect(decrypted.type).toEqual("m.room.message");
@@ -778,20 +792,9 @@ describe("megolm", () => {
     it("Alice should wait for device list to complete when sending a megolm message", async () => {
         aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
-        // establish an olm session with alice
-        const p2pSession = await createOlmSession(testOlmAccount, aliceTestClient);
-
-        const syncResponse = getSyncResponse(["@bob:xyz"]);
-
-        const olmEvent = encryptOlmEvent({
-            senderKey: testSenderKey,
-            recipient: aliceTestClient,
-            p2pSession: p2pSession,
-        });
-
-        syncResponse.to_device = { events: [olmEvent] };
+        await establishOlmSession(aliceTestClient, testOlmAccount);
 
-        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, syncResponse);
+        aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
         await aliceTestClient.flushSync();
 
         // this will block

From 8293011ee2086827a3d2c68b71085331cb9d5413 Mon Sep 17 00:00:00 2001
From: Janne Mareike Koschinski <jannemk@element.io>
Date: Mon, 12 Dec 2022 18:22:16 +0100
Subject: [PATCH 48/60] Fix #23916: Prevent edits of the last message in a
 thread getting lost (#2951)

* Fix issue where the root event of a thread had to be loaded in a complicated way
* Fix issue where edits to the last event of a thread would get lost
* Fix issue where thread reply count would desync
* Refactor relations pagination mocking for tests
---
 .../matrix-client-event-timeline.spec.ts      | 114 +++++-------------
 spec/test-utils/thread.ts                     |   3 -
 spec/unit/room.spec.ts                        |  17 +--
 src/models/room.ts                            |   4 +-
 src/models/thread.ts                          |  58 ++++-----
 5 files changed, 70 insertions(+), 126 deletions(-)

diff --git a/spec/integ/matrix-client-event-timeline.spec.ts b/spec/integ/matrix-client-event-timeline.spec.ts
index 63d47540a30..a520895160f 100644
--- a/spec/integ/matrix-client-event-timeline.spec.ts
+++ b/spec/integ/matrix-client-event-timeline.spec.ts
@@ -27,12 +27,11 @@ import {
     MatrixEvent,
     PendingEventOrdering,
     Room,
-    RoomEvent,
 } from "../../src/matrix";
 import { logger } from "../../src/logger";
-import { encodeUri } from "../../src/utils";
+import { encodeParams, encodeUri, QueryDict, replaceParam } from "../../src/utils";
 import { TestClient } from "../TestClient";
-import { FeatureSupport, Thread, THREAD_RELATION_TYPE } from "../../src/models/thread";
+import { FeatureSupport, Thread, THREAD_RELATION_TYPE, ThreadEvent } from "../../src/models/thread";
 import { emitPromise } from "../test-utils/test-utils";
 
 const userId = "@alice:localhost";
@@ -47,6 +46,18 @@ const withoutRoomId = (e: Partial<IEvent>): Partial<IEvent> => {
     return copy;
 };
 
+/**
+ * Our httpBackend only allows matching calls if we have the exact same query, in the exact same order
+ * This method allows building queries with the exact same parameter order as the fetchRelations method in client
+ * @param params query parameters
+ */
+const buildRelationPaginationQuery = (params: QueryDict): string => {
+    if (Thread.hasServerSideFwdPaginationSupport === FeatureSupport.Experimental) {
+        params = replaceParam("dir", "org.matrix.msc3715.dir", params);
+    }
+    return "?" + encodeParams(params).toString();
+};
+
 const USER_MEMBERSHIP_EVENT = utils.mkMembership({
     room: roomId,
     mship: "join",
@@ -595,42 +606,6 @@ describe("MatrixClient event timelines", function () {
                 .respond(200, function () {
                     return THREAD_ROOT;
                 });
-
-            httpBackend
-                .when(
-                    "GET",
-                    "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
-                        encodeURIComponent(THREAD_ROOT.event_id!) +
-                        "/" +
-                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
-                        "?dir=b&limit=1",
-                )
-                .respond(200, function () {
-                    return {
-                        original_event: THREAD_ROOT,
-                        chunk: [THREAD_REPLY],
-                        // no next batch as this is the oldest end of the timeline
-                    };
-                });
-
-            const thread = room.createThread(THREAD_ROOT.event_id!, undefined, [], false);
-            await httpBackend.flushAllExpected();
-            const timelineSet = thread.timelineSet;
-
-            const timelinePromise = client.getEventTimeline(timelineSet, THREAD_REPLY.event_id!);
-            const timeline = await timelinePromise;
-
-            expect(timeline!.getEvents().find((e) => e.getId() === THREAD_ROOT.event_id!)).toBeTruthy();
-            expect(timeline!.getEvents().find((e) => e.getId() === THREAD_REPLY.event_id!)).toBeTruthy();
-        });
-
-        it("should handle thread replies with server support by fetching a contiguous thread timeline", async () => {
-            // @ts-ignore
-            client.clientOpts.experimentalThreadSupport = true;
-            Thread.setServerSideSupport(FeatureSupport.Experimental);
-            await client.stopClient(); // we don't need the client to be syncing at this time
-            const room = client.getRoom(roomId)!;
-
             httpBackend
                 .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
                 .respond(200, function () {
@@ -644,7 +619,7 @@ describe("MatrixClient event timelines", function () {
                         encodeURIComponent(THREAD_ROOT.event_id!) +
                         "/" +
                         encodeURIComponent(THREAD_RELATION_TYPE.name) +
-                        "?dir=b&limit=1",
+                        buildRelationPaginationQuery({ dir: Direction.Backward, limit: 1 }),
                 )
                 .respond(200, function () {
                     return {
@@ -656,15 +631,14 @@ describe("MatrixClient event timelines", function () {
             const thread = room.createThread(THREAD_ROOT.event_id!, undefined, [], false);
             await httpBackend.flushAllExpected();
             const timelineSet = thread.timelineSet;
-
             httpBackend
                 .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
                 .respond(200, function () {
                     return THREAD_ROOT;
                 });
+            await flushHttp(emitPromise(thread, ThreadEvent.Update));
 
-            const timelinePromise = client.getEventTimeline(timelineSet, THREAD_REPLY.event_id!);
-            const [timeline] = await Promise.all([timelinePromise, httpBackend.flushAllExpected()]);
+            const timeline = await client.getEventTimeline(timelineSet, THREAD_REPLY.event_id!);
 
             const eventIds = timeline!.getEvents().map((it) => it.getId());
             expect(eventIds).toContain(THREAD_ROOT.event_id);
@@ -1273,7 +1247,7 @@ describe("MatrixClient event timelines", function () {
                             event_id: THREAD_ROOT.event_id,
                         },
                     },
-                    event: false,
+                    event: true,
                 });
 
                 // Test data for the first thread, with the second reply
@@ -1286,7 +1260,7 @@ describe("MatrixClient event timelines", function () {
                             "io.element.thread": {
                                 ...THREAD_ROOT.unsigned!["m.relations"]!["io.element.thread"],
                                 count: 2,
-                                latest_event: THREAD_REPLY2,
+                                latest_event: THREAD_REPLY2.event,
                             },
                         },
                     },
@@ -1314,12 +1288,13 @@ describe("MatrixClient event timelines", function () {
                 respondToThreads(threadsResponse);
                 respondToThreads(threadsResponse);
                 respondToEvent(THREAD_ROOT);
-                respondToEvent(THREAD_ROOT);
-                respondToEvent(THREAD2_ROOT);
                 respondToEvent(THREAD2_ROOT);
                 respondToThread(THREAD_ROOT, [THREAD_REPLY]);
                 respondToThread(THREAD2_ROOT, [THREAD2_REPLY]);
                 await flushHttp(room.fetchRoomThreads());
+                const threadIds = room.getThreads().map((thread) => thread.id);
+                expect(threadIds).toContain(THREAD_ROOT.event_id);
+                expect(threadIds).toContain(THREAD2_ROOT.event_id);
                 const [allThreads] = timelineSets!;
                 const timeline = allThreads.getLiveTimeline()!;
                 // Test threads are in chronological order
@@ -1330,12 +1305,15 @@ describe("MatrixClient event timelines", function () {
 
                 // Test adding a second event to the first thread
                 const thread = room.getThread(THREAD_ROOT.event_id!)!;
-                const prom = emitPromise(allThreads!, RoomEvent.Timeline);
-                await thread.addEvent(client.getEventMapper()(THREAD_REPLY2), false);
+                const prom = emitPromise(room, ThreadEvent.NewReply);
+                respondToEvent(THREAD_ROOT_UPDATED);
                 respondToEvent(THREAD_ROOT_UPDATED);
                 respondToEvent(THREAD_ROOT_UPDATED);
+                respondToEvent(THREAD2_ROOT);
+                room.addLiveEvents([THREAD_REPLY2]);
                 await httpBackend.flushAllExpected();
                 await prom;
+                expect(thread.length).toBe(2);
                 // Test threads are in chronological order
                 expect(timeline!.getEvents().map((it) => it.event.event_id)).toEqual([
                     THREAD2_ROOT.event_id,
@@ -1652,24 +1630,6 @@ describe("MatrixClient event timelines", function () {
             const thread = room.getThread(THREAD_ROOT.event_id!)!;
             const timelineSet = thread.timelineSet;
 
-            const buildParams = (direction: Direction, token: string): string => {
-                if (Thread.hasServerSideFwdPaginationSupport === FeatureSupport.Experimental) {
-                    return `?from=${token}&org.matrix.msc3715.dir=${direction}`;
-                } else {
-                    return `?dir=${direction}&from=${token}`;
-                }
-            };
-
-            httpBackend
-                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_ROOT.event_id!))
-                .respond(200, {
-                    start: "start_token",
-                    events_before: [],
-                    event: THREAD_ROOT,
-                    events_after: [],
-                    state: [],
-                    end: "end_token",
-                });
             httpBackend
                 .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
                 .respond(200, function () {
@@ -1692,27 +1652,11 @@ describe("MatrixClient event timelines", function () {
                         encodeURIComponent(THREAD_ROOT.event_id!) +
                         "/" +
                         encodeURIComponent(THREAD_RELATION_TYPE.name) +
-                        buildParams(Direction.Backward, "start_token"),
+                        buildRelationPaginationQuery({ dir: Direction.Backward, limit: 1 }),
                 )
                 .respond(200, function () {
                     return {
-                        original_event: THREAD_ROOT,
-                        chunk: [],
-                    };
-                });
-            httpBackend
-                .when(
-                    "GET",
-                    "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
-                        encodeURIComponent(THREAD_ROOT.event_id!) +
-                        "/" +
-                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
-                        buildParams(Direction.Forward, "end_token"),
-                )
-                .respond(200, function () {
-                    return {
-                        original_event: THREAD_ROOT,
-                        chunk: [THREAD_REPLY],
+                        chunk: [THREAD_ROOT],
                     };
                 });
             const timeline = await flushHttp(client.getEventTimeline(timelineSet, THREAD_ROOT.event_id!));
diff --git a/spec/test-utils/thread.ts b/spec/test-utils/thread.ts
index 6111aba40b5..6232f20d70c 100644
--- a/spec/test-utils/thread.ts
+++ b/spec/test-utils/thread.ts
@@ -138,9 +138,6 @@ export const mkThread = ({
     }
 
     const thread = room.createThread(rootEvent.getId() ?? "", rootEvent, events, true);
-    // So that we do not have to mock the thread loading
-    thread.initialEventsFetched = true;
-    thread.addEvents(events, true);
 
     return { thread, rootEvent, events };
 };
diff --git a/spec/unit/room.spec.ts b/spec/unit/room.spec.ts
index 8fd3c22b936..62a9cb660ae 100644
--- a/spec/unit/room.spec.ts
+++ b/spec/unit/room.spec.ts
@@ -2475,11 +2475,11 @@ describe("Room", function () {
 
             let prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents([randomMessage, threadRoot, threadResponse]);
-            const thread = await prom;
+            const thread: Thread = await prom;
             await emitPromise(room, ThreadEvent.Update);
 
-            expect(thread.replyToEvent.event).toEqual(threadResponse.event);
-            expect(thread.replyToEvent.getContent().body).toBe(threadResponse.getContent().body);
+            expect(thread.replyToEvent!.event).toEqual(threadResponse.event);
+            expect(thread.replyToEvent!.getContent().body).toBe(threadResponse.getContent().body);
 
             room.client.fetchRoomEvent = (eventId: string) =>
                 Promise.resolve({
@@ -2490,7 +2490,7 @@ describe("Room", function () {
                             [THREAD_RELATION_TYPE.name]: {
                                 latest_event: {
                                     ...threadResponse.event,
-                                    content: threadResponseEdit.event.content,
+                                    content: threadResponseEdit.getContent()["m.new_content"],
                                 },
                                 count: 2,
                                 current_user_participated: true,
@@ -2502,7 +2502,7 @@ describe("Room", function () {
             prom = emitPromise(room, ThreadEvent.Update);
             room.addLiveEvents([threadResponseEdit]);
             await prom;
-            expect(thread.replyToEvent.getContent().body).toBe(threadResponseEdit.getContent()["m.new_content"].body);
+            expect(thread.replyToEvent!.getContent().body).toBe(threadResponseEdit.getContent()["m.new_content"].body);
         });
 
         it("Redactions to thread responses decrement the length", async () => {
@@ -2847,7 +2847,7 @@ describe("Room", function () {
             expect(room.eventShouldLiveIn(reply2, events, roots).shouldLiveInThread).toBeFalsy();
         });
 
-        it("should aggregate relations in thread event timeline set", () => {
+        it("should aggregate relations in thread event timeline set", async () => {
             Thread.setServerSideSupport(FeatureSupport.Stable);
             const threadRoot = mkMessage();
             const rootReaction = mkReaction(threadRoot);
@@ -2856,9 +2856,10 @@ describe("Room", function () {
 
             const events = [threadRoot, rootReaction, threadResponse, threadReaction];
 
+            const prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents(events);
-
-            const thread = threadRoot.getThread()!;
+            const thread = await prom;
+            expect(thread).toBe(threadRoot.getThread());
             expect(thread.rootEvent).toBe(threadRoot);
 
             const rootRelations = thread.timelineSet.relations
diff --git a/src/models/room.ts b/src/models/room.ts
index 8b88b984226..7250528621b 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -2090,9 +2090,7 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         // If we jump to an event in a thread where neither the event, nor the root,
         // nor any thread event are loaded yet, we'll load the event as well as the thread root, create the thread,
         // and pass the event through this.
-        for (const event of events) {
-            thread.setEventMetadata(event);
-        }
+        thread.addEvents(events, false);
 
         // If we managed to create a thread and figure out its `id` then we can use it
         this.threads.set(thread.id, thread);
diff --git a/src/models/thread.ts b/src/models/thread.ts
index ec1bd167685..eaa62e27951 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -1,5 +1,5 @@
 /*
-Copyright 2021 The Matrix.org Foundation C.I.C.
+Copyright 2021-2022 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.
@@ -19,7 +19,7 @@ import { Optional } from "matrix-events-sdk";
 import { MatrixClient, PendingEventOrdering } from "../client";
 import { TypedReEmitter } from "../ReEmitter";
 import { RelationType } from "../@types/event";
-import { EventStatus, IThreadBundledRelationship, MatrixEvent, MatrixEventEvent } from "./event";
+import { IThreadBundledRelationship, MatrixEvent, MatrixEventEvent } from "./event";
 import { Direction, EventTimeline } from "./event-timeline";
 import { EventTimelineSet, EventTimelineSetHandlerMap } from "./event-timeline-set";
 import { NotificationCountType, Room, RoomEvent } from "./room";
@@ -125,7 +125,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
 
         this.room.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
         this.room.on(RoomEvent.Redaction, this.onRedaction);
-        this.room.on(RoomEvent.LocalEchoUpdated, this.onEcho);
+        this.room.on(RoomEvent.LocalEchoUpdated, this.onLocalEcho);
         this.timelineSet.on(RoomEvent.Timeline, this.onTimelineEvent);
 
         this.processReceipts(opts.receipts);
@@ -174,6 +174,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             !redaction.status // only respect it when it succeeds
         ) {
             this.replyCount--;
+            this.updatePendingReplyCount();
             this.emit(ThreadEvent.Update, this);
         }
     };
@@ -201,15 +202,19 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
         if (!toStartOfTimeline) {
             room!.addLocalEchoReceipt(event.getSender()!, event, ReceiptType.Read);
         }
-        this.onEcho(event);
+        this.onEcho(event, toStartOfTimeline ?? false);
     };
 
-    private onEcho = async (event: MatrixEvent): Promise<void> => {
-        if (event.threadRootId !== this.id) return; // ignore echoes for other timelines
-        if (this.lastEvent === event) return;
-        if (!event.isRelation(THREAD_RELATION_TYPE.name)) return;
+    private onLocalEcho = (event: MatrixEvent): void => {
+        this.onEcho(event, false);
+    };
 
+    private onEcho = async (event: MatrixEvent, toStartOfTimeline: boolean): Promise<void> => {
+        if (event.threadRootId !== this.id) return; // ignore echoes for other timelines
+        if (this.lastEvent === event) return; // ignore duplicate events
         await this.updateThreadMetadata();
+        if (!event.isRelation(THREAD_RELATION_TYPE.name)) return; // don't send a new reply event for reactions or edits
+        if (toStartOfTimeline) return; // ignore messages added to the start of the timeline
         this.emit(ThreadEvent.NewReply, this, event);
     };
 
@@ -257,9 +262,9 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             this.addEventToTimeline(event, toStartOfTimeline);
 
             this.client.decryptEventIfNeeded(event, {});
-        } else if (!toStartOfTimeline && this.initialEventsFetched && isNewestReply) {
-            await this.fetchEditsWhereNeeded(event);
+        } else if (!toStartOfTimeline && isNewestReply) {
             this.addEventToTimeline(event, false);
+            this.fetchEditsWhereNeeded(event);
         } else if (event.isRelation(RelationType.Annotation) || event.isRelation(RelationType.Replace)) {
             // Apply annotations and replace relations to the relations of the timeline only
             this.timelineSet.relations?.aggregateParentEvent(event);
@@ -323,25 +328,28 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
                 ...bundledRelationship.latest_event,
                 room_id: this.roomId,
             });
+            this.updatePendingReplyCount();
             await this.processEvent(this.lastEvent);
         }
+    }
 
-        let pendingEvents: MatrixEvent[];
-        if (this.pendingEventOrdering === PendingEventOrdering.Detached) {
-            pendingEvents = this.room
-                .getPendingEvents()
-                .filter((ev) => ev.isRelation(THREAD_RELATION_TYPE.name) && this.id === ev.threadRootId);
-            await Promise.all(pendingEvents.map((ev) => this.processEvent(ev)));
-        } else {
-            pendingEvents = this.events
-                .filter((ev) => ev.isRelation(THREAD_RELATION_TYPE.name))
-                .filter((ev) => ev.status !== EventStatus.SENT && ev.status !== EventStatus.CANCELLED);
-        }
+    private updatePendingReplyCount(): void {
+        const unfilteredPendingEvents =
+            this.pendingEventOrdering === PendingEventOrdering.Detached ? this.room.getPendingEvents() : this.events;
+        const pendingEvents = unfilteredPendingEvents.filter(
+            (ev) =>
+                ev.threadRootId === this.id &&
+                ev.isRelation(THREAD_RELATION_TYPE.name) &&
+                ev.status !== null &&
+                ev.getId() !== this.lastEvent?.getId(),
+        );
         this.lastPendingEvent = pendingEvents.length ? pendingEvents[pendingEvents.length - 1] : undefined;
         this.pendingReplyCount = pendingEvents.length;
     }
 
     private async updateThreadMetadata(): Promise<void> {
+        this.updatePendingReplyCount();
+
         if (Thread.hasServerSideSupport) {
             // Ensure we show *something* as soon as possible, we'll update it as soon as we get better data, but we
             // don't want the thread preview to be empty if we can avoid it
@@ -420,11 +428,6 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
      * Finds an event by ID in the current thread
      */
     public findEventById(eventId: string): MatrixEvent | undefined {
-        // Check the lastEvent as it may have been created based on a bundled relationship and not in a timeline
-        if (this.lastEvent?.getId() === eventId) {
-            return this.lastEvent;
-        }
-
         return this.timelineSet.findEventById(eventId);
     }
 
@@ -455,7 +458,8 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
     }
 
     /**
-     * A getter for the last event added to the thread, if known.
+     * A getter for the last event of the thread.
+     * This might be a synthesized event, if so, it will not emit any events to listeners.
      */
     public get replyToEvent(): Optional<MatrixEvent> {
         return this.lastPendingEvent ?? this.lastEvent ?? this.lastReply();

From 9c17eb6c14ecc3dae0bbb3f183cbd77e029679aa Mon Sep 17 00:00:00 2001
From: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Date: Mon, 12 Dec 2022 17:49:39 +0000
Subject: [PATCH 49/60] Begin factoring out a CryptoBackend interface (#2955)

Part of https://github.com/vector-im/element-web/issues/21972. Eventually I want to replace the whole of the current `Crypto` implementation with an alternative implementation, but in order to get from here to there, I'm factoring out a common interface which will be implemented by both implementations.

I'm also determined to fix the problem where the innards of the crypto implementation are exposed to applications via the `MatrixClient.crypto` property.

It's not (yet) entirely clear what shape this interface should be, so I'm going with a minimal approach and adding things as we know we need them. This means that we need to keep the old `client.crypto` property around as well as a new `client.cryptoBackend` property. Eventually `client.crypto` will go away, but that will be a breaking change in the js-sdk.
---
 spec/integ/megolm-integ.spec.ts        | 125 +++++++++++++++++++++++++
 spec/unit/crypto/cross-signing.spec.ts |   2 +-
 spec/unit/room.spec.ts                 |   2 +-
 src/@types/crypto.ts                   |  26 +++++
 src/client.ts                          |  36 +++----
 src/common-crypto/CryptoBackend.ts     |  63 +++++++++++++
 src/common-crypto/README.md            |   4 +
 src/crypto/algorithms/megolm.ts        |   9 +-
 src/crypto/algorithms/olm.ts           |   3 +-
 src/crypto/index.ts                    |  33 ++-----
 src/models/event.ts                    |   8 +-
 11 files changed, 255 insertions(+), 56 deletions(-)
 create mode 100644 src/common-crypto/CryptoBackend.ts
 create mode 100644 src/common-crypto/README.md

diff --git a/spec/integ/megolm-integ.spec.ts b/spec/integ/megolm-integ.spec.ts
index fcdfa8694fa..334800333a6 100644
--- a/spec/integ/megolm-integ.spec.ts
+++ b/spec/integ/megolm-integ.spec.ts
@@ -650,6 +650,131 @@ describe("megolm", () => {
         ]);
     });
 
+    describe("get|setGlobalErrorOnUnknownDevices", () => {
+        it("should raise an error if crypto is disabled", () => {
+            aliceTestClient.client["cryptoBackend"] = undefined;
+            expect(() => aliceTestClient.client.setGlobalErrorOnUnknownDevices(true)).toThrowError(
+                "encryption disabled",
+            );
+            expect(() => aliceTestClient.client.getGlobalErrorOnUnknownDevices()).toThrowError("encryption disabled");
+        });
+
+        it("should permit sending to unknown devices", async () => {
+            expect(aliceTestClient.client.getGlobalErrorOnUnknownDevices()).toBeTruthy();
+
+            aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
+            await aliceTestClient.start();
+            const p2pSession = await establishOlmSession(aliceTestClient, testOlmAccount);
+
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
+            await aliceTestClient.flushSync();
+
+            // start out with the device unknown - the send should be rejected.
+            aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+            aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+
+            await Promise.all([
+                aliceTestClient.client.sendTextMessage(ROOM_ID, "test").then(
+                    () => {
+                        throw new Error("sendTextMessage failed on an unknown device");
+                    },
+                    (e) => {
+                        expect(e.name).toEqual("UnknownDeviceError");
+                    },
+                ),
+                aliceTestClient.httpBackend.flushAllExpected(),
+            ]);
+
+            // enable sending to unknown devices, and resend
+            aliceTestClient.client.setGlobalErrorOnUnknownDevices(false);
+            expect(aliceTestClient.client.getGlobalErrorOnUnknownDevices()).toBeFalsy();
+
+            const room = aliceTestClient.client.getRoom(ROOM_ID)!;
+            const pendingMsg = room.getPendingEvents()[0];
+
+            const inboundGroupSessionPromise = expectSendRoomKey(
+                aliceTestClient.httpBackend,
+                "@bob:xyz",
+                testOlmAccount,
+                p2pSession,
+            );
+
+            await Promise.all([
+                aliceTestClient.client.resendEvent(pendingMsg, room),
+                expectSendMegolmMessage(aliceTestClient.httpBackend, inboundGroupSessionPromise),
+            ]);
+        });
+    });
+
+    describe("get|setGlobalBlacklistUnverifiedDevices", () => {
+        it("should raise an error if crypto is disabled", () => {
+            aliceTestClient.client["cryptoBackend"] = undefined;
+            expect(() => aliceTestClient.client.setGlobalBlacklistUnverifiedDevices(true)).toThrowError(
+                "encryption disabled",
+            );
+            expect(() => aliceTestClient.client.getGlobalBlacklistUnverifiedDevices()).toThrowError(
+                "encryption disabled",
+            );
+        });
+
+        it("should disable sending to unverified devices", async () => {
+            aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
+            await aliceTestClient.start();
+            const p2pSession = await establishOlmSession(aliceTestClient, testOlmAccount);
+
+            // tell alice we share a room with bob
+            aliceTestClient.httpBackend.when("GET", "/sync").respond(200, getSyncResponse(["@bob:xyz"]));
+            await aliceTestClient.flushSync();
+
+            logger.log("Forcing alice to download our device keys");
+            aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+            aliceTestClient.httpBackend.when("POST", "/keys/query").respond(200, getTestKeysQueryResponse("@bob:xyz"));
+
+            await Promise.all([
+                aliceTestClient.client.downloadKeys(["@bob:xyz"]),
+                aliceTestClient.httpBackend.flush("/keys/query", 2),
+            ]);
+
+            logger.log("Telling alice to block messages to unverified devices");
+            expect(aliceTestClient.client.getGlobalBlacklistUnverifiedDevices()).toBeFalsy();
+            aliceTestClient.client.setGlobalBlacklistUnverifiedDevices(true);
+            expect(aliceTestClient.client.getGlobalBlacklistUnverifiedDevices()).toBeTruthy();
+
+            logger.log("Telling alice to send a megolm message");
+            aliceTestClient.httpBackend.when("PUT", "/send/").respond(200, { event_id: "$event_id" });
+            aliceTestClient.httpBackend.when("PUT", "/sendToDevice/m.room_key.withheld/").respond(200, {});
+
+            await Promise.all([
+                aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
+                aliceTestClient.httpBackend.flushAllExpected({ timeout: 1000 }),
+            ]);
+
+            // Now, let's mark the device as verified, and check that keys are sent to it.
+
+            logger.log("Marking the device as verified");
+            // XXX: this is an integration test; we really ought to do this via the cross-signing dance
+            const d = aliceTestClient.client.crypto!.deviceList.getStoredDevice("@bob:xyz", "DEVICE_ID")!;
+            d.verified = DeviceInfo.DeviceVerification.VERIFIED;
+            aliceTestClient.client.crypto?.deviceList.storeDevicesForUser("@bob:xyz", { DEVICE_ID: d });
+
+            const inboundGroupSessionPromise = expectSendRoomKey(
+                aliceTestClient.httpBackend,
+                "@bob:xyz",
+                testOlmAccount,
+                p2pSession,
+            );
+
+            logger.log("Asking alice to re-send");
+            await Promise.all([
+                expectSendMegolmMessage(aliceTestClient.httpBackend, inboundGroupSessionPromise).then((decrypted) => {
+                    expect(decrypted.type).toEqual("m.room.message");
+                    expect(decrypted.content!.body).toEqual("test");
+                }),
+                aliceTestClient.client.sendTextMessage(ROOM_ID, "test"),
+            ]);
+        });
+    });
+
     it("We should start a new megolm session when a device is blocked", async () => {
         aliceTestClient.expectKeyQuery({ device_keys: { "@alice:localhost": {} }, failures: {} });
         await aliceTestClient.start();
diff --git a/spec/unit/crypto/cross-signing.spec.ts b/spec/unit/crypto/cross-signing.spec.ts
index 6f15bdd09ab..eddaf43ba4a 100644
--- a/spec/unit/crypto/cross-signing.spec.ts
+++ b/spec/unit/crypto/cross-signing.spec.ts
@@ -1147,7 +1147,7 @@ describe("userHasCrossSigningKeys", function () {
     });
 
     it("throws an error if crypto is disabled", () => {
-        aliceClient.crypto = undefined;
+        aliceClient["cryptoBackend"] = undefined;
         expect(() => aliceClient.userHasCrossSigningKeys()).toThrowError("encryption disabled");
     });
 });
diff --git a/spec/unit/room.spec.ts b/spec/unit/room.spec.ts
index 62a9cb660ae..71e9031d9cd 100644
--- a/spec/unit/room.spec.ts
+++ b/spec/unit/room.spec.ts
@@ -3131,7 +3131,7 @@ describe("Room", function () {
 
     it("should load pending events from from the store and decrypt if needed", async () => {
         const client = new TestClient(userA).client;
-        client.crypto = {
+        client.crypto = client["cryptoBackend"] = {
             decryptEvent: jest.fn().mockResolvedValue({ clearEvent: { body: "enc" } }),
         } as unknown as Crypto;
         client.store.getPendingEvents = jest.fn(async (roomId) => [
diff --git a/src/@types/crypto.ts b/src/@types/crypto.ts
index 3c46d993910..91e4d161c7b 100644
--- a/src/@types/crypto.ts
+++ b/src/@types/crypto.ts
@@ -14,7 +14,33 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import type { IClearEvent } from "../models/event";
+
 export type OlmGroupSessionExtraData = {
     untrusted?: boolean;
     sharedHistory?: boolean;
 };
+
+/**
+ * The result of a (successful) call to {@link Crypto.decryptEvent}
+ */
+export interface IEventDecryptionResult {
+    /**
+     * The plaintext payload for the event (typically containing <tt>type</tt> and <tt>content</tt> fields).
+     */
+    clearEvent: IClearEvent;
+    /**
+     * List of curve25519 keys involved in telling us about the senderCurve25519Key and claimedEd25519Key.
+     * See {@link MatrixEvent#getForwardingCurve25519KeyChain}.
+     */
+    forwardingCurve25519KeyChain?: string[];
+    /**
+     * Key owned by the sender of this event.  See {@link MatrixEvent#getSenderKey}.
+     */
+    senderCurve25519Key?: string;
+    /**
+     * ed25519 key claimed by the sender of this event. See {@link MatrixEvent#getClaimedEd25519Key}.
+     */
+    claimedEd25519Key?: string;
+    untrusted?: boolean;
+}
diff --git a/src/client.ts b/src/client.ts
index 66b16903039..83c4ac2cd12 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -210,6 +210,7 @@ import { UIARequest, UIAResponse } from "./@types/uia";
 import { LocalNotificationSettings } from "./@types/local_notifications";
 import { UNREAD_THREAD_NOTIFICATIONS } from "./@types/sync";
 import { buildFeatureSupportMap, Feature, ServerSupport } from "./feature";
+import { CryptoBackend } from "./common-crypto/CryptoBackend";
 
 export type Store = IStore;
 
@@ -1147,7 +1148,8 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     public urlPreviewCache: { [key: string]: Promise<IPreviewUrlResponse> } = {};
     public identityServer?: IIdentityServerProvider;
     public http: MatrixHttpApi<IHttpOpts & { onlyData: true }>; // XXX: Intended private, used in code.
-    public crypto?: Crypto; // XXX: Intended private, used in code.
+    public crypto?: Crypto; // libolm crypto implementation. XXX: Intended private, used in code. Being replaced by cryptoBackend
+    private cryptoBackend?: CryptoBackend; // one of crypto or rustCrypto
     public cryptoCallbacks: ICryptoCallbacks; // XXX: Intended private, used in code.
     public callEventHandler?: CallEventHandler; // XXX: Intended private, used in code.
     public groupCallEventHandler?: GroupCallEventHandler;
@@ -1455,7 +1457,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * clean shutdown.
      */
     public stopClient(): void {
-        this.crypto?.stop(); // crypto might have been initialised even if the client wasn't fully started
+        this.cryptoBackend?.stop(); // crypto might have been initialised even if the client wasn't fully started
 
         if (!this.clientRunning) return; // already stopped
 
@@ -1959,7 +1961,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
     }
 
     /**
-     * Initialise support for end-to-end encryption in this client
+     * Initialise support for end-to-end encryption in this client, using libolm.
      *
      * You should call this method after creating the matrixclient, but *before*
      * calling `startClient`, if you want to support end-to-end encryption.
@@ -1975,7 +1977,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             );
         }
 
-        if (this.crypto) {
+        if (this.cryptoBackend) {
             logger.warn("Attempt to re-initialise e2e encryption on MatrixClient");
             return;
         }
@@ -2040,7 +2042,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
 
         // if crypto initialisation was successful, tell it to attach its event handlers.
         crypto.registerEventHandlers(this as Parameters<Crypto["registerEventHandlers"]>[0]);
-        this.crypto = crypto;
+        this.cryptoBackend = this.crypto = crypto;
 
         // upload our keys in the background
         this.crypto.uploadDeviceKeys().catch((e) => {
@@ -2054,7 +2056,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns True if end-to-end is enabled.
      */
     public isCryptoEnabled(): boolean {
-        return !!this.crypto;
+        return !!this.cryptoBackend;
     }
 
     /**
@@ -2299,10 +2301,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param value - whether to blacklist all unverified devices by default
      */
     public setGlobalBlacklistUnverifiedDevices(value: boolean): boolean {
-        if (!this.crypto) {
+        if (!this.cryptoBackend) {
             throw new Error("End-to-end encryption disabled");
         }
-        this.crypto.globalBlacklistUnverifiedDevices = value;
+        this.cryptoBackend.globalBlacklistUnverifiedDevices = value;
         return value;
     }
 
@@ -2310,10 +2312,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @returns whether to blacklist all unverified devices by default
      */
     public getGlobalBlacklistUnverifiedDevices(): boolean {
-        if (!this.crypto) {
+        if (!this.cryptoBackend) {
             throw new Error("End-to-end encryption disabled");
         }
-        return this.crypto.globalBlacklistUnverifiedDevices;
+        return this.cryptoBackend.globalBlacklistUnverifiedDevices;
     }
 
     /**
@@ -2327,10 +2329,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * @param value - whether error on unknown devices
      */
     public setGlobalErrorOnUnknownDevices(value: boolean): void {
-        if (!this.crypto) {
+        if (!this.cryptoBackend) {
             throw new Error("End-to-end encryption disabled");
         }
-        this.crypto.globalErrorOnUnknownDevices = value;
+        this.cryptoBackend.globalErrorOnUnknownDevices = value;
     }
 
     /**
@@ -2339,10 +2341,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * This API is currently UNSTABLE and may change or be removed without notice.
      */
     public getGlobalErrorOnUnknownDevices(): boolean {
-        if (!this.crypto) {
+        if (!this.cryptoBackend) {
             throw new Error("End-to-end encryption disabled");
         }
-        return this.crypto.globalErrorOnUnknownDevices;
+        return this.cryptoBackend.globalErrorOnUnknownDevices;
     }
 
     /**
@@ -2482,10 +2484,10 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      * the cross-signing pseudo-device.
      */
     public userHasCrossSigningKeys(): Promise<boolean> {
-        if (!this.crypto) {
+        if (!this.cryptoBackend) {
             throw new Error("End-to-end encryption disabled");
         }
-        return this.crypto.userHasCrossSigningKeys();
+        return this.cryptoBackend.userHasCrossSigningKeys();
     }
 
     /**
@@ -7162,7 +7164,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public decryptEventIfNeeded(event: MatrixEvent, options?: IDecryptOptions): Promise<void> {
         if (event.shouldAttemptDecryption() && this.isCryptoEnabled()) {
-            event.attemptDecryption(this.crypto!, options);
+            event.attemptDecryption(this.cryptoBackend!, options);
         }
 
         if (event.isBeingDecrypted()) {
diff --git a/src/common-crypto/CryptoBackend.ts b/src/common-crypto/CryptoBackend.ts
new file mode 100644
index 00000000000..77748cb5050
--- /dev/null
+++ b/src/common-crypto/CryptoBackend.ts
@@ -0,0 +1,63 @@
+/*
+Copyright 2022 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 type { IEventDecryptionResult } from "../@types/crypto";
+import { MatrixEvent } from "../models/event";
+
+/**
+ * Common interface for the crypto implementations
+ */
+export interface CryptoBackend {
+    /**
+     * Global override for whether the client should ever send encrypted
+     * messages to unverified devices. This provides the default for rooms which
+     * do not specify a value.
+     *
+     * If true, all unverified devices will be blacklisted by default
+     */
+    globalBlacklistUnverifiedDevices: boolean;
+
+    /**
+     * Whether sendMessage in a room with unknown and unverified devices
+     * should throw an error and not send the message. This has 'Global' for
+     * symmetry with setGlobalBlacklistUnverifiedDevices but there is currently
+     * no room-level equivalent for this setting.
+     */
+    globalErrorOnUnknownDevices: boolean;
+
+    /**
+     * Shut down any background processes related to crypto
+     */
+    stop(): void;
+
+    /**
+     * Checks if the user has previously published cross-signing keys
+     *
+     * This means downloading the devicelist for the user and checking if the list includes
+     * the cross-signing pseudo-device.
+
+     * @returns true if the user has previously published cross-signing keys
+     */
+    userHasCrossSigningKeys(): Promise<boolean>;
+
+    /**
+     * Decrypt a received event
+     *
+     * @returns a promise which resolves once we have finished decrypting.
+     * Rejects with an error if there is a problem decrypting the event.
+     */
+    decryptEvent(event: MatrixEvent): Promise<IEventDecryptionResult>;
+}
diff --git a/src/common-crypto/README.md b/src/common-crypto/README.md
new file mode 100644
index 00000000000..7af3298af48
--- /dev/null
+++ b/src/common-crypto/README.md
@@ -0,0 +1,4 @@
+This directory contains functionality which is common to both the legacy (libolm-based) crypto implementation,
+and the new rust-based implementation.
+
+It is an internal module, and is _not_ directly exposed to applications.
diff --git a/src/crypto/algorithms/megolm.ts b/src/crypto/algorithms/megolm.ts
index e8816569339..ef04e8f4e0b 100644
--- a/src/crypto/algorithms/megolm.ts
+++ b/src/crypto/algorithms/megolm.ts
@@ -20,6 +20,7 @@ limitations under the License.
 
 import { v4 as uuidv4 } from "uuid";
 
+import type { IEventDecryptionResult } from "../../@types/crypto";
 import { logger } from "../../logger";
 import * as olmlib from "../olmlib";
 import {
@@ -38,13 +39,7 @@ import { IOlmSessionResult } from "../olmlib";
 import { DeviceInfoMap } from "../DeviceList";
 import { IContent, MatrixEvent } from "../../models/event";
 import { EventType, MsgType, ToDeviceMessageId } from "../../@types/event";
-import {
-    IMegolmEncryptedContent,
-    IEventDecryptionResult,
-    IMegolmSessionData,
-    IncomingRoomKeyRequest,
-    IEncryptedContent,
-} from "../index";
+import { IMegolmEncryptedContent, IMegolmSessionData, IncomingRoomKeyRequest, IEncryptedContent } from "../index";
 import { RoomKeyRequestState } from "../OutgoingRoomKeyRequestManager";
 import { OlmGroupSessionExtraData } from "../../@types/crypto";
 import { MatrixError } from "../../http-api";
diff --git a/src/crypto/algorithms/olm.ts b/src/crypto/algorithms/olm.ts
index 90e724d3804..1a795545916 100644
--- a/src/crypto/algorithms/olm.ts
+++ b/src/crypto/algorithms/olm.ts
@@ -18,13 +18,14 @@ limitations under the License.
  * Defines m.olm encryption/decryption
  */
 
+import type { IEventDecryptionResult } from "../../@types/crypto";
 import { logger } from "../../logger";
 import * as olmlib from "../olmlib";
 import { DeviceInfo } from "../deviceinfo";
 import { DecryptionAlgorithm, DecryptionError, EncryptionAlgorithm, registerAlgorithm } from "./base";
 import { Room } from "../../models/room";
 import { IContent, MatrixEvent } from "../../models/event";
-import { IEncryptedContent, IEventDecryptionResult, IOlmEncryptedContent } from "../index";
+import { IEncryptedContent, IOlmEncryptedContent } from "../index";
 import { IInboundSession } from "../OlmDevice";
 
 const DeviceVerification = DeviceInfo.DeviceVerification;
diff --git a/src/crypto/index.ts b/src/crypto/index.ts
index 391e6975e7d..9349550130d 100644
--- a/src/crypto/index.ts
+++ b/src/crypto/index.ts
@@ -20,6 +20,7 @@ limitations under the License.
 import anotherjson from "another-json";
 import { v4 as uuidv4 } from "uuid";
 
+import type { IEventDecryptionResult } from "../@types/crypto";
 import type { PkDecryption, PkSigning } from "@matrix-org/olm";
 import { EventType, ToDeviceMessageId } from "../@types/event";
 import { TypedReEmitter } from "../ReEmitter";
@@ -67,7 +68,7 @@ import { BackupManager } from "./backup";
 import { IStore } from "../store";
 import { Room, RoomEvent } from "../models/room";
 import { RoomMember, RoomMemberEvent } from "../models/room-member";
-import { EventStatus, IClearEvent, IEvent, MatrixEvent, MatrixEventEvent } from "../models/event";
+import { EventStatus, IEvent, MatrixEvent, MatrixEventEvent } from "../models/event";
 import { ToDeviceBatch } from "../models/ToDeviceMessage";
 import {
     ClientEvent,
@@ -87,6 +88,7 @@ import { IContent } from "../models/event";
 import { ISyncResponse } from "../sync-accumulator";
 import { ISignatures } from "../@types/signed";
 import { IMessage } from "./algorithms/olm";
+import { CryptoBackend } from "../common-crypto/CryptoBackend";
 
 const DeviceVerification = DeviceInfo.DeviceVerification;
 
@@ -218,30 +220,6 @@ interface ISignableObject {
     unsigned?: object;
 }
 
-/**
- * The result of a (successful) call to decryptEvent.
- */
-export interface IEventDecryptionResult {
-    /**
-     * The plaintext payload for the event (typically containing <tt>type</tt> and <tt>content</tt> fields).
-     */
-    clearEvent: IClearEvent;
-    /**
-     * List of curve25519 keys involved in telling us about the senderCurve25519Key and claimedEd25519Key.
-     * See {@link MatrixEvent#getForwardingCurve25519KeyChain}.
-     */
-    forwardingCurve25519KeyChain?: string[];
-    /**
-     * Key owned by the sender of this event.  See {@link MatrixEvent#getSenderKey}.
-     */
-    senderCurve25519Key?: string;
-    /**
-     * ed25519 key claimed by the sender of this event. See {@link MatrixEvent#getClaimedEd25519Key}.
-     */
-    claimedEd25519Key?: string;
-    untrusted?: boolean;
-}
-
 export interface IRequestsMap {
     getRequest(event: MatrixEvent): VerificationRequest | undefined;
     getRequestByChannel(channel: IVerificationChannel): VerificationRequest | undefined;
@@ -380,7 +358,7 @@ export type CryptoEventHandlerMap = {
     [CryptoEvent.UserCrossSigningUpdated]: (userId: string) => void;
 };
 
-export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap> {
+export class Crypto extends TypedEventEmitter<CryptoEvent, CryptoEventHandlerMap> implements CryptoBackend {
     /**
      * @returns The version of Olm.
      */
@@ -3915,3 +3893,6 @@ class IncomingRoomKeyRequestCancellation {
         this.requestId = content.request_id;
     }
 }
+
+// IEventDecryptionResult is re-exported for backwards compatibility, in case any applications are referencing it.
+export type { IEventDecryptionResult } from "../@types/crypto";
diff --git a/src/models/event.ts b/src/models/event.ts
index c4910e752c1..1f1c3cfa366 100644
--- a/src/models/event.ts
+++ b/src/models/event.ts
@@ -21,10 +21,11 @@ limitations under the License.
 
 import { ExtensibleEvent, ExtensibleEvents, Optional } from "matrix-events-sdk";
 
+import type { IEventDecryptionResult } from "../@types/crypto";
 import { logger } from "../logger";
 import { VerificationRequest } from "../crypto/verification/request/VerificationRequest";
 import { EVENT_VISIBILITY_CHANGE_TYPE, EventType, MsgType, RelationType } from "../@types/event";
-import { Crypto, IEventDecryptionResult } from "../crypto";
+import { Crypto } from "../crypto";
 import { deepSortedObjectEntries, internaliseString } from "../utils";
 import { RoomMember } from "./room-member";
 import { Thread, ThreadEvent, EventHandlerMap as ThreadEventHandlerMap, THREAD_RELATION_TYPE } from "./thread";
@@ -34,6 +35,7 @@ import { MatrixError } from "../http-api";
 import { TypedEventEmitter } from "./typed-event-emitter";
 import { EventStatus } from "./event-status";
 import { DecryptionError } from "../crypto/algorithms";
+import { CryptoBackend } from "../common-crypto/CryptoBackend";
 
 export { EventStatus } from "./event-status";
 
@@ -725,7 +727,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * @returns promise which resolves (to undefined) when the decryption
      * attempt is completed.
      */
-    public async attemptDecryption(crypto: Crypto, options: IDecryptOptions = {}): Promise<void> {
+    public async attemptDecryption(crypto: CryptoBackend, options: IDecryptOptions = {}): Promise<void> {
         // start with a couple of sanity checks.
         if (!this.isEncrypted()) {
             throw new Error("Attempt to decrypt event which isn't encrypted");
@@ -803,7 +805,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         return recipients;
     }
 
-    private async decryptionLoop(crypto: Crypto, options: IDecryptOptions = {}): Promise<void> {
+    private async decryptionLoop(crypto: CryptoBackend, options: IDecryptOptions = {}): Promise<void> {
         // make sure that this method never runs completely synchronously.
         // (doing so would mean that we would clear decryptionPromise *before*
         // it is set in attemptDecryption - and hence end up with a stuck

From 74b30246d01dca455ce4e272f103912d98f4c2b1 Mon Sep 17 00:00:00 2001
From: Germain <germains@element.io>
Date: Tue, 13 Dec 2022 09:54:44 +0000
Subject: [PATCH 50/60] Avoid creating duplicate threads (#2968)

---
 spec/unit/room.spec.ts | 16 ++++++++++++++++
 src/models/room.ts     |  4 ++++
 2 files changed, 20 insertions(+)

diff --git a/spec/unit/room.spec.ts b/spec/unit/room.spec.ts
index 71e9031d9cd..5036cabaaf4 100644
--- a/spec/unit/room.spec.ts
+++ b/spec/unit/room.spec.ts
@@ -46,6 +46,7 @@ import { TestClient } from "../TestClient";
 import { ReceiptType, WrappedReceipt } from "../../src/@types/read_receipts";
 import { FeatureSupport, Thread, THREAD_RELATION_TYPE, ThreadEvent } from "../../src/models/thread";
 import { Crypto } from "../../src/crypto";
+import { mkThread } from "../test-utils/thread";
 
 describe("Room", function () {
     const roomId = "!foo:bar";
@@ -2438,6 +2439,21 @@ describe("Room", function () {
             expect(() => room.createThread(rootEvent.getId()!, rootEvent, [], false)).not.toThrow();
         });
 
+        it("returns the same model when creating a thread twice", () => {
+            const { thread, rootEvent } = mkThread({
+                room,
+                client: new TestClient().client,
+                authorId: "@bob:example.org",
+                participantUserIds: ["@bob:example.org"],
+            });
+
+            expect(thread).toBeInstanceOf(Thread);
+
+            const duplicateThread = room.createThread(rootEvent.getId()!, rootEvent, [], false);
+
+            expect(duplicateThread).toBe(thread);
+        });
+
         it("creating thread from edited event should not conflate old versions of the event", () => {
             const message = mkMessage();
             const edit = mkEdit(message);
diff --git a/src/models/room.ts b/src/models/room.ts
index 7250528621b..e33d571e65d 100644
--- a/src/models/room.ts
+++ b/src/models/room.ts
@@ -2066,6 +2066,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         events: MatrixEvent[] = [],
         toStartOfTimeline: boolean,
     ): Thread {
+        if (this.threads.has(threadId)) {
+            return this.threads.get(threadId)!;
+        }
+
         if (rootEvent) {
             const relatedEvents = this.relations.getAllChildEventsForEvent(rootEvent.getId()!);
             if (relatedEvents?.length) {

From acd220b8a93264a1cc4e0c796cc68ca8ca1945f7 Mon Sep 17 00:00:00 2001
From: Michael Telatynski <7t3chguy@gmail.com>
Date: Tue, 13 Dec 2022 09:59:52 +0000
Subject: [PATCH 51/60] Tweak how the SonarCloud scan fails (#2947)

---
 .github/workflows/sonarcloud.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/sonarcloud.yml b/.github/workflows/sonarcloud.yml
index e70c9b99e2c..5c678c394e4 100644
--- a/.github/workflows/sonarcloud.yml
+++ b/.github/workflows/sonarcloud.yml
@@ -28,6 +28,8 @@ jobs:
             - name: "🩻 SonarCloud Scan"
               id: sonarcloud
               uses: matrix-org/sonarcloud-workflow-action@v2.3
+              # workflow_run fails report against the develop commit always, we don't want that for PRs
+              continue-on-error: ${{ github.event.workflow_run.head_branch != 'develop' }}
               with:
                   repository: ${{ github.event.workflow_run.head_repository.full_name }}
                   is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}

From 193c38523c6304c86e56d6bdc5089ece26ad34da Mon Sep 17 00:00:00 2001
From: Janne Mareike Koschinski <jannemk@element.io>
Date: Tue, 13 Dec 2022 15:23:43 +0100
Subject: [PATCH 52/60] Fix messages loaded during initial fetch ending up out
 of order (#2971)

* Fix messages loaded during initial fetch ending up out of order
---
 .../matrix-client-event-timeline.spec.ts      | 68 ++++++++++++++++++-
 spec/unit/room.spec.ts                        | 39 +++++++++--
 src/models/thread.ts                          |  2 +-
 3 files changed, 101 insertions(+), 8 deletions(-)

diff --git a/spec/integ/matrix-client-event-timeline.spec.ts b/spec/integ/matrix-client-event-timeline.spec.ts
index a520895160f..b02955511e9 100644
--- a/spec/integ/matrix-client-event-timeline.spec.ts
+++ b/spec/integ/matrix-client-event-timeline.spec.ts
@@ -1249,6 +1249,7 @@ describe("MatrixClient event timelines", function () {
                     },
                     event: true,
                 });
+                THREAD_REPLY2.localTimestamp += 1000;
 
                 // Test data for the first thread, with the second reply
                 const THREAD_ROOT_UPDATED = {
@@ -1305,6 +1306,7 @@ describe("MatrixClient event timelines", function () {
 
                 // Test adding a second event to the first thread
                 const thread = room.getThread(THREAD_ROOT.event_id!)!;
+                thread.initialEventsFetched = true;
                 const prom = emitPromise(room, ThreadEvent.NewReply);
                 respondToEvent(THREAD_ROOT_UPDATED);
                 respondToEvent(THREAD_ROOT_UPDATED);
@@ -1624,10 +1626,35 @@ describe("MatrixClient event timelines", function () {
                     },
                 },
             });
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
+                    return THREAD_ROOT;
+                });
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
+                    return THREAD_ROOT;
+                });
+            httpBackend
+                .when(
+                    "GET",
+                    "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
+                        encodeURIComponent(THREAD_ROOT.event_id!) +
+                        "/" +
+                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
+                        buildRelationPaginationQuery({ dir: Direction.Backward, limit: 1 }),
+                )
+                .respond(200, function () {
+                    return {
+                        chunk: [THREAD_REPLY],
+                    };
+                });
             await Promise.all([httpBackend.flushAllExpected(), utils.syncPromise(client)]);
 
             const room = client.getRoom(roomId)!;
             const thread = room.getThread(THREAD_ROOT.event_id!)!;
+            expect(thread.initialEventsFetched).toBeTruthy();
             const timelineSet = thread.timelineSet;
 
             httpBackend
@@ -1645,6 +1672,28 @@ describe("MatrixClient event timelines", function () {
                 .respond(200, function () {
                     return THREAD_ROOT;
                 });
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
+                    return THREAD_ROOT;
+                });
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/event/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
+                    return THREAD_ROOT;
+                });
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(THREAD_ROOT.event_id!))
+                .respond(200, function () {
+                    return {
+                        start: "start_token",
+                        events_before: [],
+                        event: THREAD_ROOT,
+                        events_after: [],
+                        end: "end_token",
+                        state: [],
+                    };
+                });
             httpBackend
                 .when(
                     "GET",
@@ -1652,13 +1701,28 @@ describe("MatrixClient event timelines", function () {
                         encodeURIComponent(THREAD_ROOT.event_id!) +
                         "/" +
                         encodeURIComponent(THREAD_RELATION_TYPE.name) +
-                        buildRelationPaginationQuery({ dir: Direction.Backward, limit: 1 }),
+                        buildRelationPaginationQuery({ dir: Direction.Backward, from: "start_token" }),
                 )
                 .respond(200, function () {
                     return {
-                        chunk: [THREAD_ROOT],
+                        chunk: [],
                     };
                 });
+            httpBackend
+                .when(
+                    "GET",
+                    "/_matrix/client/v1/rooms/!foo%3Abar/relations/" +
+                        encodeURIComponent(THREAD_ROOT.event_id!) +
+                        "/" +
+                        encodeURIComponent(THREAD_RELATION_TYPE.name) +
+                        buildRelationPaginationQuery({ dir: Direction.Forward, from: "end_token" }),
+                )
+                .respond(200, function () {
+                    return {
+                        chunk: [THREAD_REPLY],
+                    };
+                });
+
             const timeline = await flushHttp(client.getEventTimeline(timelineSet, THREAD_ROOT.event_id!));
 
             httpBackend.when("GET", "/sync").respond(200, {
diff --git a/spec/unit/room.spec.ts b/spec/unit/room.spec.ts
index 5036cabaaf4..81f6602e784 100644
--- a/spec/unit/room.spec.ts
+++ b/spec/unit/room.spec.ts
@@ -29,6 +29,8 @@ import {
     EventTimelineSet,
     EventType,
     IContent,
+    IEvent,
+    IRelationsRequestOpts,
     IStateEventWithRoomId,
     JoinRule,
     MatrixEvent,
@@ -2489,11 +2491,24 @@ describe("Room", function () {
                     },
                 });
 
+            room.client.fetchRelations = (
+                roomId: string,
+                eventId: string,
+                relationType?: RelationType | string | null,
+                eventType?: EventType | string | null,
+                opts: IRelationsRequestOpts = { dir: Direction.Backward },
+            ) =>
+                Promise.resolve({
+                    chunk: [threadResponse.event] as IEvent[],
+                    next_batch: "start_token",
+                });
+
             let prom = emitPromise(room, ThreadEvent.New);
             room.addLiveEvents([randomMessage, threadRoot, threadResponse]);
             const thread: Thread = await prom;
             await emitPromise(room, ThreadEvent.Update);
 
+            expect(thread.initialEventsFetched).toBeTruthy();
             expect(thread.replyToEvent!.event).toEqual(threadResponse.event);
             expect(thread.replyToEvent!.getContent().body).toBe(threadResponse.getContent().body);
 
@@ -2704,13 +2719,27 @@ describe("Room", function () {
                     },
                 });
 
+            room.client.fetchRelations = (
+                roomId: string,
+                eventId: string,
+                relationType?: RelationType | string | null,
+                eventType?: EventType | string | null,
+                opts: IRelationsRequestOpts = { dir: Direction.Backward },
+            ) =>
+                Promise.resolve({
+                    chunk: [threadResponse1.event] as IEvent[],
+                    next_batch: "start_token",
+                });
+
             let prom = emitPromise(room, ThreadEvent.New);
-            room.addLiveEvents([threadRoot, threadResponse1, threadResponse2]);
-            const thread = await prom;
+            room.addLiveEvents([threadRoot, threadResponse1]);
+            const thread: Thread = await prom;
             await emitPromise(room, ThreadEvent.Update);
 
+            expect(thread.initialEventsFetched).toBeTruthy();
+            room.addLiveEvents([threadResponse2]);
             expect(thread).toHaveLength(2);
-            expect(thread.replyToEvent.getId()).toBe(threadResponse2.getId());
+            expect(thread.replyToEvent!.getId()).toBe(threadResponse2.getId());
 
             room.client.fetchRoomEvent = (eventId: string) =>
                 Promise.resolve({
@@ -2733,7 +2762,7 @@ describe("Room", function () {
             await prom;
             await emitPromise(room, ThreadEvent.Update);
             expect(thread).toHaveLength(1);
-            expect(thread.replyToEvent.getId()).toBe(threadResponse1.getId());
+            expect(thread.replyToEvent!.getId()).toBe(threadResponse1.getId());
 
             room.client.fetchRoomEvent = (eventId: string) =>
                 Promise.resolve({
@@ -2757,7 +2786,7 @@ describe("Room", function () {
             await prom;
             await prom2;
             expect(thread).toHaveLength(0);
-            expect(thread.replyToEvent.getId()).toBe(threadRoot.getId());
+            expect(thread.replyToEvent!.getId()).toBe(threadRoot.getId());
         });
     });
 
diff --git a/src/models/thread.ts b/src/models/thread.ts
index eaa62e27951..bca2d92b427 100644
--- a/src/models/thread.ts
+++ b/src/models/thread.ts
@@ -262,7 +262,7 @@ export class Thread extends ReadReceipt<EmittedEvents, EventHandlerMap> {
             this.addEventToTimeline(event, toStartOfTimeline);
 
             this.client.decryptEventIfNeeded(event, {});
-        } else if (!toStartOfTimeline && isNewestReply) {
+        } else if (!toStartOfTimeline && this.initialEventsFetched && isNewestReply) {
             this.addEventToTimeline(event, false);
             this.fetchEditsWhereNeeded(event);
         } else if (event.isRelation(RelationType.Annotation) || event.isRelation(RelationType.Replace)) {

From 284a475dfb898bd3a97f2e27ed414cd2615f7fee Mon Sep 17 00:00:00 2001
From: RiotRobot <releases@riot.im>
Date: Tue, 13 Dec 2022 15:35:12 +0000
Subject: [PATCH 53/60] Exclude CHANGELOG from prettier and undo what it did

---
 .prettierignore |    3 +
 CHANGELOG.md    | 8015 +++++++++++++++++++++++------------------------
 2 files changed, 3990 insertions(+), 4028 deletions(-)

diff --git a/.prettierignore b/.prettierignore
index 5a329d581e6..6d56d969f02 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -21,3 +21,6 @@ out
 
 .vscode
 .vscode/
+
+# This file is owned, parsed, and generated by allchange, which doesn't comply with prettier
+/CHANGELOG.md
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6780d4b3d0b..e5dd9237cf8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,1676 +1,1624 @@
-# Changes in [22.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v22.0.0) (2022-12-06)
+Changes in [22.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v22.0.0) (2022-12-06)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Enable users to join group calls from multiple devices ([\#2902](https://github.com/matrix-org/matrix-js-sdk/pull/2902)).
+ * Enable users to join group calls from multiple devices ([\#2902](https://github.com/matrix-org/matrix-js-sdk/pull/2902)).
 
 ## 🦖 Deprecations
-
--   Deprecate a function containing a typo ([\#2904](https://github.com/matrix-org/matrix-js-sdk/pull/2904)).
+ * Deprecate a function containing a typo ([\#2904](https://github.com/matrix-org/matrix-js-sdk/pull/2904)).
 
 ## ✨ Features
-
--   sliding sync: add receipts extension ([\#2912](https://github.com/matrix-org/matrix-js-sdk/pull/2912)).
--   Define a spec support policy for the js-sdk ([\#2882](https://github.com/matrix-org/matrix-js-sdk/pull/2882)).
--   Further improvements to e2ee logging ([\#2900](https://github.com/matrix-org/matrix-js-sdk/pull/2900)).
--   sliding sync: add support for typing extension ([\#2893](https://github.com/matrix-org/matrix-js-sdk/pull/2893)).
--   Improve logging on Olm session errors ([\#2885](https://github.com/matrix-org/matrix-js-sdk/pull/2885)).
--   Improve logging of e2ee messages ([\#2884](https://github.com/matrix-org/matrix-js-sdk/pull/2884)).
+ * sliding sync: add receipts extension ([\#2912](https://github.com/matrix-org/matrix-js-sdk/pull/2912)).
+ * Define a spec support policy for the js-sdk ([\#2882](https://github.com/matrix-org/matrix-js-sdk/pull/2882)).
+ * Further improvements to e2ee logging ([\#2900](https://github.com/matrix-org/matrix-js-sdk/pull/2900)).
+ * sliding sync: add support for typing extension ([\#2893](https://github.com/matrix-org/matrix-js-sdk/pull/2893)).
+ * Improve logging on Olm session errors ([\#2885](https://github.com/matrix-org/matrix-js-sdk/pull/2885)).
+ * Improve logging of e2ee messages ([\#2884](https://github.com/matrix-org/matrix-js-sdk/pull/2884)).
 
 ## 🐛 Bug Fixes
+ * Fix 3pid invite acceptance not working due to mxid being sent in body ([\#2907](https://github.com/matrix-org/matrix-js-sdk/pull/2907)). Fixes vector-im/element-web#23823.
+ * Don't hang up calls that haven't started yet ([\#2898](https://github.com/matrix-org/matrix-js-sdk/pull/2898)).
+ * Read receipt accumulation for threads ([\#2881](https://github.com/matrix-org/matrix-js-sdk/pull/2881)).
+ * Make GroupCall work better with widgets ([\#2935](https://github.com/matrix-org/matrix-js-sdk/pull/2935)).
+ * Fix highlight notifications increasing when total notification is zero ([\#2937](https://github.com/matrix-org/matrix-js-sdk/pull/2937)). Fixes vector-im/element-web#23885.
+ * Fix synthesizeReceipt ([\#2916](https://github.com/matrix-org/matrix-js-sdk/pull/2916)). Fixes vector-im/element-web#23827 vector-im/element-web#23754 and vector-im/element-web#23847.
 
--   Fix 3pid invite acceptance not working due to mxid being sent in body ([\#2907](https://github.com/matrix-org/matrix-js-sdk/pull/2907)). Fixes vector-im/element-web#23823.
--   Don't hang up calls that haven't started yet ([\#2898](https://github.com/matrix-org/matrix-js-sdk/pull/2898)).
--   Read receipt accumulation for threads ([\#2881](https://github.com/matrix-org/matrix-js-sdk/pull/2881)).
--   Make GroupCall work better with widgets ([\#2935](https://github.com/matrix-org/matrix-js-sdk/pull/2935)).
--   Fix highlight notifications increasing when total notification is zero ([\#2937](https://github.com/matrix-org/matrix-js-sdk/pull/2937)). Fixes vector-im/element-web#23885.
--   Fix synthesizeReceipt ([\#2916](https://github.com/matrix-org/matrix-js-sdk/pull/2916)). Fixes vector-im/element-web#23827 vector-im/element-web#23754 and vector-im/element-web#23847.
-
-# Changes in [21.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.2.0) (2022-11-22)
+Changes in [21.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.2.0) (2022-11-22)
+==================================================================================================
 
 ## ✨ Features
-
--   Make calls go back to 'connecting' state when media lost ([\#2880](https://github.com/matrix-org/matrix-js-sdk/pull/2880)).
--   Add ability to send unthreaded receipt ([\#2878](https://github.com/matrix-org/matrix-js-sdk/pull/2878)).
--   Add way to abort search requests ([\#2877](https://github.com/matrix-org/matrix-js-sdk/pull/2877)).
--   sliding sync: add custom room subscriptions support ([\#2834](https://github.com/matrix-org/matrix-js-sdk/pull/2834)).
--   webrtc: add advanced audio settings ([\#2434](https://github.com/matrix-org/matrix-js-sdk/pull/2434)). Contributed by @MrAnno.
--   Add support for group calls using MSC3401 ([\#2553](https://github.com/matrix-org/matrix-js-sdk/pull/2553)).
--   Make the js-sdk conform to tsc --strict ([\#2835](https://github.com/matrix-org/matrix-js-sdk/pull/2835)). Fixes #2112 #2116 and #2124.
--   Let leave requests outlive the window ([\#2815](https://github.com/matrix-org/matrix-js-sdk/pull/2815)). Fixes vector-im/element-call#639.
--   Add event and message capabilities to RoomWidgetClient ([\#2797](https://github.com/matrix-org/matrix-js-sdk/pull/2797)).
--   Misc fixes for group call widgets ([\#2657](https://github.com/matrix-org/matrix-js-sdk/pull/2657)).
--   Support nested Matrix clients via the widget API ([\#2473](https://github.com/matrix-org/matrix-js-sdk/pull/2473)).
--   Set max average bitrate on PTT calls ([\#2499](https://github.com/matrix-org/matrix-js-sdk/pull/2499)). Fixes vector-im/element-call#440.
--   Add config option for e2e group call signalling ([\#2492](https://github.com/matrix-org/matrix-js-sdk/pull/2492)).
--   Enable DTX on audio tracks in calls ([\#2482](https://github.com/matrix-org/matrix-js-sdk/pull/2482)).
--   Don't ignore call member events with a distant future expiration date ([\#2466](https://github.com/matrix-org/matrix-js-sdk/pull/2466)).
--   Expire call member state events after 1 hour ([\#2446](https://github.com/matrix-org/matrix-js-sdk/pull/2446)).
--   Emit unknown device errors for group call participants without e2e ([\#2447](https://github.com/matrix-org/matrix-js-sdk/pull/2447)).
--   Mute disconnected peers in PTT mode ([\#2421](https://github.com/matrix-org/matrix-js-sdk/pull/2421)).
--   Add support for sending encrypted to-device events with OLM ([\#2322](https://github.com/matrix-org/matrix-js-sdk/pull/2322)). Contributed by @robertlong.
--   Support for PTT group call mode ([\#2338](https://github.com/matrix-org/matrix-js-sdk/pull/2338)).
+ * Make calls go back to 'connecting' state when media lost ([\#2880](https://github.com/matrix-org/matrix-js-sdk/pull/2880)).
+ * Add ability to send unthreaded receipt ([\#2878](https://github.com/matrix-org/matrix-js-sdk/pull/2878)).
+ * Add way to abort search requests ([\#2877](https://github.com/matrix-org/matrix-js-sdk/pull/2877)).
+ * sliding sync: add custom room subscriptions support ([\#2834](https://github.com/matrix-org/matrix-js-sdk/pull/2834)).
+ * webrtc: add advanced audio settings ([\#2434](https://github.com/matrix-org/matrix-js-sdk/pull/2434)). Contributed by @MrAnno.
+ * Add support for group calls using MSC3401 ([\#2553](https://github.com/matrix-org/matrix-js-sdk/pull/2553)).
+ * Make the js-sdk conform to tsc --strict ([\#2835](https://github.com/matrix-org/matrix-js-sdk/pull/2835)). Fixes #2112 #2116 and #2124.
+ * Let leave requests outlive the window ([\#2815](https://github.com/matrix-org/matrix-js-sdk/pull/2815)). Fixes vector-im/element-call#639.
+ * Add event and message capabilities to RoomWidgetClient ([\#2797](https://github.com/matrix-org/matrix-js-sdk/pull/2797)).
+ * Misc fixes for group call widgets ([\#2657](https://github.com/matrix-org/matrix-js-sdk/pull/2657)).
+ * Support nested Matrix clients via the widget API ([\#2473](https://github.com/matrix-org/matrix-js-sdk/pull/2473)).
+ * Set max average bitrate on PTT calls ([\#2499](https://github.com/matrix-org/matrix-js-sdk/pull/2499)). Fixes vector-im/element-call#440.
+ * Add config option for e2e group call signalling ([\#2492](https://github.com/matrix-org/matrix-js-sdk/pull/2492)).
+ * Enable DTX on audio tracks in calls ([\#2482](https://github.com/matrix-org/matrix-js-sdk/pull/2482)).
+ * Don't ignore call member events with a distant future expiration date ([\#2466](https://github.com/matrix-org/matrix-js-sdk/pull/2466)).
+ * Expire call member state events after 1 hour ([\#2446](https://github.com/matrix-org/matrix-js-sdk/pull/2446)).
+ * Emit unknown device errors for group call participants without e2e ([\#2447](https://github.com/matrix-org/matrix-js-sdk/pull/2447)).
+ * Mute disconnected peers in PTT mode ([\#2421](https://github.com/matrix-org/matrix-js-sdk/pull/2421)).
+ * Add support for sending encrypted to-device events with OLM ([\#2322](https://github.com/matrix-org/matrix-js-sdk/pull/2322)). Contributed by @robertlong.
+ * Support for PTT group call mode ([\#2338](https://github.com/matrix-org/matrix-js-sdk/pull/2338)).
 
 ## 🐛 Bug Fixes
-
--   Fix registration add phone number not working ([\#2876](https://github.com/matrix-org/matrix-js-sdk/pull/2876)). Contributed by @bagvand.
--   Use an underride rule for Element Call notifications ([\#2873](https://github.com/matrix-org/matrix-js-sdk/pull/2873)). Fixes vector-im/element-web#23691.
--   Fixes unwanted highlight notifications with encrypted threads ([\#2862](https://github.com/matrix-org/matrix-js-sdk/pull/2862)).
--   Extra insurance that we don't mix events in the wrong timelines - v2 ([\#2856](https://github.com/matrix-org/matrix-js-sdk/pull/2856)). Contributed by @MadLittleMods.
--   Hide pending events in thread timelines ([\#2843](https://github.com/matrix-org/matrix-js-sdk/pull/2843)). Fixes vector-im/element-web#23684.
--   Fix pagination token tracking for mixed room timelines ([\#2855](https://github.com/matrix-org/matrix-js-sdk/pull/2855)). Fixes vector-im/element-web#23695.
--   Extra insurance that we don't mix events in the wrong timelines ([\#2848](https://github.com/matrix-org/matrix-js-sdk/pull/2848)). Contributed by @MadLittleMods.
--   Do not freeze state in `initialiseState()` ([\#2846](https://github.com/matrix-org/matrix-js-sdk/pull/2846)).
--   Don't remove our own member for a split second when entering a call ([\#2844](https://github.com/matrix-org/matrix-js-sdk/pull/2844)).
--   Resolve races between `initLocalCallFeed` and `leave` ([\#2826](https://github.com/matrix-org/matrix-js-sdk/pull/2826)).
--   Add throwOnFail to groupCall.setScreensharingEnabled ([\#2787](https://github.com/matrix-org/matrix-js-sdk/pull/2787)).
--   Fix connectivity regressions ([\#2780](https://github.com/matrix-org/matrix-js-sdk/pull/2780)).
--   Fix screenshare failing after several attempts ([\#2771](https://github.com/matrix-org/matrix-js-sdk/pull/2771)). Fixes vector-im/element-call#625.
--   Don't block muting/unmuting on network requests ([\#2754](https://github.com/matrix-org/matrix-js-sdk/pull/2754)). Fixes vector-im/element-call#592.
--   Fix ICE restarts ([\#2702](https://github.com/matrix-org/matrix-js-sdk/pull/2702)).
--   Target widget actions at a specific room ([\#2670](https://github.com/matrix-org/matrix-js-sdk/pull/2670)).
--   Add tests for ice candidate sending ([\#2674](https://github.com/matrix-org/matrix-js-sdk/pull/2674)).
--   Prevent exception when muting ([\#2667](https://github.com/matrix-org/matrix-js-sdk/pull/2667)). Fixes vector-im/element-call#578.
--   Fix race in creating calls ([\#2662](https://github.com/matrix-org/matrix-js-sdk/pull/2662)).
--   Add client.waitUntilRoomReadyForGroupCalls() ([\#2641](https://github.com/matrix-org/matrix-js-sdk/pull/2641)).
--   Wait for client to start syncing before making group calls ([\#2632](https://github.com/matrix-org/matrix-js-sdk/pull/2632)). Fixes #2589.
--   Add GroupCallEventHandlerEvent.Room ([\#2631](https://github.com/matrix-org/matrix-js-sdk/pull/2631)).
--   Add missing events from reemitter to GroupCall ([\#2527](https://github.com/matrix-org/matrix-js-sdk/pull/2527)). Contributed by @toger5.
--   Prevent double mute status changed events ([\#2502](https://github.com/matrix-org/matrix-js-sdk/pull/2502)).
--   Don't mute the remote side immediately in PTT calls ([\#2487](https://github.com/matrix-org/matrix-js-sdk/pull/2487)). Fixes vector-im/element-call#425.
--   Fix some MatrixCall leaks and use a shared AudioContext ([\#2484](https://github.com/matrix-org/matrix-js-sdk/pull/2484)). Fixes vector-im/element-call#412.
--   Don't block muting on determining whether the device exists ([\#2461](https://github.com/matrix-org/matrix-js-sdk/pull/2461)).
--   Only clone streams on Safari ([\#2450](https://github.com/matrix-org/matrix-js-sdk/pull/2450)). Fixes vector-im/element-call#267.
--   Set PTT mode on call correctly ([\#2445](https://github.com/matrix-org/matrix-js-sdk/pull/2445)). Fixes vector-im/element-call#382.
--   Wait for mute event to send in PTT mode ([\#2401](https://github.com/matrix-org/matrix-js-sdk/pull/2401)).
--   Handle other members having no e2e keys ([\#2383](https://github.com/matrix-org/matrix-js-sdk/pull/2383)). Fixes vector-im/element-call#338.
--   Fix races when muting/unmuting ([\#2370](https://github.com/matrix-org/matrix-js-sdk/pull/2370)).
-
-# Changes in [21.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.1.0) (2022-11-08)
+ * Fix registration add phone number not working ([\#2876](https://github.com/matrix-org/matrix-js-sdk/pull/2876)). Contributed by @bagvand.
+ * Use an underride rule for Element Call notifications ([\#2873](https://github.com/matrix-org/matrix-js-sdk/pull/2873)). Fixes vector-im/element-web#23691.
+ * Fixes unwanted highlight notifications with encrypted threads ([\#2862](https://github.com/matrix-org/matrix-js-sdk/pull/2862)).
+ * Extra insurance that we don't mix events in the wrong timelines - v2 ([\#2856](https://github.com/matrix-org/matrix-js-sdk/pull/2856)). Contributed by @MadLittleMods.
+ * Hide pending events in thread timelines ([\#2843](https://github.com/matrix-org/matrix-js-sdk/pull/2843)). Fixes vector-im/element-web#23684.
+ * Fix pagination token tracking for mixed room timelines ([\#2855](https://github.com/matrix-org/matrix-js-sdk/pull/2855)). Fixes vector-im/element-web#23695.
+ * Extra insurance that we don't mix events in the wrong timelines ([\#2848](https://github.com/matrix-org/matrix-js-sdk/pull/2848)). Contributed by @MadLittleMods.
+ * Do not freeze state in `initialiseState()` ([\#2846](https://github.com/matrix-org/matrix-js-sdk/pull/2846)).
+ * Don't remove our own member for a split second when entering a call ([\#2844](https://github.com/matrix-org/matrix-js-sdk/pull/2844)).
+ * Resolve races between `initLocalCallFeed` and `leave` ([\#2826](https://github.com/matrix-org/matrix-js-sdk/pull/2826)).
+ * Add throwOnFail to groupCall.setScreensharingEnabled ([\#2787](https://github.com/matrix-org/matrix-js-sdk/pull/2787)).
+ * Fix connectivity regressions ([\#2780](https://github.com/matrix-org/matrix-js-sdk/pull/2780)).
+ * Fix screenshare failing after several attempts ([\#2771](https://github.com/matrix-org/matrix-js-sdk/pull/2771)). Fixes vector-im/element-call#625.
+ * Don't block muting/unmuting on network requests ([\#2754](https://github.com/matrix-org/matrix-js-sdk/pull/2754)). Fixes vector-im/element-call#592.
+ * Fix ICE restarts ([\#2702](https://github.com/matrix-org/matrix-js-sdk/pull/2702)).
+ * Target widget actions at a specific room ([\#2670](https://github.com/matrix-org/matrix-js-sdk/pull/2670)).
+ * Add tests for ice candidate sending ([\#2674](https://github.com/matrix-org/matrix-js-sdk/pull/2674)).
+ * Prevent exception when muting ([\#2667](https://github.com/matrix-org/matrix-js-sdk/pull/2667)). Fixes vector-im/element-call#578.
+ * Fix race in creating calls ([\#2662](https://github.com/matrix-org/matrix-js-sdk/pull/2662)).
+ * Add client.waitUntilRoomReadyForGroupCalls() ([\#2641](https://github.com/matrix-org/matrix-js-sdk/pull/2641)).
+ * Wait for client to start syncing before making group calls ([\#2632](https://github.com/matrix-org/matrix-js-sdk/pull/2632)). Fixes #2589.
+ * Add GroupCallEventHandlerEvent.Room ([\#2631](https://github.com/matrix-org/matrix-js-sdk/pull/2631)).
+ * Add missing events from reemitter to GroupCall ([\#2527](https://github.com/matrix-org/matrix-js-sdk/pull/2527)). Contributed by @toger5.
+ * Prevent double mute status changed events ([\#2502](https://github.com/matrix-org/matrix-js-sdk/pull/2502)).
+ * Don't mute the remote side immediately in PTT calls ([\#2487](https://github.com/matrix-org/matrix-js-sdk/pull/2487)). Fixes vector-im/element-call#425.
+ * Fix some MatrixCall leaks and use a shared AudioContext ([\#2484](https://github.com/matrix-org/matrix-js-sdk/pull/2484)). Fixes vector-im/element-call#412.
+ * Don't block muting on determining whether the device exists ([\#2461](https://github.com/matrix-org/matrix-js-sdk/pull/2461)).
+ * Only clone streams on Safari ([\#2450](https://github.com/matrix-org/matrix-js-sdk/pull/2450)). Fixes vector-im/element-call#267.
+ * Set PTT mode on call correctly ([\#2445](https://github.com/matrix-org/matrix-js-sdk/pull/2445)). Fixes vector-im/element-call#382.
+ * Wait for mute event to send in PTT mode ([\#2401](https://github.com/matrix-org/matrix-js-sdk/pull/2401)).
+ * Handle other members having no e2e keys ([\#2383](https://github.com/matrix-org/matrix-js-sdk/pull/2383)). Fixes vector-im/element-call#338.
+ * Fix races when muting/unmuting ([\#2370](https://github.com/matrix-org/matrix-js-sdk/pull/2370)).
+
+Changes in [21.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.1.0) (2022-11-08)
+==================================================================================================
 
 ## ✨ Features
-
--   Loading threads with server-side assistance ([\#2735](https://github.com/matrix-org/matrix-js-sdk/pull/2735)). Contributed by @justjanne.
--   Support sign in + E2EE set up using QR code implementing MSC3886, MSC3903 and MSC3906 ([\#2747](https://github.com/matrix-org/matrix-js-sdk/pull/2747)). Contributed by @hughns.
+ * Loading threads with server-side assistance ([\#2735](https://github.com/matrix-org/matrix-js-sdk/pull/2735)). Contributed by @justjanne.
+ * Support sign in + E2EE set up using QR code implementing MSC3886, MSC3903 and MSC3906 ([\#2747](https://github.com/matrix-org/matrix-js-sdk/pull/2747)). Contributed by @hughns.
 
 ## 🐛 Bug Fixes
+ * Replace `instanceof Array` with `Array.isArray` ([\#2812](https://github.com/matrix-org/matrix-js-sdk/pull/2812)). Fixes #2811.
+ * Emit UnreadNotification event on notifications reset ([\#2804](https://github.com/matrix-org/matrix-js-sdk/pull/2804)). Fixes vector-im/element-web#23590.
+ * Fix incorrect prevEv being sent in ClientEvent.AccountData events ([\#2794](https://github.com/matrix-org/matrix-js-sdk/pull/2794)).
+ * Fix build error caused by wrong ts-strict improvements ([\#2783](https://github.com/matrix-org/matrix-js-sdk/pull/2783)). Contributed by @justjanne.
+ * Encryption should not hinder verification ([\#2734](https://github.com/matrix-org/matrix-js-sdk/pull/2734)).
 
--   Replace `instanceof Array` with `Array.isArray` ([\#2812](https://github.com/matrix-org/matrix-js-sdk/pull/2812)). Fixes #2811.
--   Emit UnreadNotification event on notifications reset ([\#2804](https://github.com/matrix-org/matrix-js-sdk/pull/2804)). Fixes vector-im/element-web#23590.
--   Fix incorrect prevEv being sent in ClientEvent.AccountData events ([\#2794](https://github.com/matrix-org/matrix-js-sdk/pull/2794)).
--   Fix build error caused by wrong ts-strict improvements ([\#2783](https://github.com/matrix-org/matrix-js-sdk/pull/2783)). Contributed by @justjanne.
--   Encryption should not hinder verification ([\#2734](https://github.com/matrix-org/matrix-js-sdk/pull/2734)).
-
-# Changes in [21.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.1) (2022-11-01)
+Changes in [21.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.1) (2022-11-01)
+==================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix default behavior of Room.getBlacklistUnverifiedDevices ([\#2830](https://github.com/matrix-org/matrix-js-sdk/pull/2830)). Contributed by @duxovni.
+ * Catch server versions API call exception when starting the client ([\#2828](https://github.com/matrix-org/matrix-js-sdk/pull/2828)). Fixes vector-im/element-web#23634.
+ * Fix authedRequest including `Authorization: Bearer undefined` for password resets ([\#2822](https://github.com/matrix-org/matrix-js-sdk/pull/2822)). Fixes vector-im/element-web#23655.
 
--   Fix default behavior of Room.getBlacklistUnverifiedDevices ([\#2830](https://github.com/matrix-org/matrix-js-sdk/pull/2830)). Contributed by @duxovni.
--   Catch server versions API call exception when starting the client ([\#2828](https://github.com/matrix-org/matrix-js-sdk/pull/2828)). Fixes vector-im/element-web#23634.
--   Fix authedRequest including `Authorization: Bearer undefined` for password resets ([\#2822](https://github.com/matrix-org/matrix-js-sdk/pull/2822)). Fixes vector-im/element-web#23655.
-
-# Changes in [21.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.0) (2022-10-25)
+Changes in [21.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v21.0.0) (2022-10-25)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Changes the `uploadContent` API, kills off `request` and `browser-request` in favour of `fetch`, removed callback support on a lot of the methods, adds a lot of tests. ([\#2719](https://github.com/matrix-org/matrix-js-sdk/pull/2719)). Fixes #2415 and #801.
--   Remove deprecated `m.room.aliases` references ([\#2759](https://github.com/matrix-org/matrix-js-sdk/pull/2759)). Fixes vector-im/element-web#12680.
+ * Changes the `uploadContent` API, kills off `request` and `browser-request` in favour of `fetch`, removed callback support on a lot of the methods, adds a lot of tests. ([\#2719](https://github.com/matrix-org/matrix-js-sdk/pull/2719)). Fixes #2415 and #801.
+ * Remove deprecated `m.room.aliases` references ([\#2759](https://github.com/matrix-org/matrix-js-sdk/pull/2759)). Fixes vector-im/element-web#12680.
 
 ## ✨ Features
-
--   Remove node-specific crypto bits, use Node 16's WebCrypto ([\#2762](https://github.com/matrix-org/matrix-js-sdk/pull/2762)). Fixes #2760.
--   Export types for MatrixEvent and Room emitted events, and make event handler map types stricter ([\#2750](https://github.com/matrix-org/matrix-js-sdk/pull/2750)). Contributed by @stas-demydiuk.
--   Use even more stable calls to `/room_keys` ([\#2746](https://github.com/matrix-org/matrix-js-sdk/pull/2746)).
--   Upgrade to Olm 3.2.13 which has been repackaged to support Node 18 ([\#2744](https://github.com/matrix-org/matrix-js-sdk/pull/2744)).
--   Fix `power_level_content_override` type ([\#2741](https://github.com/matrix-org/matrix-js-sdk/pull/2741)).
--   Add custom notification handling for MSC3401 call events ([\#2720](https://github.com/matrix-org/matrix-js-sdk/pull/2720)).
--   Add support for unread thread notifications ([\#2726](https://github.com/matrix-org/matrix-js-sdk/pull/2726)).
--   Load Thread List with server-side assistance (MSC3856) ([\#2602](https://github.com/matrix-org/matrix-js-sdk/pull/2602)).
--   Use stable calls to `/room_keys` ([\#2729](https://github.com/matrix-org/matrix-js-sdk/pull/2729)). Fixes vector-im/element-web#22839.
+ * Remove node-specific crypto bits, use Node 16's WebCrypto ([\#2762](https://github.com/matrix-org/matrix-js-sdk/pull/2762)). Fixes #2760.
+ * Export types for MatrixEvent and Room emitted events, and make event handler map types stricter ([\#2750](https://github.com/matrix-org/matrix-js-sdk/pull/2750)). Contributed by @stas-demydiuk.
+ * Use even more stable calls to `/room_keys` ([\#2746](https://github.com/matrix-org/matrix-js-sdk/pull/2746)).
+ * Upgrade to Olm 3.2.13 which has been repackaged to support Node 18 ([\#2744](https://github.com/matrix-org/matrix-js-sdk/pull/2744)).
+ * Fix `power_level_content_override` type ([\#2741](https://github.com/matrix-org/matrix-js-sdk/pull/2741)).
+ * Add custom notification handling for MSC3401 call events  ([\#2720](https://github.com/matrix-org/matrix-js-sdk/pull/2720)).
+ * Add support for unread thread notifications ([\#2726](https://github.com/matrix-org/matrix-js-sdk/pull/2726)).
+ * Load Thread List with server-side assistance (MSC3856) ([\#2602](https://github.com/matrix-org/matrix-js-sdk/pull/2602)).
+ * Use stable calls to `/room_keys` ([\#2729](https://github.com/matrix-org/matrix-js-sdk/pull/2729)). Fixes vector-im/element-web#22839.
 
 ## 🐛 Bug Fixes
+ * Fix POST data not being passed for registerWithIdentityServer ([\#2769](https://github.com/matrix-org/matrix-js-sdk/pull/2769)). Fixes matrix-org/element-web-rageshakes#16206.
+ * Fix IdentityPrefix.V2 containing spurious `/api` ([\#2761](https://github.com/matrix-org/matrix-js-sdk/pull/2761)). Fixes vector-im/element-web#23505.
+ * Always send back an httpStatus property if one is known ([\#2753](https://github.com/matrix-org/matrix-js-sdk/pull/2753)).
+ * Check for AbortError, not any generic connection error, to avoid tightlooping ([\#2752](https://github.com/matrix-org/matrix-js-sdk/pull/2752)).
+ * Correct the dir parameter of MSC3715 ([\#2745](https://github.com/matrix-org/matrix-js-sdk/pull/2745)). Contributed by @dhenneke.
+ * Fix sync init when thread unread notif is not supported ([\#2739](https://github.com/matrix-org/matrix-js-sdk/pull/2739)). Fixes vector-im/element-web#23435.
+ * Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
 
--   Fix POST data not being passed for registerWithIdentityServer ([\#2769](https://github.com/matrix-org/matrix-js-sdk/pull/2769)). Fixes matrix-org/element-web-rageshakes#16206.
--   Fix IdentityPrefix.V2 containing spurious `/api` ([\#2761](https://github.com/matrix-org/matrix-js-sdk/pull/2761)). Fixes vector-im/element-web#23505.
--   Always send back an httpStatus property if one is known ([\#2753](https://github.com/matrix-org/matrix-js-sdk/pull/2753)).
--   Check for AbortError, not any generic connection error, to avoid tightlooping ([\#2752](https://github.com/matrix-org/matrix-js-sdk/pull/2752)).
--   Correct the dir parameter of MSC3715 ([\#2745](https://github.com/matrix-org/matrix-js-sdk/pull/2745)). Contributed by @dhenneke.
--   Fix sync init when thread unread notif is not supported ([\#2739](https://github.com/matrix-org/matrix-js-sdk/pull/2739)). Fixes vector-im/element-web#23435.
--   Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
-
-# Changes in [20.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.1.0) (2022-10-11)
+Changes in [20.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.1.0) (2022-10-11)
+============================================================================================================
 
 ## ✨ Features
-
--   Add local notification settings capability ([\#2700](https://github.com/matrix-org/matrix-js-sdk/pull/2700)).
--   Implementation of MSC3882 login token request ([\#2687](https://github.com/matrix-org/matrix-js-sdk/pull/2687)). Contributed by @hughns.
--   Typings for MSC2965 OIDC provider discovery ([\#2424](https://github.com/matrix-org/matrix-js-sdk/pull/2424)). Contributed by @hughns.
--   Support to remotely toggle push notifications ([\#2686](https://github.com/matrix-org/matrix-js-sdk/pull/2686)).
--   Read receipts for threads ([\#2635](https://github.com/matrix-org/matrix-js-sdk/pull/2635)).
+ * Add local notification settings capability ([\#2700](https://github.com/matrix-org/matrix-js-sdk/pull/2700)).
+ * Implementation of MSC3882 login token request ([\#2687](https://github.com/matrix-org/matrix-js-sdk/pull/2687)). Contributed by @hughns.
+ * Typings for MSC2965 OIDC provider discovery ([\#2424](https://github.com/matrix-org/matrix-js-sdk/pull/2424)). Contributed by @hughns.
+ * Support to remotely toggle push notifications ([\#2686](https://github.com/matrix-org/matrix-js-sdk/pull/2686)).
+ * Read receipts for threads ([\#2635](https://github.com/matrix-org/matrix-js-sdk/pull/2635)).
 
 ## 🐛 Bug Fixes
+ * Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
+ * Unexpected ignored self key request when it's not shared history ([\#2724](https://github.com/matrix-org/matrix-js-sdk/pull/2724)). Contributed by @mcalinghee.
+ * Fix IDB initial migration handling causing spurious lazy loading upgrade loops ([\#2718](https://github.com/matrix-org/matrix-js-sdk/pull/2718)). Fixes vector-im/element-web#23377.
+ * Fix backpagination at end logic being spec non-conforming ([\#2680](https://github.com/matrix-org/matrix-js-sdk/pull/2680)). Fixes vector-im/element-web#22784.
 
--   Use the correct sender key when checking shared secret ([\#2730](https://github.com/matrix-org/matrix-js-sdk/pull/2730)). Fixes vector-im/element-web#23374.
--   Unexpected ignored self key request when it's not shared history ([\#2724](https://github.com/matrix-org/matrix-js-sdk/pull/2724)). Contributed by @mcalinghee.
--   Fix IDB initial migration handling causing spurious lazy loading upgrade loops ([\#2718](https://github.com/matrix-org/matrix-js-sdk/pull/2718)). Fixes vector-im/element-web#23377.
--   Fix backpagination at end logic being spec non-conforming ([\#2680](https://github.com/matrix-org/matrix-js-sdk/pull/2680)). Fixes vector-im/element-web#22784.
-
-# Changes in [20.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.2) (2022-09-30)
+Changes in [20.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.2) (2022-09-30)
+==================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix issue in sync when crypto is not supported by client ([\#2715](https://github.com/matrix-org/matrix-js-sdk/pull/2715)). Contributed by @stas-demydiuk.
 
--   Fix issue in sync when crypto is not supported by client ([\#2715](https://github.com/matrix-org/matrix-js-sdk/pull/2715)). Contributed by @stas-demydiuk.
-
-# Changes in [20.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.1) (2022-09-28)
+Changes in [20.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.1) (2022-09-28)
+==================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix missing return when receiving an invitation without shared history ([\#2710](https://github.com/matrix-org/matrix-js-sdk/pull/2710)).
 
--   Fix missing return when receiving an invitation without shared history ([\#2710](https://github.com/matrix-org/matrix-js-sdk/pull/2710)).
-
-# Changes in [20.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.0) (2022-09-28)
+Changes in [20.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v20.0.0) (2022-09-28)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES
+ * Bump IDB crypto store version ([\#2705](https://github.com/matrix-org/matrix-js-sdk/pull/2705)).
 
--   Bump IDB crypto store version ([\#2705](https://github.com/matrix-org/matrix-js-sdk/pull/2705)).
-
-# Changes in [19.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.7.0) (2022-09-28)
+Changes in [19.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.7.0) (2022-09-28)
+==================================================================================================
 
 ## 🔒 Security
+* Fix for [CVE-2022-39249](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39249)
+* Fix for [CVE-2022-39250](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39250)
+* Fix for [CVE-2022-39251](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39251)
+* Fix for [CVE-2022-39236](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39236)
 
--   Fix for [CVE-2022-39249](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39249)
--   Fix for [CVE-2022-39250](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39250)
--   Fix for [CVE-2022-39251](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39251)
--   Fix for [CVE-2022-39236](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D39236)
-
-# Changes in [19.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.6.0) (2022-09-27)
+Changes in [19.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.6.0) (2022-09-27)
+==================================================================================================
 
 ## ✨ Features
-
--   Add a property aggregating all names of a NamespacedValue ([\#2656](https://github.com/matrix-org/matrix-js-sdk/pull/2656)).
--   Implementation of MSC3824 to add action= param on SSO login ([\#2398](https://github.com/matrix-org/matrix-js-sdk/pull/2398)). Contributed by @hughns.
--   Add invited_count and joined_count to sliding sync room responses. ([\#2628](https://github.com/matrix-org/matrix-js-sdk/pull/2628)).
--   Base support for MSC3847: Ignore invites with policy rooms ([\#2626](https://github.com/matrix-org/matrix-js-sdk/pull/2626)). Contributed by @Yoric.
+ * Add a property aggregating all names of a NamespacedValue ([\#2656](https://github.com/matrix-org/matrix-js-sdk/pull/2656)).
+ * Implementation of MSC3824 to add action= param on SSO login ([\#2398](https://github.com/matrix-org/matrix-js-sdk/pull/2398)). Contributed by @hughns.
+ * Add invited_count and joined_count to sliding sync room responses. ([\#2628](https://github.com/matrix-org/matrix-js-sdk/pull/2628)).
+ * Base support for MSC3847: Ignore invites with policy rooms ([\#2626](https://github.com/matrix-org/matrix-js-sdk/pull/2626)). Contributed by @Yoric.
 
 ## 🐛 Bug Fixes
+ * Fix handling of remote echoes doubling up ([\#2639](https://github.com/matrix-org/matrix-js-sdk/pull/2639)). Fixes #2618.
 
--   Fix handling of remote echoes doubling up ([\#2639](https://github.com/matrix-org/matrix-js-sdk/pull/2639)). Fixes #2618.
-
-# Changes in [19.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.5.0) (2022-09-13)
+Changes in [19.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.5.0) (2022-09-13)
+==================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix bug in deepCompare which would incorrectly return objects with disjoint keys as equal ([\#2586](https://github.com/matrix-org/matrix-js-sdk/pull/2586)). Contributed by @3nprob.
+ * Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
+ * Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
+ * Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
 
--   Fix bug in deepCompare which would incorrectly return objects with disjoint keys as equal ([\#2586](https://github.com/matrix-org/matrix-js-sdk/pull/2586)). Contributed by @3nprob.
--   Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
--   Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
--   Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
-
-# Changes in [19.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.4.0) (2022-08-31)
+Changes in [19.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.4.0) (2022-08-31)
+==================================================================================================
 
 ## 🔒 Security
-
--   Fix for [CVE-2022-36059](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D36059)
+* Fix for [CVE-2022-36059](https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=CVE%2D2022%2D36059)
 
 Find more details at https://matrix.org/blog/2022/08/31/security-releases-matrix-js-sdk-19-4-0-and-matrix-react-sdk-3-53-0
 
 ## ✨ Features
-
--   Re-emit room state events on rooms ([\#2607](https://github.com/matrix-org/matrix-js-sdk/pull/2607)).
--   Add ability to override built in room name generator for an i18n'able one ([\#2609](https://github.com/matrix-org/matrix-js-sdk/pull/2609)).
--   Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
+ * Re-emit room state events on rooms ([\#2607](https://github.com/matrix-org/matrix-js-sdk/pull/2607)).
+ * Add ability to override built in room name generator for an i18n'able one ([\#2609](https://github.com/matrix-org/matrix-js-sdk/pull/2609)).
+ * Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
 
 ## 🐛 Bug Fixes
+ * Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
+ * Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
+ * Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
+ * fixed a sliding sync bug which could cause the `roomIndexToRoomId` map to be incorrect when a new room is added in the middle of the list or when an existing room is deleted from the middle of the list. ([\#2610](https://github.com/matrix-org/matrix-js-sdk/pull/2610)).
+ * Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078. Contributed by @kerryarchibald.
+ * Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
+ * fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
 
--   Refactor Sync and fix `initialSyncLimit` ([\#2587](https://github.com/matrix-org/matrix-js-sdk/pull/2587)).
--   Use deep equality comparisons when searching for outgoing key requests by target ([\#2623](https://github.com/matrix-org/matrix-js-sdk/pull/2623)). Contributed by @duxovni.
--   Fix room membership race with PREPARED event ([\#2613](https://github.com/matrix-org/matrix-js-sdk/pull/2613)). Contributed by @jotto.
--   fixed a sliding sync bug which could cause the `roomIndexToRoomId` map to be incorrect when a new room is added in the middle of the list or when an existing room is deleted from the middle of the list. ([\#2610](https://github.com/matrix-org/matrix-js-sdk/pull/2610)).
--   Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078. Contributed by @kerryarchibald.
--   Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
--   fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
-
-# Changes in [19.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.3.0) (2022-08-16)
+Changes in [19.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.3.0) (2022-08-16)
+==================================================================================================
 
 ## ✨ Features
-
--   Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
--   Emit an event when the client receives TURN servers ([\#2529](https://github.com/matrix-org/matrix-js-sdk/pull/2529)).
--   Add support for stable prefixes for MSC2285 ([\#2524](https://github.com/matrix-org/matrix-js-sdk/pull/2524)).
--   Remove stream-replacement ([\#2551](https://github.com/matrix-org/matrix-js-sdk/pull/2551)).
--   Add support for sending user-defined encrypted to-device messages ([\#2528](https://github.com/matrix-org/matrix-js-sdk/pull/2528)).
--   Retry to-device messages ([\#2549](https://github.com/matrix-org/matrix-js-sdk/pull/2549)). Fixes vector-im/element-web#12851.
--   Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
--   Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
+ * Add txn_id support to sliding sync ([\#2567](https://github.com/matrix-org/matrix-js-sdk/pull/2567)).
+ * Emit an event when the client receives TURN servers ([\#2529](https://github.com/matrix-org/matrix-js-sdk/pull/2529)).
+ * Add support for stable prefixes for MSC2285 ([\#2524](https://github.com/matrix-org/matrix-js-sdk/pull/2524)).
+ * Remove stream-replacement ([\#2551](https://github.com/matrix-org/matrix-js-sdk/pull/2551)).
+ * Add support for sending user-defined encrypted to-device messages ([\#2528](https://github.com/matrix-org/matrix-js-sdk/pull/2528)).
+ * Retry to-device messages ([\#2549](https://github.com/matrix-org/matrix-js-sdk/pull/2549)). Fixes vector-im/element-web#12851.
+ * Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
+ * Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
 
 ## 🐛 Bug Fixes
+ * Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078.
+ * Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
+ * Fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
+ * Don't load the sync accumulator if there's already a sync persist in flight ([\#2569](https://github.com/matrix-org/matrix-js-sdk/pull/2569)).
 
--   Fix: Handle parsing of a beacon info event without asset ([\#2591](https://github.com/matrix-org/matrix-js-sdk/pull/2591)). Fixes vector-im/element-web#23078.
--   Fix finding event read up to if stable private read receipts is missing ([\#2585](https://github.com/matrix-org/matrix-js-sdk/pull/2585)). Fixes vector-im/element-web#23027.
--   Fixed a sliding sync issue where history could be interpreted as live events. ([\#2583](https://github.com/matrix-org/matrix-js-sdk/pull/2583)).
--   Don't load the sync accumulator if there's already a sync persist in flight ([\#2569](https://github.com/matrix-org/matrix-js-sdk/pull/2569)).
-
-# Changes in [19.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.2.0) (2022-08-02)
+Changes in [19.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.2.0) (2022-08-02)
+==================================================================================================
 
 ## 🦖 Deprecations
-
--   Remove unstable support for `m.room_key.withheld` ([\#2512](https://github.com/matrix-org/matrix-js-sdk/pull/2512)). Fixes #2233.
+ * Remove unstable support for `m.room_key.withheld` ([\#2512](https://github.com/matrix-org/matrix-js-sdk/pull/2512)). Fixes #2233.
 
 ## ✨ Features
-
--   Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
--   Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
--   Add support for MSC3575: Sliding Sync ([\#2242](https://github.com/matrix-org/matrix-js-sdk/pull/2242)).
+ * Sliding sync: add missing filters from latest MSC ([\#2555](https://github.com/matrix-org/matrix-js-sdk/pull/2555)).
+ * Use stable prefixes for MSC3827 ([\#2537](https://github.com/matrix-org/matrix-js-sdk/pull/2537)).
+ * Add support for MSC3575: Sliding Sync ([\#2242](https://github.com/matrix-org/matrix-js-sdk/pull/2242)).
 
 ## 🐛 Bug Fixes
+ * Correct the units in TURN servers expiry documentation ([\#2520](https://github.com/matrix-org/matrix-js-sdk/pull/2520)).
+ * Re-insert room IDs when decrypting bundled redaction events returned by `/sync` ([\#2531](https://github.com/matrix-org/matrix-js-sdk/pull/2531)). Contributed by @duxovni.
 
--   Correct the units in TURN servers expiry documentation ([\#2520](https://github.com/matrix-org/matrix-js-sdk/pull/2520)).
--   Re-insert room IDs when decrypting bundled redaction events returned by `/sync` ([\#2531](https://github.com/matrix-org/matrix-js-sdk/pull/2531)). Contributed by @duxovni.
-
-# Changes in [19.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.1.0) (2022-07-26)
+Changes in [19.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.1.0) (2022-07-26)
+==================================================================================================
 
 ## 🦖 Deprecations
-
--   Remove MSC3244 support ([\#2504](https://github.com/matrix-org/matrix-js-sdk/pull/2504)).
+ * Remove MSC3244 support ([\#2504](https://github.com/matrix-org/matrix-js-sdk/pull/2504)).
 
 ## ✨ Features
-
--   `room` now exports `KNOWN_SAFE_ROOM_VERSION` ([\#2474](https://github.com/matrix-org/matrix-js-sdk/pull/2474)).
+ * `room` now exports `KNOWN_SAFE_ROOM_VERSION` ([\#2474](https://github.com/matrix-org/matrix-js-sdk/pull/2474)).
 
 ## 🐛 Bug Fixes
+ * Don't crash with undefined room in `processBeaconEvents()` ([\#2500](https://github.com/matrix-org/matrix-js-sdk/pull/2500)). Fixes #2494.
+ * Properly re-insert room ID in bundled thread relation messages from sync ([\#2505](https://github.com/matrix-org/matrix-js-sdk/pull/2505)). Fixes vector-im/element-web#22094. Contributed by @duxovni.
+ * Actually store the identity server in the client when given as an option ([\#2503](https://github.com/matrix-org/matrix-js-sdk/pull/2503)). Fixes vector-im/element-web#22757.
+ * Fix call.collectCallStats() ([\#2480](https://github.com/matrix-org/matrix-js-sdk/pull/2480)).
 
--   Don't crash with undefined room in `processBeaconEvents()` ([\#2500](https://github.com/matrix-org/matrix-js-sdk/pull/2500)). Fixes #2494.
--   Properly re-insert room ID in bundled thread relation messages from sync ([\#2505](https://github.com/matrix-org/matrix-js-sdk/pull/2505)). Fixes vector-im/element-web#22094. Contributed by @duxovni.
--   Actually store the identity server in the client when given as an option ([\#2503](https://github.com/matrix-org/matrix-js-sdk/pull/2503)). Fixes vector-im/element-web#22757.
--   Fix call.collectCallStats() ([\#2480](https://github.com/matrix-org/matrix-js-sdk/pull/2480)).
-
-# Changes in [19.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.0.0) (2022-07-05)
+Changes in [19.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v19.0.0) (2022-07-05)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Remove unused sessionStore ([\#2455](https://github.com/matrix-org/matrix-js-sdk/pull/2455)).
+ * Remove unused sessionStore ([\#2455](https://github.com/matrix-org/matrix-js-sdk/pull/2455)).
 
 ## ✨ Features
-
--   Implement MSC3827: Filtering of `/publicRooms` by room type ([\#2469](https://github.com/matrix-org/matrix-js-sdk/pull/2469)).
--   expose latestLocationEvent on beacon model ([\#2467](https://github.com/matrix-org/matrix-js-sdk/pull/2467)). Contributed by @kerryarchibald.
--   Live location share - add start time leniency ([\#2465](https://github.com/matrix-org/matrix-js-sdk/pull/2465)). Contributed by @kerryarchibald.
--   Log real errors and not just their messages, traces are useful ([\#2464](https://github.com/matrix-org/matrix-js-sdk/pull/2464)).
--   Various changes to `src/crypto` files for correctness ([\#2137](https://github.com/matrix-org/matrix-js-sdk/pull/2137)). Contributed by @ShadowJonathan.
--   Update MSC3786 implementation: Check the `state_key` ([\#2429](https://github.com/matrix-org/matrix-js-sdk/pull/2429)).
--   Timeline needs to refresh when we see a MSC2716 marker event ([\#2299](https://github.com/matrix-org/matrix-js-sdk/pull/2299)). Contributed by @MadLittleMods.
--   Try to load keys from key backup when a message fails to decrypt ([\#2373](https://github.com/matrix-org/matrix-js-sdk/pull/2373)). Fixes vector-im/element-web#21026. Contributed by @duxovni.
+ * Implement MSC3827: Filtering of `/publicRooms` by room type ([\#2469](https://github.com/matrix-org/matrix-js-sdk/pull/2469)).
+ * expose latestLocationEvent on beacon model ([\#2467](https://github.com/matrix-org/matrix-js-sdk/pull/2467)). Contributed by @kerryarchibald.
+ * Live location share - add start time leniency ([\#2465](https://github.com/matrix-org/matrix-js-sdk/pull/2465)). Contributed by @kerryarchibald.
+ * Log real errors and not just their messages, traces are useful ([\#2464](https://github.com/matrix-org/matrix-js-sdk/pull/2464)).
+ * Various changes to `src/crypto` files for correctness ([\#2137](https://github.com/matrix-org/matrix-js-sdk/pull/2137)). Contributed by @ShadowJonathan.
+ * Update MSC3786 implementation: Check the `state_key` ([\#2429](https://github.com/matrix-org/matrix-js-sdk/pull/2429)).
+ * Timeline needs to refresh when we see a MSC2716 marker event  ([\#2299](https://github.com/matrix-org/matrix-js-sdk/pull/2299)). Contributed by @MadLittleMods.
+ * Try to load keys from key backup when a message fails to decrypt ([\#2373](https://github.com/matrix-org/matrix-js-sdk/pull/2373)). Fixes vector-im/element-web#21026. Contributed by @duxovni.
 
 ## 🐛 Bug Fixes
-
--   Send call version `1` as a string ([\#2471](https://github.com/matrix-org/matrix-js-sdk/pull/2471)). Fixes vector-im/element-web#22629.
--   Fix issue with `getEventTimeline` returning undefined for thread roots in main timeline ([\#2454](https://github.com/matrix-org/matrix-js-sdk/pull/2454)). Fixes vector-im/element-web#22539.
--   Add missing `type` property on `IAuthData` ([\#2463](https://github.com/matrix-org/matrix-js-sdk/pull/2463)).
--   Clearly indicate that `lastReply` on a Thread can return falsy ([\#2462](https://github.com/matrix-org/matrix-js-sdk/pull/2462)).
--   Fix issues with getEventTimeline and thread roots ([\#2444](https://github.com/matrix-org/matrix-js-sdk/pull/2444)). Fixes vector-im/element-web#21613.
--   Live location sharing - monitor liveness of beacons yet to start ([\#2437](https://github.com/matrix-org/matrix-js-sdk/pull/2437)). Contributed by @kerryarchibald.
--   Refactor Relations to not be per-EventTimelineSet ([\#2412](https://github.com/matrix-org/matrix-js-sdk/pull/2412)). Fixes #2399 and vector-im/element-web#22298.
--   Add tests for sendEvent threadId handling ([\#2435](https://github.com/matrix-org/matrix-js-sdk/pull/2435)). Fixes vector-im/element-web#22433.
--   Make sure `encryptAndSendKeysToDevices` assumes devices are unique per-user. ([\#2136](https://github.com/matrix-org/matrix-js-sdk/pull/2136)). Fixes #2135. Contributed by @ShadowJonathan.
--   Don't bug the user while re-checking key backups after decryption failures ([\#2430](https://github.com/matrix-org/matrix-js-sdk/pull/2430)). Fixes vector-im/element-web#22416. Contributed by @duxovni.
-
-# Changes in [18.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.1.0) (2022-06-07)
+ * Send call version `1` as a string ([\#2471](https://github.com/matrix-org/matrix-js-sdk/pull/2471)). Fixes vector-im/element-web#22629.
+ * Fix issue with `getEventTimeline` returning undefined for thread roots in main timeline ([\#2454](https://github.com/matrix-org/matrix-js-sdk/pull/2454)). Fixes vector-im/element-web#22539.
+ * Add missing `type` property on `IAuthData` ([\#2463](https://github.com/matrix-org/matrix-js-sdk/pull/2463)).
+ * Clearly indicate that `lastReply` on a Thread can return falsy ([\#2462](https://github.com/matrix-org/matrix-js-sdk/pull/2462)).
+ * Fix issues with getEventTimeline and thread roots ([\#2444](https://github.com/matrix-org/matrix-js-sdk/pull/2444)). Fixes vector-im/element-web#21613.
+ * Live location sharing - monitor liveness of beacons yet to start ([\#2437](https://github.com/matrix-org/matrix-js-sdk/pull/2437)). Contributed by @kerryarchibald.
+ * Refactor Relations to not be per-EventTimelineSet ([\#2412](https://github.com/matrix-org/matrix-js-sdk/pull/2412)). Fixes #2399 and vector-im/element-web#22298.
+ * Add tests for sendEvent threadId handling ([\#2435](https://github.com/matrix-org/matrix-js-sdk/pull/2435)). Fixes vector-im/element-web#22433.
+ * Make sure `encryptAndSendKeysToDevices` assumes devices are unique per-user. ([\#2136](https://github.com/matrix-org/matrix-js-sdk/pull/2136)). Fixes #2135. Contributed by @ShadowJonathan.
+ * Don't bug the user while re-checking key backups after decryption failures ([\#2430](https://github.com/matrix-org/matrix-js-sdk/pull/2430)). Fixes vector-im/element-web#22416. Contributed by @duxovni.
+
+Changes in [18.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.1.0) (2022-06-07)
+==================================================================================================
 
 ## ✨ Features
-
--   Convert `getLocalAliases` to a stable API call ([\#2402](https://github.com/matrix-org/matrix-js-sdk/pull/2402)).
+ * Convert `getLocalAliases` to a stable API call ([\#2402](https://github.com/matrix-org/matrix-js-sdk/pull/2402)).
 
 ## 🐛 Bug Fixes
-
--   Fix request, crypto, and bs58 imports ([\#2414](https://github.com/matrix-org/matrix-js-sdk/pull/2414)). Fixes #2415.
--   Update relations after every decryption attempt ([\#2387](https://github.com/matrix-org/matrix-js-sdk/pull/2387)). Fixes vector-im/element-web#22258. Contributed by @weeman1337.
--   Fix degraded mode for the IDBStore and test it ([\#2400](https://github.com/matrix-org/matrix-js-sdk/pull/2400)). Fixes matrix-org/element-web-rageshakes#13170.
--   Don't cancel SAS verifications if `ready` is received after `start` ([\#2250](https://github.com/matrix-org/matrix-js-sdk/pull/2250)).
--   Prevent overlapping sync accumulator persists ([\#2392](https://github.com/matrix-org/matrix-js-sdk/pull/2392)). Fixes vector-im/element-web#21541.
--   Fix behaviour of isRelation with relation m.replace for state events ([\#2389](https://github.com/matrix-org/matrix-js-sdk/pull/2389)). Fixes vector-im/element-web#22280.
--   Fixes #2384 ([\#2385](https://github.com/matrix-org/matrix-js-sdk/pull/2385)). Fixes undefined/matrix-js-sdk#2384. Contributed by @schmop.
--   Ensure rooms are recalculated on re-invites ([\#2374](https://github.com/matrix-org/matrix-js-sdk/pull/2374)). Fixes vector-im/element-web#22106.
-
-# Changes in [18.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.0.0) (2022-05-24)
+ * Fix request, crypto, and bs58 imports ([\#2414](https://github.com/matrix-org/matrix-js-sdk/pull/2414)). Fixes #2415.
+ * Update relations after every decryption attempt ([\#2387](https://github.com/matrix-org/matrix-js-sdk/pull/2387)). Fixes vector-im/element-web#22258. Contributed by @weeman1337.
+ * Fix degraded mode for the IDBStore and test it ([\#2400](https://github.com/matrix-org/matrix-js-sdk/pull/2400)). Fixes matrix-org/element-web-rageshakes#13170.
+ * Don't cancel SAS verifications if `ready` is received after `start` ([\#2250](https://github.com/matrix-org/matrix-js-sdk/pull/2250)).
+ * Prevent overlapping sync accumulator persists ([\#2392](https://github.com/matrix-org/matrix-js-sdk/pull/2392)). Fixes vector-im/element-web#21541.
+ * Fix behaviour of isRelation with relation m.replace for state events ([\#2389](https://github.com/matrix-org/matrix-js-sdk/pull/2389)). Fixes vector-im/element-web#22280.
+ * Fixes #2384 ([\#2385](https://github.com/matrix-org/matrix-js-sdk/pull/2385)). Fixes undefined/matrix-js-sdk#2384. Contributed by @schmop.
+ * Ensure rooms are recalculated on re-invites ([\#2374](https://github.com/matrix-org/matrix-js-sdk/pull/2374)). Fixes vector-im/element-web#22106.
+
+Changes in [18.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v18.0.0) (2022-05-24)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES (to experimental methods)
-
--   Implement changes to MSC2285 (private read receipts) ([\#2221](https://github.com/matrix-org/matrix-js-sdk/pull/2221)).
+ * Implement changes to MSC2285 (private read receipts) ([\#2221](https://github.com/matrix-org/matrix-js-sdk/pull/2221)).
 
 ## ✨ Features
-
--   Add support for HTML renderings of room topics ([\#2272](https://github.com/matrix-org/matrix-js-sdk/pull/2272)).
--   Add stopClient parameter to MatrixClient::logout ([\#2367](https://github.com/matrix-org/matrix-js-sdk/pull/2367)).
--   registration: add function to re-request email token ([\#2357](https://github.com/matrix-org/matrix-js-sdk/pull/2357)).
--   Remove hacky custom status feature ([\#2350](https://github.com/matrix-org/matrix-js-sdk/pull/2350)).
+ * Add support for HTML renderings of room topics ([\#2272](https://github.com/matrix-org/matrix-js-sdk/pull/2272)).
+ * Add stopClient parameter to MatrixClient::logout ([\#2367](https://github.com/matrix-org/matrix-js-sdk/pull/2367)).
+ * registration: add function to re-request email token ([\#2357](https://github.com/matrix-org/matrix-js-sdk/pull/2357)).
+ * Remove hacky custom status feature ([\#2350](https://github.com/matrix-org/matrix-js-sdk/pull/2350)).
 
 ## 🐛 Bug Fixes
+ * Remove default push rule override for MSC1930 ([\#2376](https://github.com/matrix-org/matrix-js-sdk/pull/2376)). Fixes vector-im/element-web#15439.
+ * Tweak thread creation & event adding to fix bugs around relations ([\#2369](https://github.com/matrix-org/matrix-js-sdk/pull/2369)). Fixes vector-im/element-web#22162 and vector-im/element-web#22180.
+ * Prune both clear & wire content on redaction ([\#2346](https://github.com/matrix-org/matrix-js-sdk/pull/2346)). Fixes vector-im/element-web#21929.
+ * MSC3786: Add a default push rule to ignore `m.room.server_acl` events ([\#2333](https://github.com/matrix-org/matrix-js-sdk/pull/2333)). Fixes vector-im/element-web#20788.
 
--   Remove default push rule override for MSC1930 ([\#2376](https://github.com/matrix-org/matrix-js-sdk/pull/2376)). Fixes vector-im/element-web#15439.
--   Tweak thread creation & event adding to fix bugs around relations ([\#2369](https://github.com/matrix-org/matrix-js-sdk/pull/2369)). Fixes vector-im/element-web#22162 and vector-im/element-web#22180.
--   Prune both clear & wire content on redaction ([\#2346](https://github.com/matrix-org/matrix-js-sdk/pull/2346)). Fixes vector-im/element-web#21929.
--   MSC3786: Add a default push rule to ignore `m.room.server_acl` events ([\#2333](https://github.com/matrix-org/matrix-js-sdk/pull/2333)). Fixes vector-im/element-web#20788.
-
-# Changes in [17.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.2.0) (2022-05-10)
+Changes in [17.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.2.0) (2022-05-10)
+==================================================================================================
 
 ## ✨ Features
-
--   Live location sharing: handle encrypted messages in processBeaconEvents ([\#2327](https://github.com/matrix-org/matrix-js-sdk/pull/2327)).
+ * Live location sharing: handle encrypted messages in processBeaconEvents ([\#2327](https://github.com/matrix-org/matrix-js-sdk/pull/2327)).
 
 ## 🐛 Bug Fixes
+ * Fix race conditions around threads ([\#2331](https://github.com/matrix-org/matrix-js-sdk/pull/2331)). Fixes vector-im/element-web#21627.
+ * Ignore m.replace relations on state events, they're invalid ([\#2306](https://github.com/matrix-org/matrix-js-sdk/pull/2306)). Fixes vector-im/element-web#21851.
+ * fix example in readme ([\#2315](https://github.com/matrix-org/matrix-js-sdk/pull/2315)).
+ * Don't decrement the length count of a thread when root redacted ([\#2314](https://github.com/matrix-org/matrix-js-sdk/pull/2314)).
+ * Prevent attempt to create thread with id "undefined" ([\#2308](https://github.com/matrix-org/matrix-js-sdk/pull/2308)).
+ * Update threads handling for replies-to-thread-responses as per MSC update ([\#2305](https://github.com/matrix-org/matrix-js-sdk/pull/2305)). Fixes vector-im/element-web#19678.
 
--   Fix race conditions around threads ([\#2331](https://github.com/matrix-org/matrix-js-sdk/pull/2331)). Fixes vector-im/element-web#21627.
--   Ignore m.replace relations on state events, they're invalid ([\#2306](https://github.com/matrix-org/matrix-js-sdk/pull/2306)). Fixes vector-im/element-web#21851.
--   fix example in readme ([\#2315](https://github.com/matrix-org/matrix-js-sdk/pull/2315)).
--   Don't decrement the length count of a thread when root redacted ([\#2314](https://github.com/matrix-org/matrix-js-sdk/pull/2314)).
--   Prevent attempt to create thread with id "undefined" ([\#2308](https://github.com/matrix-org/matrix-js-sdk/pull/2308)).
--   Update threads handling for replies-to-thread-responses as per MSC update ([\#2305](https://github.com/matrix-org/matrix-js-sdk/pull/2305)). Fixes vector-im/element-web#19678.
-
-# Changes in [17.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.1.0) (2022-04-26)
+Changes in [17.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.1.0) (2022-04-26)
+==================================================================================================
 
 ## ✨ Features
-
--   Add MatrixClient.doesServerSupportLogoutDevices() for MSC2457 ([\#2297](https://github.com/matrix-org/matrix-js-sdk/pull/2297)).
--   Live location sharing - expose room liveBeaconIds ([\#2296](https://github.com/matrix-org/matrix-js-sdk/pull/2296)).
--   Support for MSC2457 logout_devices param for setPassword() ([\#2285](https://github.com/matrix-org/matrix-js-sdk/pull/2285)).
--   Stabilise token authenticated registration support ([\#2181](https://github.com/matrix-org/matrix-js-sdk/pull/2181)). Contributed by @govynnus.
--   Live location sharing - Aggregate beacon locations on beacons ([\#2268](https://github.com/matrix-org/matrix-js-sdk/pull/2268)).
+ * Add MatrixClient.doesServerSupportLogoutDevices() for MSC2457 ([\#2297](https://github.com/matrix-org/matrix-js-sdk/pull/2297)).
+ * Live location sharing - expose room liveBeaconIds ([\#2296](https://github.com/matrix-org/matrix-js-sdk/pull/2296)).
+ * Support for MSC2457 logout_devices param for setPassword() ([\#2285](https://github.com/matrix-org/matrix-js-sdk/pull/2285)).
+ * Stabilise token authenticated registration support ([\#2181](https://github.com/matrix-org/matrix-js-sdk/pull/2181)). Contributed by @govynnus.
+ * Live location sharing - Aggregate beacon locations on beacons ([\#2268](https://github.com/matrix-org/matrix-js-sdk/pull/2268)).
 
 ## 🐛 Bug Fixes
+ * Prevent duplicated re-emitter setups in event-mapper ([\#2293](https://github.com/matrix-org/matrix-js-sdk/pull/2293)).
+ * Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
 
--   Prevent duplicated re-emitter setups in event-mapper ([\#2293](https://github.com/matrix-org/matrix-js-sdk/pull/2293)).
--   Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
-
-# Changes in [17.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0) (2022-04-11)
+Changes in [17.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v17.0.0) (2022-04-11)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
+ * Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
 
 ## ✨ Features
-
--   Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
--   Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
+ * Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
+ * Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
 
 ## 🐛 Bug Fixes
+ * Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
+ * Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
+ * Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
 
--   Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
--   Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
--   Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
-
-# Changes in [16.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.2-rc.1) (2022-04-05)
+Changes in [16.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.2-rc.1) (2022-04-05)
+============================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
+ * Remove groups and groups-related APIs ([\#2234](https://github.com/matrix-org/matrix-js-sdk/pull/2234)).
 
 ## ✨ Features
-
--   Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
--   Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
+ * Add Element video room type ([\#2273](https://github.com/matrix-org/matrix-js-sdk/pull/2273)).
+ * Live location sharing - handle redacted beacons ([\#2269](https://github.com/matrix-org/matrix-js-sdk/pull/2269)).
 
 ## 🐛 Bug Fixes
+ * Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
+ * Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
+ * Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
 
--   Fix getSessionsNeedingBackup() limit support ([\#2270](https://github.com/matrix-org/matrix-js-sdk/pull/2270)). Contributed by @adamvy.
--   Fix issues with /search and /context API handling for threads ([\#2261](https://github.com/matrix-org/matrix-js-sdk/pull/2261)). Fixes vector-im/element-web#21543.
--   Prevent exception 'Unable to set up secret storage' ([\#2260](https://github.com/matrix-org/matrix-js-sdk/pull/2260)).
-
-# Changes in [16.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1) (2022-03-28)
+Changes in [16.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1) (2022-03-28)
+==================================================================================================
 
 ## ✨ Features
-
--   emit aggregate room beacon liveness ([\#2241](https://github.com/matrix-org/matrix-js-sdk/pull/2241)).
--   Live location sharing - create m.beacon_info events ([\#2238](https://github.com/matrix-org/matrix-js-sdk/pull/2238)).
--   Beacon event types from MSC3489 ([\#2230](https://github.com/matrix-org/matrix-js-sdk/pull/2230)).
+ * emit aggregate room beacon liveness ([\#2241](https://github.com/matrix-org/matrix-js-sdk/pull/2241)).
+ * Live location sharing - create m.beacon_info events ([\#2238](https://github.com/matrix-org/matrix-js-sdk/pull/2238)).
+ * Beacon event types from MSC3489 ([\#2230](https://github.com/matrix-org/matrix-js-sdk/pull/2230)).
 
 ## 🐛 Bug Fixes
+ * Fix incorrect usage of unstable variant of `is_falling_back` ([\#2227](https://github.com/matrix-org/matrix-js-sdk/pull/2227)).
 
--   Fix incorrect usage of unstable variant of `is_falling_back` ([\#2227](https://github.com/matrix-org/matrix-js-sdk/pull/2227)).
-
-# Changes in [16.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1-rc.1) (2022-03-22)
+Changes in [16.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.1-rc.1) (2022-03-22)
+============================================================================================================
 
-# Changes in [16.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0) (2022-03-15)
+Changes in [16.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0) (2022-03-15)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
+ * Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
 
 ## ✨ Features
-
--   Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
--   add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
--   Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
--   Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
+ * Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
+ * add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
+ * Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
+ * Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
 
 ## 🐛 Bug Fixes
+ * Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
+ * Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
+ * Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
+ * Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
+ * fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
+ * Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
 
--   Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
--   Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
--   Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
--   Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
--   fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
--   Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
-
-# Changes in [16.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0-rc.1) (2022-03-08)
+Changes in [16.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v16.0.0-rc.1) (2022-03-08)
+============================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
+ * Improve typing around event emitter handlers ([\#2180](https://github.com/matrix-org/matrix-js-sdk/pull/2180)).
 
 ## ✨ Features
-
--   Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
--   add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
--   Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
--   Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
+ * Fix defer not supporting resolving with a Promise<T> ([\#2216](https://github.com/matrix-org/matrix-js-sdk/pull/2216)).
+ * add LocationAssetType enum ([\#2214](https://github.com/matrix-org/matrix-js-sdk/pull/2214)).
+ * Support for mid-call devices changes ([\#2154](https://github.com/matrix-org/matrix-js-sdk/pull/2154)). Contributed by @SimonBrandner.
+ * Add new room state emit RoomStateEvent.Update for lower-frequency hits ([\#2192](https://github.com/matrix-org/matrix-js-sdk/pull/2192)).
 
 ## 🐛 Bug Fixes
+ * Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
+ * Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
+ * Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
+ * Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
+ * fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
+ * Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
 
--   Fix wrong event_id being sent for m.in_reply_to of threads ([\#2213](https://github.com/matrix-org/matrix-js-sdk/pull/2213)).
--   Fix wrongly asserting that PushRule::conditions is non-null ([\#2217](https://github.com/matrix-org/matrix-js-sdk/pull/2217)).
--   Make createThread more resilient when missing rootEvent ([\#2207](https://github.com/matrix-org/matrix-js-sdk/pull/2207)). Fixes vector-im/element-web#21130.
--   Fix bug with the /hierarchy API sending invalid requests ([\#2201](https://github.com/matrix-org/matrix-js-sdk/pull/2201)). Fixes vector-im/element-web#21170.
--   fix relation sender filter ([\#2196](https://github.com/matrix-org/matrix-js-sdk/pull/2196)). Fixes vector-im/element-web#20877.
--   Fix bug with one-way audio after a transfer ([\#2193](https://github.com/matrix-org/matrix-js-sdk/pull/2193)).
-
-# Changes in [15.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0) (2022-02-28)
+Changes in [15.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0) (2022-02-28)
+==================================================================================================
 
 ## ✨ Features
-
--   Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
--   Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
+ * Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
+ * Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
 
 ## 🐛 Bug Fixes
-
--   [Release] Fix bug with the /hierarchy API sending invalid requests ([\#2202](https://github.com/matrix-org/matrix-js-sdk/pull/2202)).
--   Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
--   Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
--   Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
--   Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
--   Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
--   Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
--   Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
--   Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
-
-# Changes in [15.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0-rc.1) (2022-02-22)
+ * [Release] Fix bug with the /hierarchy API sending invalid requests ([\#2202](https://github.com/matrix-org/matrix-js-sdk/pull/2202)).
+ * Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
+ * Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
+ * Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
+ * Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
+ * Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
+ * Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
+ * Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
+ * Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
+
+Changes in [15.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.6.0-rc.1) (2022-02-22)
+============================================================================================================
 
 ## ✨ Features
-
--   Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
--   Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
+ * Return send event response from MSC3089Branch.createNewVersion() ([\#2186](https://github.com/matrix-org/matrix-js-sdk/pull/2186)).
+ * Add functions to support refresh tokens ([\#2178](https://github.com/matrix-org/matrix-js-sdk/pull/2178)).
 
 ## 🐛 Bug Fixes
-
--   Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
--   Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
--   Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
--   Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
--   Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
--   Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
--   Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
--   Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
-
-# Changes in [15.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.2) (2022-02-17)
+ * Fix bug where calls could break if rejected from somewhere else ([\#2189](https://github.com/matrix-org/matrix-js-sdk/pull/2189)).
+ * Fix camera stuck on after call transfer ([\#2188](https://github.com/matrix-org/matrix-js-sdk/pull/2188)).
+ * Fix synthetic read receipt handling ([\#2174](https://github.com/matrix-org/matrix-js-sdk/pull/2174)). Fixes vector-im/element-web#21016.
+ * Revert "Sign backup with cross-signing key when we reset it." ([\#2175](https://github.com/matrix-org/matrix-js-sdk/pull/2175)).
+ * Sign backup with cross-signing key when we reset it. ([\#2170](https://github.com/matrix-org/matrix-js-sdk/pull/2170)).
+ * Fix error in uploadContent() when file is empty under Node.js ([\#2155](https://github.com/matrix-org/matrix-js-sdk/pull/2155)).
+ * Check the backup info against the stored private key when determining trust. ([\#2167](https://github.com/matrix-org/matrix-js-sdk/pull/2167)).
+ * Back up keys before logging out ([\#2158](https://github.com/matrix-org/matrix-js-sdk/pull/2158)). Fixes vector-im/element-web#13151.
+
+Changes in [15.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.2) (2022-02-17)
+==================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix synthetic read receipt handling
 
--   Fix synthetic read receipt handling
-
-# Changes in [15.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1) (2022-02-14)
+Changes in [15.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1) (2022-02-14)
+==================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
+ * Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
+ * Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
+ * Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
+ * Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
+ * Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
+ * Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
 
--   Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
--   Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
--   Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
--   Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
--   Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
--   Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
--   Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
-
-# Changes in [15.5.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1-rc.1) (2022-02-08)
+Changes in [15.5.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.1-rc.1) (2022-02-08)
+============================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
+ * Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
+ * Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
+ * Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
+ * Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
+ * Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
+ * Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
 
--   Fix issue with rooms not getting marked as unread ([\#2163](https://github.com/matrix-org/matrix-js-sdk/pull/2163)). Fixes vector-im/element-web#20971.
--   Don't store streams that are only used once ([\#2157](https://github.com/matrix-org/matrix-js-sdk/pull/2157)). Fixes vector-im/element-web#20932. Contributed by @SimonBrandner.
--   Fix edge cases around RR calculations ([\#2160](https://github.com/matrix-org/matrix-js-sdk/pull/2160)). Fixes vector-im/element-web#20922.
--   Account for encryption in `maySendMessage()` ([\#2159](https://github.com/matrix-org/matrix-js-sdk/pull/2159)). Contributed by @SimonBrandner.
--   Send references to thread root to threads, even out of order ([\#2156](https://github.com/matrix-org/matrix-js-sdk/pull/2156)).
--   Fix initial sync fail when event fetching unsuccessful ([\#2150](https://github.com/matrix-org/matrix-js-sdk/pull/2150)). Fixes vector-im/element-web#20862.
--   Don't decrypt redacted messages ([\#2143](https://github.com/matrix-org/matrix-js-sdk/pull/2143)). Contributed by @SimonBrandner.
-
-# Changes in [15.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0) (2022-01-31)
+Changes in [15.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0) (2022-01-31)
+==================================================================================================
 
 ## ✨ Features
-
--   Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
--   Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
--   Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
+ * Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
+ * Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
+ * Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
 
 ## 🐛 Bug Fixes
+ * Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
+ * Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
 
--   Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
--   Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
-
-# Changes in [15.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0-rc.1) (2022-01-26)
+Changes in [15.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.5.0-rc.1) (2022-01-26)
+============================================================================================================
 
 ## ✨ Features
-
--   Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
--   Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
--   Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
+ * Support m.asset in m.location event content ([\#2109](https://github.com/matrix-org/matrix-js-sdk/pull/2109)).
+ * Send extensible events structure and support on-demand parsing ([\#2091](https://github.com/matrix-org/matrix-js-sdk/pull/2091)).
+ * Support cancelling events whilst they are in status = ENCRYPTING ([\#2095](https://github.com/matrix-org/matrix-js-sdk/pull/2095)).
 
 ## 🐛 Bug Fixes
+ * Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
+ * Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
 
--   Fix http-api butchering idServer requests ([\#2134](https://github.com/matrix-org/matrix-js-sdk/pull/2134)). Fixes vector-im/element-web#20680.
--   Don't remove streams that still have tracks ([\#2104](https://github.com/matrix-org/matrix-js-sdk/pull/2104)).
-
-# Changes in [15.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0) (2022-01-17)
+Changes in [15.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0) (2022-01-17)
+==================================================================================================
 
 ## ✨ Features
-
--   Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
--   Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
--   Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
+ * Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
+ * Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
+ * Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
 
 ## 🐛 Bug Fixes
+ * Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
+ * Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
+ * Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
+ * Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
+ * Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
 
--   Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
--   Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
--   Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
--   Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
--   Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
-
-# Changes in [15.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0-rc.1) (2022-01-11)
+Changes in [15.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.4.0-rc.1) (2022-01-11)
+============================================================================================================
 
 ## ✨ Features
-
--   Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
--   Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
--   Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
+ * Don't consider alt_aliases when calculating room name ([\#2094](https://github.com/matrix-org/matrix-js-sdk/pull/2094)). Fixes vector-im/element-web#13887.
+ * Load room history if necessary when searching for MSC3089 getFileEvent() ([\#2066](https://github.com/matrix-org/matrix-js-sdk/pull/2066)).
+ * Add support for MSC3030 `/timestamp_to_event` ([\#2072](https://github.com/matrix-org/matrix-js-sdk/pull/2072)).
 
 ## 🐛 Bug Fixes
+ * Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
+ * Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
+ * Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
+ * Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
+ * Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
 
--   Stop encrypting redactions as it isn't spec compliant ([\#2098](https://github.com/matrix-org/matrix-js-sdk/pull/2098)). Fixes vector-im/element-web#20460.
--   Fix more function typings relating to key backup ([\#2086](https://github.com/matrix-org/matrix-js-sdk/pull/2086)).
--   Fix timeline search in MSC3089 getFileEvent() ([\#2085](https://github.com/matrix-org/matrix-js-sdk/pull/2085)).
--   Set a `deviceId` for VoIP example and use `const`/`let` ([\#2090](https://github.com/matrix-org/matrix-js-sdk/pull/2090)). Fixes #2083. Contributed by @SimonBrandner.
--   Fix incorrect TS return type for secret storage and key backup functions ([\#2082](https://github.com/matrix-org/matrix-js-sdk/pull/2082)).
-
-# Changes in [15.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0) (2021-12-20)
+Changes in [15.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0) (2021-12-20)
+==================================================================================================
 
 ## ✨ Features
-
--   Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
--   Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
--   Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
+ * Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
+ * Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
+ * Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
 
 ## 🐛 Bug Fixes
+ * Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
+ * Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
+ * Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
 
--   Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
--   Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
--   Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
-
-# Changes in [15.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0-rc.1) (2021-12-14)
+Changes in [15.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.3.0-rc.1) (2021-12-14)
+============================================================================================================
 
 ## ✨ Features
-
--   Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
--   Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
--   Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
+ * Improve fallback key behaviour ([\#2037](https://github.com/matrix-org/matrix-js-sdk/pull/2037)).
+ * Add new room event filter fields ([\#2051](https://github.com/matrix-org/matrix-js-sdk/pull/2051)).
+ * Add method to fetch /account/whoami ([\#2046](https://github.com/matrix-org/matrix-js-sdk/pull/2046)).
 
 ## 🐛 Bug Fixes
+ * Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
+ * Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
+ * Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
 
--   Filter out falsey opts in /relations API hits ([\#2059](https://github.com/matrix-org/matrix-js-sdk/pull/2059)). Fixes vector-im/element-web#20137.
--   Fix paginateEventTimeline resolve to boolean ([\#2054](https://github.com/matrix-org/matrix-js-sdk/pull/2054)).
--   Fix incorrect MSC3089 typings and add null checks ([\#2049](https://github.com/matrix-org/matrix-js-sdk/pull/2049)).
-
-# Changes in [15.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.1) (2021-12-13)
+Changes in [15.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.1) (2021-12-13)
+==================================================================================================
 
--   Security release with updated version of Olm to fix https://matrix.org/blog/2021/12/03/pre-disclosure-upcoming-security-release-of-libolm-and-matrix-js-sdk
+ * Security release with updated version of Olm to fix https://matrix.org/blog/2021/12/03/pre-disclosure-upcoming-security-release-of-libolm-and-matrix-js-sdk
 
-# Changes in [15.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0) (2021-12-06)
+Changes in [15.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0) (2021-12-06)
+==================================================================================================
 
 ## ✨ Features
-
--   Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
--   Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
--   Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
+ * Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
+ * Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
+ * Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
 
 ## 🐛 Bug Fixes
+ * Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
 
--   Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
-
-# Changes in [15.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0-rc.1) (2021-11-30)
+Changes in [15.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.2.0-rc.1) (2021-11-30)
+============================================================================================================
 
 ## ✨ Features
-
--   Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
--   Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
--   Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
+ * Remove support for `ArrayBuffer` in unstable MSC3089 `createFile()` and `createNewVersion()` and instead use same content types as handled by `MatrixClient.uploadContent()`. This enables support for Node.js. ([\#2014](https://github.com/matrix-org/matrix-js-sdk/pull/2014)).
+ * Support for password-based backup on Node.js ([\#2021](https://github.com/matrix-org/matrix-js-sdk/pull/2021)).
+ * Add optional force parameter when ensuring Olm sessions ([\#2027](https://github.com/matrix-org/matrix-js-sdk/pull/2027)).
 
 ## 🐛 Bug Fixes
+ * Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
 
--   Fix call upgrades ([\#2024](https://github.com/matrix-org/matrix-js-sdk/pull/2024)). Contributed by @SimonBrandner.
-
-# Changes in [15.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1) (2021-11-22)
+Changes in [15.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1) (2021-11-22)
+==================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
+ * Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
 
--   Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
--   Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
-
-# Changes in [15.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1-rc.1) (2021-11-17)
+Changes in [15.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.1-rc.1) (2021-11-17)
+============================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
+ * Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
 
--   Fix edit history being broken after editing an unencrypted event with an encrypted event ([\#2013](https://github.com/matrix-org/matrix-js-sdk/pull/2013)). Fixes vector-im/element-web#19651 and vector-im/element-web#19651. Contributed by @aaronraimist.
--   Make events pagination responses parse threads ([\#2011](https://github.com/matrix-org/matrix-js-sdk/pull/2011)). Fixes vector-im/element-web#19587 and vector-im/element-web#19587.
-
-# Changes in [15.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0) (2021-11-08)
+Changes in [15.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0) (2021-11-08)
+==================================================================================================
 
 ## 🦖 Deprecations
-
--   Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
+ * Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
 
 ## ✨ Features
-
--   Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
--   Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
--   Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
--   Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
+ * Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
+ * Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
+ * Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
+ * Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
 
 ## 🐛 Bug Fixes
+ * Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
+ * Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
 
--   Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
--   Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
-
-# Changes in [15.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0-rc.1) (2021-11-02)
+Changes in [15.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v15.1.0-rc.1) (2021-11-02)
+============================================================================================================
 
 ## 🦖 Deprecations
-
--   Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
+ * Mark old verification methods as deprecated ([\#1994](https://github.com/matrix-org/matrix-js-sdk/pull/1994)).
 
 ## ✨ Features
-
--   Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
--   Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
--   Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
--   Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
+ * Try to set a sender on search result events if possible ([\#2004](https://github.com/matrix-org/matrix-js-sdk/pull/2004)).
+ * Port some changes from group calls branch to develop ([\#2001](https://github.com/matrix-org/matrix-js-sdk/pull/2001)). Contributed by @SimonBrandner.
+ * Fetch room membership from server rather than relying on stored data ([\#1998](https://github.com/matrix-org/matrix-js-sdk/pull/1998)).
+ * Add method to fetch the MSC3266 Room Summary of a Room ([\#1988](https://github.com/matrix-org/matrix-js-sdk/pull/1988)).
 
 ## 🐛 Bug Fixes
+ * Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
+ * Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
 
--   Don't show `Unable to access microphone` when cancelling screensharing dialog ([\#2005](https://github.com/matrix-org/matrix-js-sdk/pull/2005)). Fixes vector-im/element-web#19533 and vector-im/element-web#19533. Contributed by @SimonBrandner.
--   Strip direction override characters from display names ([\#1992](https://github.com/matrix-org/matrix-js-sdk/pull/1992)). Fixes vector-im/element-web#1712 and vector-im/element-web#1712.
-
-# Changes in [15.0.0](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0) (2021-10-25)
+Changes in [15.0.0](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0) (2021-10-25)
+===================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
-
--   Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
--   Try to answer a call without video if we can't access the camera ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
+ * Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
+ * Try to answer a call without video if we can't access the camera  ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
 
 ## 🐛 Bug Fixes
+ * Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
 
--   Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
-
-# Changes in [15.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0-rc.1) (2021-10-19)
+Changes in [15.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v15.0.0-rc.1) (2021-10-19)
+=============================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Use `ICallFeedOpts` in the `CallFeed` constructor. To construct a new `CallFeed` object you have to pass `ICallFeedOpts` e.g. `const callFeed = new CallFeed({client ([\#1964](https://github.com/matrix-org/matrix-js-sdk/pull/1964)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
-
--   Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
--   Try to answer a call without video if we can't access the camera ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
+ * Make threads use 'm.thread' relation ([\#1980](https://github.com/matrix-org/matrix-js-sdk/pull/1980)).
+ * Try to answer a call without video if we can't access the camera  ([\#1972](https://github.com/matrix-org/matrix-js-sdk/pull/1972)). Fixes vector-im/element-web#17975 and vector-im/element-web#17975. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Make `opts` in `importRoomKeys()` optional ([\#1974](https://github.com/matrix-org/matrix-js-sdk/pull/1974)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Enable TypeScript declaration maps ([\#1966](https://github.com/matrix-org/matrix-js-sdk/pull/1966)). Contributed by [Alexendoo](https://github.com/Alexendoo).
 
 ## 🐛 Bug Fixes
+ * Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
 
--   Fix `requestVerificationDM` with chronological `pendingEventOrdering` ([\#1943](https://github.com/matrix-org/matrix-js-sdk/pull/1943)). Contributed by [freaktechnik](https://github.com/freaktechnik).
-
-# Changes in [14.0.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.1) (2021-10-12)
+Changes in [14.0.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.1) (2021-10-12)
+===================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
-
--   Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
--   Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
+ * Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
+ * Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
+ * Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
 
--   Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
--   Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
--   Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
 
-# Changes in [14.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.0-rc.1) (2021-10-04)
+Changes in [14.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v14.0.0-rc.1) (2021-10-04)
+=============================================================================================================
 
 ## 🚨 BREAKING CHANGES
-
--   Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Support for call upgrades. `setLocalVideoMuted()` and `setMicrophoneMuted()` are now `async` and return the new mute state ([\#1827](https://github.com/matrix-org/matrix-js-sdk/pull/1827)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## ✨ Features
-
--   Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
--   Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Implement file versioning for tree spaces ([\#1952](https://github.com/matrix-org/matrix-js-sdk/pull/1952)).
+ * Allow answering calls without audio/video ([\#1950](https://github.com/matrix-org/matrix-js-sdk/pull/1950)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `bound` to `IThreepid` ([\#1941](https://github.com/matrix-org/matrix-js-sdk/pull/1941)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `trusted_locally` to `TrustInfo` ([\#1942](https://github.com/matrix-org/matrix-js-sdk/pull/1942)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
+ * Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
+ * Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
 
--   Fix incorrect return value type in getJoinedRooms() ([\#1959](https://github.com/matrix-org/matrix-js-sdk/pull/1959)). Contributed by [psrpinto](https://github.com/psrpinto).
--   Make sure to set `callLengthInterval` only once ([\#1958](https://github.com/matrix-org/matrix-js-sdk/pull/1958)). Fixes vector-im/element-web#19221 and vector-im/element-web#19221. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Fix event partitioning from non threading ready clients ([\#1948](https://github.com/matrix-org/matrix-js-sdk/pull/1948)).
--   Ensure unencrypted fields get exposed by getEffectiveEvent() ([\#1938](https://github.com/matrix-org/matrix-js-sdk/pull/1938)). Fixes vector-im/element-web#19062 and vector-im/element-web#19062.
-
-# Changes in [13.0.0](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0) (2021-09-27)
+Changes in [13.0.0](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0) (2021-09-27)
+===================================================================================================
 
 ## ✨ Features
-
--   Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
--   Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
--   Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
+ * Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
+ * Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
+ * Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
 
 ## 🐛 Bug Fixes
+ * Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
 
--   Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
-
-# Changes in [13.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0-rc.1) (2021-09-21)
+Changes in [13.0.0-rc.1](https://github.com/vector-im/element-desktop/releases/tag/v13.0.0-rc.1) (2021-09-21)
+=============================================================================================================
 
 ## ✨ Features
-
--   Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
--   Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
--   Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
+ * Add `getHistoryVisibility()` and `getGuestAccess()` ([\#1940](https://github.com/matrix-org/matrix-js-sdk/pull/1940)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `getBuffer()` to `QRCodeData` ([\#1927](https://github.com/matrix-org/matrix-js-sdk/pull/1927)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Added `createDataChannel()` and `CallEvent.DataChannel` to `MatrixCall` for creating and listening for WebRTC datachannels. ([\#1929](https://github.com/matrix-org/matrix-js-sdk/pull/1929)). Contributed by [robertlong](https://github.com/robertlong).
+ * Add file locking to MSC3089 branches ([\#1909](https://github.com/matrix-org/matrix-js-sdk/pull/1909)).
+ * Add `hasBeenCancelled` to `VerificationBase` ([\#1915](https://github.com/matrix-org/matrix-js-sdk/pull/1915)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Add `ISasEvent` ([\#1908](https://github.com/matrix-org/matrix-js-sdk/pull/1908)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Count notifications in encrypted rooms client-side ([\#1872](https://github.com/matrix-org/matrix-js-sdk/pull/1872)). Fixes vector-im/element-web#15393 and vector-im/element-web#15393. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Exclude opt-in Element performance metrics from encryption ([\#1897](https://github.com/matrix-org/matrix-js-sdk/pull/1897)).
 
 ## 🐛 Bug Fixes
+ * Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
 
--   Fix race on automatic backup restore ([\#1936](https://github.com/matrix-org/matrix-js-sdk/pull/1936)). Fixes vector-im/element-web#17781 and vector-im/element-web#17781.
-
-# Changes in [12.5.0](https://github.com/vector-im/element-desktop/releases/tag/v12.5.0) (2021-09-14)
+Changes in [12.5.0](https://github.com/vector-im/element-desktop/releases/tag/v12.5.0) (2021-09-14)
+===================================================================================================
 
 ## ✨ Features
-
--   [Release] Exclude opt-in Element performance metrics from encryption ([\#1901](https://github.com/matrix-org/matrix-js-sdk/pull/1901)).
--   Give `MatrixCall` the capability to emit `LengthChanged` events ([\#1873](https://github.com/matrix-org/matrix-js-sdk/pull/1873)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Improve browser example ([\#1875](https://github.com/matrix-org/matrix-js-sdk/pull/1875)). Contributed by [psrpinto](https://github.com/psrpinto).
--   Give `CallFeed` the capability to emit on volume changes ([\#1865](https://github.com/matrix-org/matrix-js-sdk/pull/1865)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * [Release] Exclude opt-in Element performance metrics from encryption ([\#1901](https://github.com/matrix-org/matrix-js-sdk/pull/1901)).
+ * Give `MatrixCall` the capability to emit `LengthChanged` events ([\#1873](https://github.com/matrix-org/matrix-js-sdk/pull/1873)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Improve browser example ([\#1875](https://github.com/matrix-org/matrix-js-sdk/pull/1875)). Contributed by [psrpinto](https://github.com/psrpinto).
+ * Give `CallFeed` the capability to emit on volume changes ([\#1865](https://github.com/matrix-org/matrix-js-sdk/pull/1865)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
+ * Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).
 
--   Fix verification request cancellation ([\#1871](https://github.com/matrix-org/matrix-js-sdk/pull/1871)).
-
-# Changes in [12.4.1](https://github.com/vector-im/element-desktop/releases/tag/v12.4.1) (2021-09-13)
+Changes in [12.4.1](https://github.com/vector-im/element-desktop/releases/tag/v12.4.1) (2021-09-13)
+===================================================================================================
 
 ## 🔒 SECURITY FIXES
+ * Fix a security issue with message key sharing. See https://matrix.org/blog/2021/09/13/vulnerability-disclosure-key-sharing
+   for details.
 
--   Fix a security issue with message key sharing. See https://matrix.org/blog/2021/09/13/vulnerability-disclosure-key-sharing
-    for details.
-
-# Changes in [12.4.0](https://github.com/vector-im/element-desktop/releases/tag/v12.4.0) (2021-08-31)
+Changes in [12.4.0](https://github.com/vector-im/element-desktop/releases/tag/v12.4.0) (2021-08-31)
+===================================================================================================
 
 ## 🦖 Deprecations
-
--   Deprecate groups APIs. Groups are no longer supported, only Synapse has support. They are being replaced by Spaces which build off of Rooms and are far more flexible. ([\#1792](https://github.com/matrix-org/matrix-js-sdk/pull/1792)).
+ * Deprecate groups APIs. Groups are no longer supported, only Synapse has support. They are being replaced by Spaces which build off of Rooms and are far more flexible. ([\#1792](https://github.com/matrix-org/matrix-js-sdk/pull/1792)).
 
 ## ✨ Features
-
--   Add method for including extra fields when uploading to a tree space ([\#1850](https://github.com/matrix-org/matrix-js-sdk/pull/1850)).
+ * Add method for including extra fields when uploading to a tree space ([\#1850](https://github.com/matrix-org/matrix-js-sdk/pull/1850)).
 
 ## 🐛 Bug Fixes
+ * Fix broken voice calls, no ringing and broken call notifications ([\#1858](https://github.com/matrix-org/matrix-js-sdk/pull/1858)). Fixes vector-im/element-web#18578 vector-im/element-web#18538 and vector-im/element-web#18578. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Revert "Fix glare related regressions" ([\#1857](https://github.com/matrix-org/matrix-js-sdk/pull/1857)).
+ * Fix glare related regressions ([\#1851](https://github.com/matrix-org/matrix-js-sdk/pull/1851)). Fixes vector-im/element-web#18538 and vector-im/element-web#18538. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix temporary call messages being handled without call  ([\#1834](https://github.com/matrix-org/matrix-js-sdk/pull/1834)). Contributed by [Palid](https://github.com/Palid).
+ * Fix conditional on returning file tree spaces ([\#1841](https://github.com/matrix-org/matrix-js-sdk/pull/1841)).
 
--   Fix broken voice calls, no ringing and broken call notifications ([\#1858](https://github.com/matrix-org/matrix-js-sdk/pull/1858)). Fixes vector-im/element-web#18578 vector-im/element-web#18538 and vector-im/element-web#18578. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Revert "Fix glare related regressions" ([\#1857](https://github.com/matrix-org/matrix-js-sdk/pull/1857)).
--   Fix glare related regressions ([\#1851](https://github.com/matrix-org/matrix-js-sdk/pull/1851)). Fixes vector-im/element-web#18538 and vector-im/element-web#18538. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Fix temporary call messages being handled without call ([\#1834](https://github.com/matrix-org/matrix-js-sdk/pull/1834)). Contributed by [Palid](https://github.com/Palid).
--   Fix conditional on returning file tree spaces ([\#1841](https://github.com/matrix-org/matrix-js-sdk/pull/1841)).
-
-# Changes in [12.3.1](https://github.com/vector-im/element-desktop/releases/tag/v12.3.1) (2021-08-17)
+Changes in [12.3.1](https://github.com/vector-im/element-desktop/releases/tag/v12.3.1) (2021-08-17)
+===================================================================================================
 
 ## 🐛 Bug Fixes
+ * Fix multiple VoIP regressions ([\#1860](https://github.com/matrix-org/matrix-js-sdk/pull/1860)).
 
--   Fix multiple VoIP regressions ([\#1860](https://github.com/matrix-org/matrix-js-sdk/pull/1860)).
-
-# Changes in [12.3.0](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0) (2021-08-16)
+Changes in [12.3.0](https://github.com/vector-im/element-desktop/releases/tag/v12.3.0) (2021-08-16)
+===================================================================================================
 
 ## ✨ Features
-
--   Support for MSC3291: Muting in VoIP calls ([\#1812](https://github.com/matrix-org/matrix-js-sdk/pull/1812)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Support for screen-sharing using multi-stream VoIP (MSC3077) ([\#1685](https://github.com/matrix-org/matrix-js-sdk/pull/1685)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Handle DTMF support ([\#1813](https://github.com/matrix-org/matrix-js-sdk/pull/1813)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Support for MSC3291: Muting in VoIP calls ([\#1812](https://github.com/matrix-org/matrix-js-sdk/pull/1812)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Support for screen-sharing using multi-stream VoIP (MSC3077) ([\#1685](https://github.com/matrix-org/matrix-js-sdk/pull/1685)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Handle DTMF support ([\#1813](https://github.com/matrix-org/matrix-js-sdk/pull/1813)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
 
 ## 🐛 Bug Fixes
-
--   [Release] Fix glare related regressions ([\#1854](https://github.com/matrix-org/matrix-js-sdk/pull/1854)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Fix the types in shipped package ([\#1842](https://github.com/matrix-org/matrix-js-sdk/pull/1842)). Fixes vector-im/element-web#18503 and vector-im/element-web#18503.
--   Fix error on turning off screensharing ([\#1833](https://github.com/matrix-org/matrix-js-sdk/pull/1833)). Fixes vector-im/element-web#18449. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Fix blank profile in join events ([\#1837](https://github.com/matrix-org/matrix-js-sdk/pull/1837)). Fixes vector-im/element-web#18321.
--   fix TURN by fixing regression preventing multiple ICE candidates from sending. ([\#1838](https://github.com/matrix-org/matrix-js-sdk/pull/1838)).
--   Send `user_hangup` reason if the opponent supports it ([\#1820](https://github.com/matrix-org/matrix-js-sdk/pull/1820)). Fixes vector-im/element-web#18219. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
--   Apply hidden char check to rawDisplayName too ([\#1816](https://github.com/matrix-org/matrix-js-sdk/pull/1816)).
--   Only clear bit 63 when we create the IV ([\#1819](https://github.com/matrix-org/matrix-js-sdk/pull/1819)).
-
-# Changes in [12.2.0](https://github.com/vector-im/element-desktop/releases/tag/v12.2.0) (2021-08-02)
+ * [Release] Fix glare related regressions ([\#1854](https://github.com/matrix-org/matrix-js-sdk/pull/1854)). Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix the types in shipped package ([\#1842](https://github.com/matrix-org/matrix-js-sdk/pull/1842)). Fixes vector-im/element-web#18503 and vector-im/element-web#18503.
+ * Fix error on turning off screensharing ([\#1833](https://github.com/matrix-org/matrix-js-sdk/pull/1833)). Fixes vector-im/element-web#18449. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Fix blank profile in join events ([\#1837](https://github.com/matrix-org/matrix-js-sdk/pull/1837)). Fixes vector-im/element-web#18321.
+ * fix TURN by fixing regression preventing multiple ICE candidates from sending. ([\#1838](https://github.com/matrix-org/matrix-js-sdk/pull/1838)).
+ * Send `user_hangup` reason if the opponent supports it ([\#1820](https://github.com/matrix-org/matrix-js-sdk/pull/1820)). Fixes vector-im/element-web#18219. Contributed by [SimonBrandner](https://github.com/SimonBrandner).
+ * Apply hidden char check to rawDisplayName too ([\#1816](https://github.com/matrix-org/matrix-js-sdk/pull/1816)).
+ * Only clear bit 63 when we create the IV ([\#1819](https://github.com/matrix-org/matrix-js-sdk/pull/1819)).
+
+Changes in [12.2.0](https://github.com/vector-im/element-desktop/releases/tag/v12.2.0) (2021-08-02)
+===================================================================================================
 
 ## ✨ Features
-
--   Improve calculateRoomName performances by using Intl.Collator
-    [\#1801](https://github.com/matrix-org/matrix-js-sdk/pull/1801)
--   Switch callEventHandler from listening on `event` to `Room.timeline`
-    [\#1789](https://github.com/matrix-org/matrix-js-sdk/pull/1789)
--   Expose MatrixEvent's internal clearEvent as a function
-    [\#1784](https://github.com/matrix-org/matrix-js-sdk/pull/1784)
+ * Improve calculateRoomName performances by using Intl.Collator
+   [\#1801](https://github.com/matrix-org/matrix-js-sdk/pull/1801)
+ * Switch callEventHandler from listening on `event` to `Room.timeline`
+   [\#1789](https://github.com/matrix-org/matrix-js-sdk/pull/1789)
+ * Expose MatrixEvent's internal clearEvent as a function
+   [\#1784](https://github.com/matrix-org/matrix-js-sdk/pull/1784)
 
 ## 🐛 Bug Fixes
+ * Clean up Event.clearEvent handling to fix a bug where malformed events with falsey content wouldn't be considered decrypted
+   [\#1807](https://github.com/matrix-org/matrix-js-sdk/pull/1807)
+ * Standardise spelling and casing of homeserver, identity server, and integration manager
+   [\#1782](https://github.com/matrix-org/matrix-js-sdk/pull/1782)
 
--   Clean up Event.clearEvent handling to fix a bug where malformed events with falsey content wouldn't be considered decrypted
-    [\#1807](https://github.com/matrix-org/matrix-js-sdk/pull/1807)
--   Standardise spelling and casing of homeserver, identity server, and integration manager
-    [\#1782](https://github.com/matrix-org/matrix-js-sdk/pull/1782)
-
-# Changes in [12.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0) (2021-07-19)
-
+Changes in [12.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0) (2021-07-19)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.1.0-rc.1...v12.1.0)
 
--   No changes from rc.1
-
-# Changes in [12.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0-rc.1) (2021-07-14)
+ * No changes from rc.1
 
+Changes in [12.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.1.0-rc.1) (2021-07-14)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.1...v12.1.0-rc.1)
 
--   Add VS Code to gitignore
-    [\#1783](https://github.com/matrix-org/matrix-js-sdk/pull/1783)
--   Make `Crypto::inRoomVerificationRequests` public
-    [\#1781](https://github.com/matrix-org/matrix-js-sdk/pull/1781)
--   Call `setEventMetadata()` for filtered `timelineSet`s
-    [\#1765](https://github.com/matrix-org/matrix-js-sdk/pull/1765)
--   Symmetric backup
-    [\#1775](https://github.com/matrix-org/matrix-js-sdk/pull/1775)
--   Attempt to fix megolm key not being in SSSS
-    [\#1776](https://github.com/matrix-org/matrix-js-sdk/pull/1776)
--   Convert SecretStorage to TypeScript
-    [\#1774](https://github.com/matrix-org/matrix-js-sdk/pull/1774)
--   Strip hash from urls being previewed to de-duplicate
-    [\#1721](https://github.com/matrix-org/matrix-js-sdk/pull/1721)
--   Do not generate a lockfile when running in CI
-    [\#1773](https://github.com/matrix-org/matrix-js-sdk/pull/1773)
--   Tidy up secret requesting code
-    [\#1766](https://github.com/matrix-org/matrix-js-sdk/pull/1766)
--   Convert Sync and SyncAccumulator to Typescript
-    [\#1763](https://github.com/matrix-org/matrix-js-sdk/pull/1763)
--   Convert EventTimeline, EventTimelineSet and TimelineWindow to TS
-    [\#1762](https://github.com/matrix-org/matrix-js-sdk/pull/1762)
--   Comply with new member-delimiter-style rule
-    [\#1764](https://github.com/matrix-org/matrix-js-sdk/pull/1764)
--   Do not honor string power levels
-    [\#1754](https://github.com/matrix-org/matrix-js-sdk/pull/1754)
--   Typescriptify some crypto stuffs
-    [\#1508](https://github.com/matrix-org/matrix-js-sdk/pull/1508)
--   Make filterId read/write and optional
-    [\#1760](https://github.com/matrix-org/matrix-js-sdk/pull/1760)
-
-# Changes in [12.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1) (2021-07-05)
-
+ * Add VS Code to gitignore
+   [\#1783](https://github.com/matrix-org/matrix-js-sdk/pull/1783)
+ * Make `Crypto::inRoomVerificationRequests` public
+   [\#1781](https://github.com/matrix-org/matrix-js-sdk/pull/1781)
+ * Call `setEventMetadata()` for filtered `timelineSet`s
+   [\#1765](https://github.com/matrix-org/matrix-js-sdk/pull/1765)
+ * Symmetric backup
+   [\#1775](https://github.com/matrix-org/matrix-js-sdk/pull/1775)
+ * Attempt to fix megolm key not being in SSSS
+   [\#1776](https://github.com/matrix-org/matrix-js-sdk/pull/1776)
+ * Convert SecretStorage to TypeScript
+   [\#1774](https://github.com/matrix-org/matrix-js-sdk/pull/1774)
+ * Strip hash from urls being previewed to de-duplicate
+   [\#1721](https://github.com/matrix-org/matrix-js-sdk/pull/1721)
+ * Do not generate a lockfile when running in CI
+   [\#1773](https://github.com/matrix-org/matrix-js-sdk/pull/1773)
+ * Tidy up secret requesting code
+   [\#1766](https://github.com/matrix-org/matrix-js-sdk/pull/1766)
+ * Convert Sync and SyncAccumulator to Typescript
+   [\#1763](https://github.com/matrix-org/matrix-js-sdk/pull/1763)
+ * Convert EventTimeline, EventTimelineSet and TimelineWindow to TS
+   [\#1762](https://github.com/matrix-org/matrix-js-sdk/pull/1762)
+ * Comply with new member-delimiter-style rule
+   [\#1764](https://github.com/matrix-org/matrix-js-sdk/pull/1764)
+ * Do not honor string power levels
+   [\#1754](https://github.com/matrix-org/matrix-js-sdk/pull/1754)
+ * Typescriptify some crypto stuffs
+   [\#1508](https://github.com/matrix-org/matrix-js-sdk/pull/1508)
+ * Make filterId read/write and optional
+   [\#1760](https://github.com/matrix-org/matrix-js-sdk/pull/1760)
+
+Changes in [12.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1) (2021-07-05)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.1-rc.1...v12.0.1)
 
--   No changes from rc.1
-
-# Changes in [12.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1-rc.1) (2021-06-29)
+ * No changes from rc.1
 
+Changes in [12.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.1-rc.1) (2021-06-29)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.0...v12.0.1-rc.1)
 
--   Fix broken /messages filtering due to internal field changes in
-    FilterComponent
-    [\#1759](https://github.com/matrix-org/matrix-js-sdk/pull/1759)
--   Convert crypto index to TS
-    [\#1749](https://github.com/matrix-org/matrix-js-sdk/pull/1749)
--   Fix typescript return types for membership update events
-    [\#1739](https://github.com/matrix-org/matrix-js-sdk/pull/1739)
--   Fix types of MatrixEvent sender & target
-    [\#1753](https://github.com/matrix-org/matrix-js-sdk/pull/1753)
--   Add keysharing on invites to File Tree Spaces
-    [\#1744](https://github.com/matrix-org/matrix-js-sdk/pull/1744)
--   Convert Room and RoomState to Typescript
-    [\#1746](https://github.com/matrix-org/matrix-js-sdk/pull/1746)
--   Improve type of IContent msgtype
-    [\#1752](https://github.com/matrix-org/matrix-js-sdk/pull/1752)
--   Add PR template
-    [\#1747](https://github.com/matrix-org/matrix-js-sdk/pull/1747)
--   Add functions to assist in immutability of Event objects
-    [\#1738](https://github.com/matrix-org/matrix-js-sdk/pull/1738)
--   Convert Event Context to TS
-    [\#1742](https://github.com/matrix-org/matrix-js-sdk/pull/1742)
--   Bump lodash from 4.17.20 to 4.17.21
-    [\#1743](https://github.com/matrix-org/matrix-js-sdk/pull/1743)
--   Add invite retries to file trees
-    [\#1740](https://github.com/matrix-org/matrix-js-sdk/pull/1740)
--   Convert IndexedDBStore to TS
-    [\#1741](https://github.com/matrix-org/matrix-js-sdk/pull/1741)
--   Convert additional files to typescript
-    [\#1736](https://github.com/matrix-org/matrix-js-sdk/pull/1736)
-
-# Changes in [12.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0) (2021-06-21)
-
+ * Fix broken /messages filtering due to internal field changes in
+   FilterComponent
+   [\#1759](https://github.com/matrix-org/matrix-js-sdk/pull/1759)
+ * Convert crypto index to TS
+   [\#1749](https://github.com/matrix-org/matrix-js-sdk/pull/1749)
+ * Fix typescript return types for membership update events
+   [\#1739](https://github.com/matrix-org/matrix-js-sdk/pull/1739)
+ * Fix types of MatrixEvent sender & target
+   [\#1753](https://github.com/matrix-org/matrix-js-sdk/pull/1753)
+ * Add keysharing on invites to File Tree Spaces
+   [\#1744](https://github.com/matrix-org/matrix-js-sdk/pull/1744)
+ * Convert Room and RoomState to Typescript
+   [\#1746](https://github.com/matrix-org/matrix-js-sdk/pull/1746)
+ * Improve type of IContent msgtype
+   [\#1752](https://github.com/matrix-org/matrix-js-sdk/pull/1752)
+ * Add PR template
+   [\#1747](https://github.com/matrix-org/matrix-js-sdk/pull/1747)
+ * Add functions to assist in immutability of Event objects
+   [\#1738](https://github.com/matrix-org/matrix-js-sdk/pull/1738)
+ * Convert Event Context to TS
+   [\#1742](https://github.com/matrix-org/matrix-js-sdk/pull/1742)
+ * Bump lodash from 4.17.20 to 4.17.21
+   [\#1743](https://github.com/matrix-org/matrix-js-sdk/pull/1743)
+ * Add invite retries to file trees
+   [\#1740](https://github.com/matrix-org/matrix-js-sdk/pull/1740)
+ * Convert IndexedDBStore to TS
+   [\#1741](https://github.com/matrix-org/matrix-js-sdk/pull/1741)
+ * Convert additional files to typescript
+   [\#1736](https://github.com/matrix-org/matrix-js-sdk/pull/1736)
+
+Changes in [12.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0) (2021-06-21)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v12.0.0-rc.1...v12.0.0)
 
--   No changes since rc.1
-
-# Changes in [12.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0-rc.1) (2021-06-15)
+ * No changes since rc.1
 
+Changes in [12.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v12.0.0-rc.1) (2021-06-15)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.2.0...v12.0.0-rc.1)
 
--   Rework how disambiguation is handled
-    [\#1730](https://github.com/matrix-org/matrix-js-sdk/pull/1730)
--   Fix baseToString for n=0 edge case to match inverse stringToBase
-    [\#1735](https://github.com/matrix-org/matrix-js-sdk/pull/1735)
--   Move various types from the react-sdk to the js-sdk
-    [\#1734](https://github.com/matrix-org/matrix-js-sdk/pull/1734)
--   Unstable implementation of MSC3089: File Trees
-    [\#1732](https://github.com/matrix-org/matrix-js-sdk/pull/1732)
--   Add MSC3230 event type to enum
-    [\#1729](https://github.com/matrix-org/matrix-js-sdk/pull/1729)
--   Add separate reason code for transferred calls
-    [\#1731](https://github.com/matrix-org/matrix-js-sdk/pull/1731)
--   Use sendonly for call hold
-    [\#1728](https://github.com/matrix-org/matrix-js-sdk/pull/1728)
--   Stop breeding sync listeners
-    [\#1727](https://github.com/matrix-org/matrix-js-sdk/pull/1727)
--   Fix semicolons in TS files
-    [\#1724](https://github.com/matrix-org/matrix-js-sdk/pull/1724)
--   [BREAKING] Convert MatrixClient to TypeScript
-    [\#1718](https://github.com/matrix-org/matrix-js-sdk/pull/1718)
--   Factor out backup management to a separate module
-    [\#1697](https://github.com/matrix-org/matrix-js-sdk/pull/1697)
--   Ignore power_levels events with unknown state_key on room-state
-    initialization
-    [\#1723](https://github.com/matrix-org/matrix-js-sdk/pull/1723)
--   Revert 1579 (Fix extra negotiate message in Firefox)
-    [\#1725](https://github.com/matrix-org/matrix-js-sdk/pull/1725)
-
-# Changes in [11.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0) (2021-06-07)
-
+ * Rework how disambiguation is handled
+   [\#1730](https://github.com/matrix-org/matrix-js-sdk/pull/1730)
+ * Fix baseToString for n=0 edge case to match inverse stringToBase
+   [\#1735](https://github.com/matrix-org/matrix-js-sdk/pull/1735)
+ * Move various types from the react-sdk to the js-sdk
+   [\#1734](https://github.com/matrix-org/matrix-js-sdk/pull/1734)
+ * Unstable implementation of MSC3089: File Trees
+   [\#1732](https://github.com/matrix-org/matrix-js-sdk/pull/1732)
+ * Add MSC3230 event type to enum
+   [\#1729](https://github.com/matrix-org/matrix-js-sdk/pull/1729)
+ * Add separate reason code for transferred calls
+   [\#1731](https://github.com/matrix-org/matrix-js-sdk/pull/1731)
+ * Use sendonly for call hold
+   [\#1728](https://github.com/matrix-org/matrix-js-sdk/pull/1728)
+ * Stop breeding sync listeners
+   [\#1727](https://github.com/matrix-org/matrix-js-sdk/pull/1727)
+ * Fix semicolons in TS files
+   [\#1724](https://github.com/matrix-org/matrix-js-sdk/pull/1724)
+ * [BREAKING] Convert MatrixClient to TypeScript
+   [\#1718](https://github.com/matrix-org/matrix-js-sdk/pull/1718)
+ * Factor out backup management to a separate module
+   [\#1697](https://github.com/matrix-org/matrix-js-sdk/pull/1697)
+ * Ignore power_levels events with unknown state_key on room-state
+   initialization
+   [\#1723](https://github.com/matrix-org/matrix-js-sdk/pull/1723)
+ * Revert 1579 (Fix extra negotiate message in Firefox)
+   [\#1725](https://github.com/matrix-org/matrix-js-sdk/pull/1725)
+
+Changes in [11.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0) (2021-06-07)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.2.0-rc.1...v11.2.0)
 
--   No changes since rc.1
-
-# Changes in [11.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0-rc.1) (2021-06-01)
+ * No changes since rc.1
 
+Changes in [11.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.2.0-rc.1) (2021-06-01)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.1.0...v11.2.0-rc.1)
 
--   Switch to stable endpoint/fields for MSC2858
-    [\#1720](https://github.com/matrix-org/matrix-js-sdk/pull/1720)
--   Bump ws from 7.4.2 to 7.4.6
-    [\#1715](https://github.com/matrix-org/matrix-js-sdk/pull/1715)
--   Make consistent call event type checks
-    [\#1712](https://github.com/matrix-org/matrix-js-sdk/pull/1712)
--   Apply new Babel linting config
-    [\#1714](https://github.com/matrix-org/matrix-js-sdk/pull/1714)
--   Bump browserslist from 4.16.1 to 4.16.6
-    [\#1709](https://github.com/matrix-org/matrix-js-sdk/pull/1709)
--   Add user_busy call hangup reason
-    [\#1713](https://github.com/matrix-org/matrix-js-sdk/pull/1713)
--   👕 New linting rules
-    [\#1688](https://github.com/matrix-org/matrix-js-sdk/pull/1688)
--   Emit relations created when target event added later
-    [\#1710](https://github.com/matrix-org/matrix-js-sdk/pull/1710)
--   Bump libolm version and update package name.
-    [\#1705](https://github.com/matrix-org/matrix-js-sdk/pull/1705)
--   Fix uploadContent not rejecting promise when http status code >= 400
-    [\#1703](https://github.com/matrix-org/matrix-js-sdk/pull/1703)
--   Reduce noise in tests
-    [\#1702](https://github.com/matrix-org/matrix-js-sdk/pull/1702)
--   Only log once if a Room lacks an m.room.create event
-    [\#1700](https://github.com/matrix-org/matrix-js-sdk/pull/1700)
--   Cache normalized room name
-    [\#1701](https://github.com/matrix-org/matrix-js-sdk/pull/1701)
--   Change call event handlers to adapt to undecrypted events
-    [\#1698](https://github.com/matrix-org/matrix-js-sdk/pull/1698)
-
-# Changes in [11.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0) (2021-05-24)
-
+ * Switch to stable endpoint/fields for MSC2858
+   [\#1720](https://github.com/matrix-org/matrix-js-sdk/pull/1720)
+ * Bump ws from 7.4.2 to 7.4.6
+   [\#1715](https://github.com/matrix-org/matrix-js-sdk/pull/1715)
+ * Make consistent call event type checks
+   [\#1712](https://github.com/matrix-org/matrix-js-sdk/pull/1712)
+ * Apply new Babel linting config
+   [\#1714](https://github.com/matrix-org/matrix-js-sdk/pull/1714)
+ * Bump browserslist from 4.16.1 to 4.16.6
+   [\#1709](https://github.com/matrix-org/matrix-js-sdk/pull/1709)
+ * Add user_busy call hangup reason
+   [\#1713](https://github.com/matrix-org/matrix-js-sdk/pull/1713)
+ * 👕 New linting rules
+   [\#1688](https://github.com/matrix-org/matrix-js-sdk/pull/1688)
+ * Emit relations created when target event added later
+   [\#1710](https://github.com/matrix-org/matrix-js-sdk/pull/1710)
+ * Bump libolm version and update package name.
+   [\#1705](https://github.com/matrix-org/matrix-js-sdk/pull/1705)
+ * Fix uploadContent not rejecting promise when http status code >= 400
+   [\#1703](https://github.com/matrix-org/matrix-js-sdk/pull/1703)
+ * Reduce noise in tests
+   [\#1702](https://github.com/matrix-org/matrix-js-sdk/pull/1702)
+ * Only log once if a Room lacks an m.room.create event
+   [\#1700](https://github.com/matrix-org/matrix-js-sdk/pull/1700)
+ * Cache normalized room name
+   [\#1701](https://github.com/matrix-org/matrix-js-sdk/pull/1701)
+ * Change call event handlers to adapt to undecrypted events
+   [\#1698](https://github.com/matrix-org/matrix-js-sdk/pull/1698)
+
+Changes in [11.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0) (2021-05-24)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.1.0-rc.1...v11.1.0)
 
--   [Release] Bump libolm version and update package name
-    [\#1707](https://github.com/matrix-org/matrix-js-sdk/pull/1707)
--   [Release] Change call event handlers to adapt to undecrypted events
-    [\#1699](https://github.com/matrix-org/matrix-js-sdk/pull/1699)
-
-# Changes in [11.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0-rc.1) (2021-05-19)
+ * [Release] Bump libolm version and update package name
+   [\#1707](https://github.com/matrix-org/matrix-js-sdk/pull/1707)
+ * [Release] Change call event handlers to adapt to undecrypted events
+   [\#1699](https://github.com/matrix-org/matrix-js-sdk/pull/1699)
 
+Changes in [11.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.1.0-rc.1) (2021-05-19)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.0.0...v11.1.0-rc.1)
 
--   Fix regressed glare
-    [\#1690](https://github.com/matrix-org/matrix-js-sdk/pull/1690)
--   Add m.reaction to EventType enum
-    [\#1692](https://github.com/matrix-org/matrix-js-sdk/pull/1692)
--   Prioritise and reduce the amount of events decrypted on application startup
-    [\#1684](https://github.com/matrix-org/matrix-js-sdk/pull/1684)
--   Decrypt relations before applying them to target event
-    [\#1696](https://github.com/matrix-org/matrix-js-sdk/pull/1696)
--   Guard against duplicates in `Relations` model
-
-# Changes in [11.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0) (2021-05-17)
-
+ * Fix regressed glare
+   [\#1690](https://github.com/matrix-org/matrix-js-sdk/pull/1690)
+ * Add m.reaction to EventType enum
+   [\#1692](https://github.com/matrix-org/matrix-js-sdk/pull/1692)
+ * Prioritise and reduce the amount of events decrypted on application startup
+   [\#1684](https://github.com/matrix-org/matrix-js-sdk/pull/1684)
+ * Decrypt relations before applying them to target event
+   [\#1696](https://github.com/matrix-org/matrix-js-sdk/pull/1696)
+ * Guard against duplicates in `Relations` model
+
+Changes in [11.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0) (2021-05-17)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v11.0.0-rc.1...v11.0.0)
 
--   [Release] Fix regressed glare
-    [\#1695](https://github.com/matrix-org/matrix-js-sdk/pull/1695)
-
-# Changes in [11.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0-rc.1) (2021-05-11)
+ * [Release] Fix regressed glare
+   [\#1695](https://github.com/matrix-org/matrix-js-sdk/pull/1695)
 
+Changes in [11.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v11.0.0-rc.1) (2021-05-11)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.1.0...v11.0.0-rc.1)
 
-## BREAKING CHANGES
-
--   `MatrixCall` and related APIs have been redesigned to support multiple streams
-    (see [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660) for more details)
+BREAKING CHANGES
+---
 
-## All changes
+ * `MatrixCall` and related APIs have been redesigned to support multiple streams
+   (see [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660) for more details)
 
--   Switch from MSC1772 unstable prefixes to stable
-    [\#1679](https://github.com/matrix-org/matrix-js-sdk/pull/1679)
--   Update the VoIP example to work with the new changes
-    [\#1680](https://github.com/matrix-org/matrix-js-sdk/pull/1680)
--   Bump hosted-git-info from 2.8.8 to 2.8.9
-    [\#1687](https://github.com/matrix-org/matrix-js-sdk/pull/1687)
--   Support for multiple streams (not MSC3077)
-    [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660)
--   Tweak missing m.room.create errors to describe their source
-    [\#1683](https://github.com/matrix-org/matrix-js-sdk/pull/1683)
+All changes
+---
 
-# Changes in [10.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0) (2021-05-10)
+ * Switch from MSC1772 unstable prefixes to stable
+   [\#1679](https://github.com/matrix-org/matrix-js-sdk/pull/1679)
+ * Update the VoIP example to work with the new changes
+   [\#1680](https://github.com/matrix-org/matrix-js-sdk/pull/1680)
+ * Bump hosted-git-info from 2.8.8 to 2.8.9
+   [\#1687](https://github.com/matrix-org/matrix-js-sdk/pull/1687)
+ * Support for multiple streams (not MSC3077)
+   [\#1660](https://github.com/matrix-org/matrix-js-sdk/pull/1660)
+ * Tweak missing m.room.create errors to describe their source
+   [\#1683](https://github.com/matrix-org/matrix-js-sdk/pull/1683)
 
+Changes in [10.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0) (2021-05-10)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.1.0-rc.1...v10.1.0)
 
--   No changes since rc.1
-
-# Changes in [10.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0-rc.1) (2021-05-04)
+ * No changes since rc.1
 
+Changes in [10.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.1.0-rc.1) (2021-05-04)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.0.0...v10.1.0-rc.1)
 
--   Revert "Raise logging dramatically to chase pending event errors"
-    [\#1681](https://github.com/matrix-org/matrix-js-sdk/pull/1681)
--   Add test coverage collection script
-    [\#1677](https://github.com/matrix-org/matrix-js-sdk/pull/1677)
--   Raise logging dramatically to chase pending event errors
-    [\#1678](https://github.com/matrix-org/matrix-js-sdk/pull/1678)
--   Support MSC3086 asserted identity
-    [\#1674](https://github.com/matrix-org/matrix-js-sdk/pull/1674)
--   Fix `/search` with no results field work again
-    [\#1670](https://github.com/matrix-org/matrix-js-sdk/pull/1670)
--   Add room.getMembers method
-    [\#1672](https://github.com/matrix-org/matrix-js-sdk/pull/1672)
-
-# Changes in [10.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0) (2021-04-26)
-
+ * Revert "Raise logging dramatically to chase pending event errors"
+   [\#1681](https://github.com/matrix-org/matrix-js-sdk/pull/1681)
+ * Add test coverage collection script
+   [\#1677](https://github.com/matrix-org/matrix-js-sdk/pull/1677)
+ * Raise logging dramatically to chase pending event errors
+   [\#1678](https://github.com/matrix-org/matrix-js-sdk/pull/1678)
+ * Support MSC3086 asserted identity
+   [\#1674](https://github.com/matrix-org/matrix-js-sdk/pull/1674)
+ * Fix `/search` with no results field work again
+   [\#1670](https://github.com/matrix-org/matrix-js-sdk/pull/1670)
+ * Add room.getMembers method
+   [\#1672](https://github.com/matrix-org/matrix-js-sdk/pull/1672)
+
+Changes in [10.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0) (2021-04-26)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v10.0.0-rc.1...v10.0.0)
 
--   No changes since rc.1
-
-# Changes in [10.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0-rc.1) (2021-04-21)
+ * No changes since rc.1
 
+Changes in [10.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v10.0.0-rc.1) (2021-04-21)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.11.0...v10.0.0-rc.1)
 
-## BREAKING CHANGES
-
--   The `RoomState.members` event is now only emitted when the room member's power level or the room's normal power level actually changes
-
-## All changes
-
--   Restrict event emit for room members that had power levels changed
-    [\#1675](https://github.com/matrix-org/matrix-js-sdk/pull/1675)
--   Fix sync with misconfigured push rules
-    [\#1669](https://github.com/matrix-org/matrix-js-sdk/pull/1669)
--   Add missing await
-    [\#1665](https://github.com/matrix-org/matrix-js-sdk/pull/1665)
--   Migrate to `eslint-plugin-matrix-org`
-    [\#1642](https://github.com/matrix-org/matrix-js-sdk/pull/1642)
--   Add missing event type enum for key verification done
-    [\#1664](https://github.com/matrix-org/matrix-js-sdk/pull/1664)
--   Fix timeline jumpiness by setting correct txnId
-    [\#1663](https://github.com/matrix-org/matrix-js-sdk/pull/1663)
--   Fix calling addEventListener if it does not exist
-    [\#1661](https://github.com/matrix-org/matrix-js-sdk/pull/1661)
--   Persist unsent messages for subsequent sessions
-    [\#1655](https://github.com/matrix-org/matrix-js-sdk/pull/1655)
-
-# Changes in [9.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0) (2021-04-12)
-
+BREAKING CHANGES
+---
+
+ * The `RoomState.members` event is now only emitted when the room member's power level or the room's normal power level actually changes
+
+All changes
+---
+
+ * Restrict event emit for room members that had power levels changed
+   [\#1675](https://github.com/matrix-org/matrix-js-sdk/pull/1675)
+ * Fix sync with misconfigured push rules
+   [\#1669](https://github.com/matrix-org/matrix-js-sdk/pull/1669)
+ * Add missing await
+   [\#1665](https://github.com/matrix-org/matrix-js-sdk/pull/1665)
+ * Migrate to `eslint-plugin-matrix-org`
+   [\#1642](https://github.com/matrix-org/matrix-js-sdk/pull/1642)
+ * Add missing event type enum for key verification done
+   [\#1664](https://github.com/matrix-org/matrix-js-sdk/pull/1664)
+ * Fix timeline jumpiness by setting correct txnId
+   [\#1663](https://github.com/matrix-org/matrix-js-sdk/pull/1663)
+ * Fix calling addEventListener if it does not exist
+   [\#1661](https://github.com/matrix-org/matrix-js-sdk/pull/1661)
+ * Persist unsent messages for subsequent sessions
+   [\#1655](https://github.com/matrix-org/matrix-js-sdk/pull/1655)
+
+Changes in [9.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0) (2021-04-12)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.11.0-rc.1...v9.11.0)
 
--   No changes since rc.1
-
-# Changes in [9.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0-rc.1) (2021-04-07)
+ * No changes since rc.1
 
+Changes in [9.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.11.0-rc.1) (2021-04-07)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.10.0...v9.11.0-rc.1)
 
--   Only try to cache private keys we know exist
-    [\#1657](https://github.com/matrix-org/matrix-js-sdk/pull/1657)
--   Properly terminate screen-share calls if NoUserMedia
-    [\#1654](https://github.com/matrix-org/matrix-js-sdk/pull/1654)
--   Attended transfer
-    [\#1652](https://github.com/matrix-org/matrix-js-sdk/pull/1652)
--   Remove catch handlers in private key retrieval
-    [\#1653](https://github.com/matrix-org/matrix-js-sdk/pull/1653)
--   Fixed the media fail error on caller's side
-    [\#1651](https://github.com/matrix-org/matrix-js-sdk/pull/1651)
--   Add function to share megolm keys for historical messages, take 2
-    [\#1640](https://github.com/matrix-org/matrix-js-sdk/pull/1640)
--   Cache cross-signing private keys if needed on bootstrap
-    [\#1649](https://github.com/matrix-org/matrix-js-sdk/pull/1649)
-
-# Changes in [9.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0) (2021-03-29)
-
+ * Only try to cache private keys we know exist
+   [\#1657](https://github.com/matrix-org/matrix-js-sdk/pull/1657)
+ * Properly terminate screen-share calls if NoUserMedia
+   [\#1654](https://github.com/matrix-org/matrix-js-sdk/pull/1654)
+ * Attended transfer
+   [\#1652](https://github.com/matrix-org/matrix-js-sdk/pull/1652)
+ * Remove catch handlers in private key retrieval
+   [\#1653](https://github.com/matrix-org/matrix-js-sdk/pull/1653)
+ * Fixed the media fail error on caller's side
+   [\#1651](https://github.com/matrix-org/matrix-js-sdk/pull/1651)
+ * Add function to share megolm keys for historical messages, take 2
+   [\#1640](https://github.com/matrix-org/matrix-js-sdk/pull/1640)
+ * Cache cross-signing private keys if needed on bootstrap
+   [\#1649](https://github.com/matrix-org/matrix-js-sdk/pull/1649)
+
+Changes in [9.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0) (2021-03-29)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.10.0-rc.1...v9.10.0)
 
--   No changes since rc.1
-
-# Changes in [9.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0-rc.1) (2021-03-25)
+ * No changes since rc.1
 
+Changes in [9.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.10.0-rc.1) (2021-03-25)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.9.0...v9.10.0-rc.1)
 
--   Don't send m.call.hangup if m.call.invite wasn't sent either
-    [\#1647](https://github.com/matrix-org/matrix-js-sdk/pull/1647)
--   docs: registerGuest()
-    [\#1641](https://github.com/matrix-org/matrix-js-sdk/pull/1641)
--   Download device keys in chunks of 250
-    [\#1639](https://github.com/matrix-org/matrix-js-sdk/pull/1639)
--   More VoIP connectivity fixes
-    [\#1646](https://github.com/matrix-org/matrix-js-sdk/pull/1646)
--   Make selectDesktopCapturerSource param optional
-    [\#1644](https://github.com/matrix-org/matrix-js-sdk/pull/1644)
--   Expose APIs needed for reworked cross-signing login flow
-    [\#1632](https://github.com/matrix-org/matrix-js-sdk/pull/1632)
-
-# Changes in [9.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0) (2021-03-15)
-
+ * Don't send m.call.hangup if m.call.invite wasn't sent either
+   [\#1647](https://github.com/matrix-org/matrix-js-sdk/pull/1647)
+ * docs: registerGuest()
+   [\#1641](https://github.com/matrix-org/matrix-js-sdk/pull/1641)
+ * Download device keys in chunks of 250
+   [\#1639](https://github.com/matrix-org/matrix-js-sdk/pull/1639)
+ * More VoIP connectivity fixes
+   [\#1646](https://github.com/matrix-org/matrix-js-sdk/pull/1646)
+ * Make selectDesktopCapturerSource param optional
+   [\#1644](https://github.com/matrix-org/matrix-js-sdk/pull/1644)
+ * Expose APIs needed for reworked cross-signing login flow
+   [\#1632](https://github.com/matrix-org/matrix-js-sdk/pull/1632)
+
+Changes in [9.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0) (2021-03-15)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.9.0-rc.1...v9.9.0)
 
--   No changes since rc.1
-
-# Changes in [9.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0-rc.1) (2021-03-10)
+ * No changes since rc.1
 
+Changes in [9.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.9.0-rc.1) (2021-03-10)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.8.0...v9.9.0-rc.1)
 
--   Remove detailed Olm session logging
-    [\#1638](https://github.com/matrix-org/matrix-js-sdk/pull/1638)
--   Add space summary suggested only param
-    [\#1637](https://github.com/matrix-org/matrix-js-sdk/pull/1637)
--   Check TURN servers periodically, and at start of calls
-    [\#1634](https://github.com/matrix-org/matrix-js-sdk/pull/1634)
--   Support sending invite reasons
-    [\#1624](https://github.com/matrix-org/matrix-js-sdk/pull/1624)
--   Bump elliptic from 6.5.3 to 6.5.4
-    [\#1636](https://github.com/matrix-org/matrix-js-sdk/pull/1636)
--   Add a function to get a room's MXC URI
-    [\#1635](https://github.com/matrix-org/matrix-js-sdk/pull/1635)
--   Stop streams if the call has ended
-    [\#1633](https://github.com/matrix-org/matrix-js-sdk/pull/1633)
--   Remove export keyword from global.d.ts
-    [\#1631](https://github.com/matrix-org/matrix-js-sdk/pull/1631)
--   Fix IndexedDB store creation example
-    [\#1445](https://github.com/matrix-org/matrix-js-sdk/pull/1445)
--   An attempt to cleanup how constraints are handled in calls
-    [\#1613](https://github.com/matrix-org/matrix-js-sdk/pull/1613)
--   Extract display name patterns to constants
-    [\#1628](https://github.com/matrix-org/matrix-js-sdk/pull/1628)
--   Bump pug-code-gen from 2.0.2 to 2.0.3
-    [\#1630](https://github.com/matrix-org/matrix-js-sdk/pull/1630)
--   Avoid deadlocks when ensuring Olm sessions for devices
-    [\#1627](https://github.com/matrix-org/matrix-js-sdk/pull/1627)
--   Filter out edits from other senders in history
-    [\#1626](https://github.com/matrix-org/matrix-js-sdk/pull/1626)
--   Fix ContentHelpers export
-    [\#1618](https://github.com/matrix-org/matrix-js-sdk/pull/1618)
--   Add logging to in progress Olm sessions
-    [\#1621](https://github.com/matrix-org/matrix-js-sdk/pull/1621)
--   Don't ignore ICE candidates received before offer/answer
-    [\#1623](https://github.com/matrix-org/matrix-js-sdk/pull/1623)
--   Better handling of send failures on VoIP events
-    [\#1622](https://github.com/matrix-org/matrix-js-sdk/pull/1622)
--   Log when turn creds expire
-    [\#1620](https://github.com/matrix-org/matrix-js-sdk/pull/1620)
--   Initial Spaces [MSC1772] support
-    [\#1563](https://github.com/matrix-org/matrix-js-sdk/pull/1563)
--   Add logging to crypto store transactions
-    [\#1617](https://github.com/matrix-org/matrix-js-sdk/pull/1617)
--   Room helper for getting type and checking if it is a space room
-    [\#1610](https://github.com/matrix-org/matrix-js-sdk/pull/1610)
-
-# Changes in [9.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0) (2021-03-01)
-
+ * Remove detailed Olm session logging
+   [\#1638](https://github.com/matrix-org/matrix-js-sdk/pull/1638)
+ * Add space summary suggested only param
+   [\#1637](https://github.com/matrix-org/matrix-js-sdk/pull/1637)
+ * Check TURN servers periodically, and at start of calls
+   [\#1634](https://github.com/matrix-org/matrix-js-sdk/pull/1634)
+ * Support sending invite reasons
+   [\#1624](https://github.com/matrix-org/matrix-js-sdk/pull/1624)
+ * Bump elliptic from 6.5.3 to 6.5.4
+   [\#1636](https://github.com/matrix-org/matrix-js-sdk/pull/1636)
+ * Add a function to get a room's MXC URI
+   [\#1635](https://github.com/matrix-org/matrix-js-sdk/pull/1635)
+ * Stop streams if the call has ended
+   [\#1633](https://github.com/matrix-org/matrix-js-sdk/pull/1633)
+ * Remove export keyword from global.d.ts
+   [\#1631](https://github.com/matrix-org/matrix-js-sdk/pull/1631)
+ * Fix IndexedDB store creation example
+   [\#1445](https://github.com/matrix-org/matrix-js-sdk/pull/1445)
+ * An attempt to  cleanup how constraints are handled in calls
+   [\#1613](https://github.com/matrix-org/matrix-js-sdk/pull/1613)
+ * Extract display name patterns to constants
+   [\#1628](https://github.com/matrix-org/matrix-js-sdk/pull/1628)
+ * Bump pug-code-gen from 2.0.2 to 2.0.3
+   [\#1630](https://github.com/matrix-org/matrix-js-sdk/pull/1630)
+ * Avoid deadlocks when ensuring Olm sessions for devices
+   [\#1627](https://github.com/matrix-org/matrix-js-sdk/pull/1627)
+ * Filter out edits from other senders in history
+   [\#1626](https://github.com/matrix-org/matrix-js-sdk/pull/1626)
+ * Fix ContentHelpers export
+   [\#1618](https://github.com/matrix-org/matrix-js-sdk/pull/1618)
+ * Add logging to in progress Olm sessions
+   [\#1621](https://github.com/matrix-org/matrix-js-sdk/pull/1621)
+ * Don't ignore ICE candidates received before offer/answer
+   [\#1623](https://github.com/matrix-org/matrix-js-sdk/pull/1623)
+ * Better handling of send failures on VoIP events
+   [\#1622](https://github.com/matrix-org/matrix-js-sdk/pull/1622)
+ * Log when turn creds expire
+   [\#1620](https://github.com/matrix-org/matrix-js-sdk/pull/1620)
+ * Initial Spaces [MSC1772] support
+   [\#1563](https://github.com/matrix-org/matrix-js-sdk/pull/1563)
+ * Add logging to crypto store transactions
+   [\#1617](https://github.com/matrix-org/matrix-js-sdk/pull/1617)
+ * Room helper for getting type and checking if it is a space room
+   [\#1610](https://github.com/matrix-org/matrix-js-sdk/pull/1610)
+
+Changes in [9.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0) (2021-03-01)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.8.0-rc.1...v9.8.0)
 
--   No changes since rc.1
-
-# Changes in [9.8.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0-rc.1) (2021-02-24)
+ * No changes since rc.1
 
+Changes in [9.8.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.8.0-rc.1) (2021-02-24)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.7.0...v9.8.0-rc.1)
 
--   Optimise prefixed logger
-    [\#1615](https://github.com/matrix-org/matrix-js-sdk/pull/1615)
--   Add debug logs to encryption prep, take 3
-    [\#1614](https://github.com/matrix-org/matrix-js-sdk/pull/1614)
--   Add functions for upper & lowercase random strings
-    [\#1612](https://github.com/matrix-org/matrix-js-sdk/pull/1612)
--   Room helpers for invite permissions and join rules
-    [\#1609](https://github.com/matrix-org/matrix-js-sdk/pull/1609)
--   Fixed wording in "Adding video track with id" log
-    [\#1606](https://github.com/matrix-org/matrix-js-sdk/pull/1606)
--   Add more debug logs to encryption prep
-    [\#1605](https://github.com/matrix-org/matrix-js-sdk/pull/1605)
--   Add option to set ice candidate pool size
-    [\#1604](https://github.com/matrix-org/matrix-js-sdk/pull/1604)
--   Cancel call if no source was selected
-    [\#1601](https://github.com/matrix-org/matrix-js-sdk/pull/1601)
-
-# Changes in [9.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0) (2021-02-16)
-
+ * Optimise prefixed logger
+   [\#1615](https://github.com/matrix-org/matrix-js-sdk/pull/1615)
+ * Add debug logs to encryption prep, take 3
+   [\#1614](https://github.com/matrix-org/matrix-js-sdk/pull/1614)
+ * Add functions for upper & lowercase random strings
+   [\#1612](https://github.com/matrix-org/matrix-js-sdk/pull/1612)
+ * Room helpers for invite permissions and join rules
+   [\#1609](https://github.com/matrix-org/matrix-js-sdk/pull/1609)
+ * Fixed wording in "Adding video track with id" log
+   [\#1606](https://github.com/matrix-org/matrix-js-sdk/pull/1606)
+ * Add more debug logs to encryption prep
+   [\#1605](https://github.com/matrix-org/matrix-js-sdk/pull/1605)
+ * Add option to set ice candidate pool size
+   [\#1604](https://github.com/matrix-org/matrix-js-sdk/pull/1604)
+ * Cancel call if no source was selected
+   [\#1601](https://github.com/matrix-org/matrix-js-sdk/pull/1601)
+
+Changes in [9.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0) (2021-02-16)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.7.0-rc.1...v9.7.0)
 
--   No changes since rc.1
-
-# Changes in [9.7.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0-rc.1) (2021-02-10)
+ * No changes since rc.1
 
+Changes in [9.7.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.7.0-rc.1) (2021-02-10)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.6.0...v9.7.0-rc.1)
 
--   Handle undefined peerconn
-    [\#1600](https://github.com/matrix-org/matrix-js-sdk/pull/1600)
--   ReEmitter: Don't throw if no error handler is attached
-    [\#1599](https://github.com/matrix-org/matrix-js-sdk/pull/1599)
--   Convert ReEmitter to TS
-    [\#1598](https://github.com/matrix-org/matrix-js-sdk/pull/1598)
--   Fix typo in main readme
-    [\#1597](https://github.com/matrix-org/matrix-js-sdk/pull/1597)
--   Remove rogue plus character
-    [\#1596](https://github.com/matrix-org/matrix-js-sdk/pull/1596)
--   Fix call ID NaN
-    [\#1595](https://github.com/matrix-org/matrix-js-sdk/pull/1595)
--   Fix Electron type merging
-    [\#1594](https://github.com/matrix-org/matrix-js-sdk/pull/1594)
--   Fix browser screen share
-    [\#1593](https://github.com/matrix-org/matrix-js-sdk/pull/1593)
--   Fix desktop Matrix screen sharing
-    [\#1570](https://github.com/matrix-org/matrix-js-sdk/pull/1570)
--   Guard against confused server retry times
-    [\#1591](https://github.com/matrix-org/matrix-js-sdk/pull/1591)
--   Decrypt redaction events
-    [\#1589](https://github.com/matrix-org/matrix-js-sdk/pull/1589)
--   Fix edge cases with peeking where a room is re-peeked
-    [\#1587](https://github.com/matrix-org/matrix-js-sdk/pull/1587)
-
-# Changes in [9.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0) (2021-02-03)
-
+ * Handle undefined peerconn
+   [\#1600](https://github.com/matrix-org/matrix-js-sdk/pull/1600)
+ * ReEmitter: Don't throw if no error handler is attached
+   [\#1599](https://github.com/matrix-org/matrix-js-sdk/pull/1599)
+ * Convert ReEmitter to TS
+   [\#1598](https://github.com/matrix-org/matrix-js-sdk/pull/1598)
+ * Fix typo in main readme
+   [\#1597](https://github.com/matrix-org/matrix-js-sdk/pull/1597)
+ * Remove rogue plus character
+   [\#1596](https://github.com/matrix-org/matrix-js-sdk/pull/1596)
+ * Fix call ID NaN
+   [\#1595](https://github.com/matrix-org/matrix-js-sdk/pull/1595)
+ * Fix Electron type merging
+   [\#1594](https://github.com/matrix-org/matrix-js-sdk/pull/1594)
+ * Fix browser screen share
+   [\#1593](https://github.com/matrix-org/matrix-js-sdk/pull/1593)
+ * Fix desktop Matrix screen sharing
+   [\#1570](https://github.com/matrix-org/matrix-js-sdk/pull/1570)
+ * Guard against confused server retry times
+   [\#1591](https://github.com/matrix-org/matrix-js-sdk/pull/1591)
+ * Decrypt redaction events
+   [\#1589](https://github.com/matrix-org/matrix-js-sdk/pull/1589)
+ * Fix edge cases with peeking where a room is re-peeked
+   [\#1587](https://github.com/matrix-org/matrix-js-sdk/pull/1587)
+
+Changes in [9.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0) (2021-02-03)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.6.0-rc.1...v9.6.0)
 
--   [Release] Fix edge cases with peeking where a room is re-peeked
-    [\#1588](https://github.com/matrix-org/matrix-js-sdk/pull/1588)
-
-# Changes in [9.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0-rc.1) (2021-01-29)
+ * [Release] Fix edge cases with peeking where a room is re-peeked
+   [\#1588](https://github.com/matrix-org/matrix-js-sdk/pull/1588)
 
+Changes in [9.6.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.6.0-rc.1) (2021-01-29)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.1...v9.6.0-rc.1)
 
--   Add support for getting call stats
-    [\#1584](https://github.com/matrix-org/matrix-js-sdk/pull/1584)
--   Fix compatibility with v0 calls
-    [\#1583](https://github.com/matrix-org/matrix-js-sdk/pull/1583)
--   Upgrade deps 2021-01
-    [\#1582](https://github.com/matrix-org/matrix-js-sdk/pull/1582)
--   Log the call ID when logging that we've received VoIP events
-    [\#1581](https://github.com/matrix-org/matrix-js-sdk/pull/1581)
--   Fix extra negotiate message in Firefox
-    [\#1579](https://github.com/matrix-org/matrix-js-sdk/pull/1579)
--   Add debug logs to encryption prep
-    [\#1580](https://github.com/matrix-org/matrix-js-sdk/pull/1580)
--   Expose getPresence endpoint
-    [\#1578](https://github.com/matrix-org/matrix-js-sdk/pull/1578)
--   Queue keys for backup even if backup isn't enabled yet
-    [\#1577](https://github.com/matrix-org/matrix-js-sdk/pull/1577)
--   Stop retrying TURN access when forbidden
-    [\#1576](https://github.com/matrix-org/matrix-js-sdk/pull/1576)
--   Add DTMF sending support
-    [\#1573](https://github.com/matrix-org/matrix-js-sdk/pull/1573)
-
-# Changes in [9.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.1) (2021-01-26)
-
+ * Add support for getting call stats
+   [\#1584](https://github.com/matrix-org/matrix-js-sdk/pull/1584)
+ * Fix compatibility with v0 calls
+   [\#1583](https://github.com/matrix-org/matrix-js-sdk/pull/1583)
+ * Upgrade deps 2021-01
+   [\#1582](https://github.com/matrix-org/matrix-js-sdk/pull/1582)
+ * Log the call ID when logging that we've received VoIP events
+   [\#1581](https://github.com/matrix-org/matrix-js-sdk/pull/1581)
+ * Fix extra negotiate message in Firefox
+   [\#1579](https://github.com/matrix-org/matrix-js-sdk/pull/1579)
+ * Add debug logs to encryption prep
+   [\#1580](https://github.com/matrix-org/matrix-js-sdk/pull/1580)
+ * Expose getPresence endpoint
+   [\#1578](https://github.com/matrix-org/matrix-js-sdk/pull/1578)
+ * Queue keys for backup even if backup isn't enabled yet
+   [\#1577](https://github.com/matrix-org/matrix-js-sdk/pull/1577)
+ * Stop retrying TURN access when forbidden
+   [\#1576](https://github.com/matrix-org/matrix-js-sdk/pull/1576)
+ * Add DTMF sending support
+   [\#1573](https://github.com/matrix-org/matrix-js-sdk/pull/1573)
+
+Changes in [9.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.1) (2021-01-26)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.0...v9.5.1)
 
--   [Release] Fix compatibility with v0 calls
-    [\#1585](https://github.com/matrix-org/matrix-js-sdk/pull/1585)
-
-# Changes in [9.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0) (2021-01-18)
+ * [Release] Fix compatibility with v0 calls
+   [\#1585](https://github.com/matrix-org/matrix-js-sdk/pull/1585)
 
+Changes in [9.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0) (2021-01-18)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.5.0-rc.1...v9.5.0)
 
--   No changes since rc.1
-
-# Changes in [9.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0-rc.1) (2021-01-13)
+ * No changes since rc.1
 
+Changes in [9.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.5.0-rc.1) (2021-01-13)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.1...v9.5.0-rc.1)
 
--   Don't log if no WebRTC
-    [\#1574](https://github.com/matrix-org/matrix-js-sdk/pull/1574)
--   Add \_unstable_getSharedRooms
-    [\#1417](https://github.com/matrix-org/matrix-js-sdk/pull/1417)
--   Bump node-notifier from 8.0.0 to 8.0.1
-    [\#1568](https://github.com/matrix-org/matrix-js-sdk/pull/1568)
--   Ignore party ID if opponent is v0
-    [\#1567](https://github.com/matrix-org/matrix-js-sdk/pull/1567)
--   Basic call transfer initiation support
-    [\#1566](https://github.com/matrix-org/matrix-js-sdk/pull/1566)
--   Room version 6 is now a thing
-    [\#1572](https://github.com/matrix-org/matrix-js-sdk/pull/1572)
--   Store keys with same index but better trust level
-    [\#1571](https://github.com/matrix-org/matrix-js-sdk/pull/1571)
--   Use TypeScript source for development, swap to build during release
-    [\#1561](https://github.com/matrix-org/matrix-js-sdk/pull/1561)
--   Revert "Ignore party ID if opponent is v0"
-    [\#1565](https://github.com/matrix-org/matrix-js-sdk/pull/1565)
--   Basic call transfer initiation support
-    [\#1558](https://github.com/matrix-org/matrix-js-sdk/pull/1558)
--   Ignore party ID if opponent is v0
-    [\#1559](https://github.com/matrix-org/matrix-js-sdk/pull/1559)
--   Honour a call reject event from another of our own devices
-    [\#1562](https://github.com/matrix-org/matrix-js-sdk/pull/1562)
-
-# Changes in [9.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.1) (2020-12-21)
-
+ * Don't log if no WebRTC
+   [\#1574](https://github.com/matrix-org/matrix-js-sdk/pull/1574)
+ * Add _unstable_getSharedRooms
+   [\#1417](https://github.com/matrix-org/matrix-js-sdk/pull/1417)
+ * Bump node-notifier from 8.0.0 to 8.0.1
+   [\#1568](https://github.com/matrix-org/matrix-js-sdk/pull/1568)
+ * Ignore party ID if opponent is v0
+   [\#1567](https://github.com/matrix-org/matrix-js-sdk/pull/1567)
+ * Basic call transfer initiation support
+   [\#1566](https://github.com/matrix-org/matrix-js-sdk/pull/1566)
+ * Room version 6 is now a thing
+   [\#1572](https://github.com/matrix-org/matrix-js-sdk/pull/1572)
+ * Store keys with same index but better trust level
+   [\#1571](https://github.com/matrix-org/matrix-js-sdk/pull/1571)
+ * Use TypeScript source for development, swap to build during release
+   [\#1561](https://github.com/matrix-org/matrix-js-sdk/pull/1561)
+ * Revert "Ignore party ID if opponent is v0"
+   [\#1565](https://github.com/matrix-org/matrix-js-sdk/pull/1565)
+ * Basic call transfer initiation support
+   [\#1558](https://github.com/matrix-org/matrix-js-sdk/pull/1558)
+ * Ignore party ID if opponent is v0
+   [\#1559](https://github.com/matrix-org/matrix-js-sdk/pull/1559)
+ * Honour a call reject event from another of our own devices
+   [\#1562](https://github.com/matrix-org/matrix-js-sdk/pull/1562)
+
+Changes in [9.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.1) (2020-12-21)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0...v9.4.1)
 
--   Further script tweaks to get all layers building again
-
-# Changes in [9.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0) (2020-12-21)
+ * Further script tweaks to get all layers building again
 
+Changes in [9.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0) (2020-12-21)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0-rc.2...v9.4.0)
 
--   Revert `postinstall` script change, causes issues for other layers
-
-# Changes in [9.4.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.2) (2020-12-16)
+ * Revert `postinstall` script change, causes issues for other layers
 
+Changes in [9.4.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.2) (2020-12-16)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.4.0-rc.1...v9.4.0-rc.2)
 
--   Remove `postinstall` script which also runs as a dependency
-    [\#1560](https://github.com/matrix-org/matrix-js-sdk/pull/1560)
-
-# Changes in [9.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.1) (2020-12-16)
+ * Remove `postinstall` script which also runs as a dependency
+   [\#1560](https://github.com/matrix-org/matrix-js-sdk/pull/1560)
 
+Changes in [9.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.4.0-rc.1) (2020-12-16)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.3.0...v9.4.0-rc.1)
 
--   Fixes to support line 1 / 2
-    [\#1553](https://github.com/matrix-org/matrix-js-sdk/pull/1553)
--   Add API for listening to remote hold status, advertise VoIP V1
-    [\#1549](https://github.com/matrix-org/matrix-js-sdk/pull/1549)
--   A hangup from another client is still valid
-    [\#1555](https://github.com/matrix-org/matrix-js-sdk/pull/1555)
--   Remove temporary build step for tests
-    [\#1554](https://github.com/matrix-org/matrix-js-sdk/pull/1554)
--   Move browser build steps to prepublish only
-    [\#1552](https://github.com/matrix-org/matrix-js-sdk/pull/1552)
--   Extend getSsoLoginUrl for MSC2858
-    [\#1541](https://github.com/matrix-org/matrix-js-sdk/pull/1541)
-
-# Changes in [9.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0) (2020-12-07)
-
+ * Fixes to support line 1 / 2
+   [\#1553](https://github.com/matrix-org/matrix-js-sdk/pull/1553)
+ * Add API for listening to remote hold status, advertise VoIP V1
+   [\#1549](https://github.com/matrix-org/matrix-js-sdk/pull/1549)
+ * A hangup from another client is still valid
+   [\#1555](https://github.com/matrix-org/matrix-js-sdk/pull/1555)
+ * Remove temporary build step for tests
+   [\#1554](https://github.com/matrix-org/matrix-js-sdk/pull/1554)
+ * Move browser build steps to prepublish only
+   [\#1552](https://github.com/matrix-org/matrix-js-sdk/pull/1552)
+ * Extend getSsoLoginUrl for MSC2858
+   [\#1541](https://github.com/matrix-org/matrix-js-sdk/pull/1541)
+
+Changes in [9.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0) (2020-12-07)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.3.0-rc.1...v9.3.0)
 
--   No changes since rc.1
-
-# Changes in [9.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0-rc.1) (2020-12-02)
+* No changes since rc.1
 
+Changes in [9.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.3.0-rc.1) (2020-12-02)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.2.0...v9.3.0-rc.1)
 
--   Export CallError
-    [\#1551](https://github.com/matrix-org/matrix-js-sdk/pull/1551)
--   Upgrade dependencies
-    [\#1550](https://github.com/matrix-org/matrix-js-sdk/pull/1550)
--   Don't log error when environment does not support WebRTC
-    [\#1547](https://github.com/matrix-org/matrix-js-sdk/pull/1547)
--   Fix dehydration method name
-    [\#1544](https://github.com/matrix-org/matrix-js-sdk/pull/1544)
-
-# Changes in [9.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0) (2020-11-23)
-
+ * Export CallError
+   [\#1551](https://github.com/matrix-org/matrix-js-sdk/pull/1551)
+ * Upgrade dependencies
+   [\#1550](https://github.com/matrix-org/matrix-js-sdk/pull/1550)
+ * Don't log error when environment does not support WebRTC
+   [\#1547](https://github.com/matrix-org/matrix-js-sdk/pull/1547)
+ * Fix dehydration method name
+   [\#1544](https://github.com/matrix-org/matrix-js-sdk/pull/1544)
+
+Changes in [9.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0) (2020-11-23)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.2.0-rc.1...v9.2.0)
 
--   [Release] Fix dehydration method name
-    [\#1545](https://github.com/matrix-org/matrix-js-sdk/pull/1545)
-
-# Changes in [9.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0-rc.1) (2020-11-18)
+ * [Release] Fix dehydration method name
+   [\#1545](https://github.com/matrix-org/matrix-js-sdk/pull/1545)
 
+Changes in [9.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.2.0-rc.1) (2020-11-18)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.1.0...v9.2.0-rc.1)
 
--   Implement call holding functionality
-    [\#1532](https://github.com/matrix-org/matrix-js-sdk/pull/1532)
--   Support awaitable one-time dehydration
-    [\#1537](https://github.com/matrix-org/matrix-js-sdk/pull/1537)
--   Client set profile methods update own user
-    [\#1534](https://github.com/matrix-org/matrix-js-sdk/pull/1534)
-
-# Changes in [9.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0) (2020-11-09)
+ * Implement call holding functionality
+   [\#1532](https://github.com/matrix-org/matrix-js-sdk/pull/1532)
+ * Support awaitable one-time dehydration
+   [\#1537](https://github.com/matrix-org/matrix-js-sdk/pull/1537)
+ * Client set profile methods update own user
+   [\#1534](https://github.com/matrix-org/matrix-js-sdk/pull/1534)
 
+Changes in [9.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0) (2020-11-09)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.1.0-rc.1...v9.1.0)
 
--   No changes since rc.1
-
-# Changes in [9.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0-rc.1) (2020-11-04)
+* No changes since rc.1
 
+Changes in [9.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.1.0-rc.1) (2020-11-04)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.1...v9.1.0-rc.1)
 
--   Fix spelling error in the server ACL event type
-    [\#1535](https://github.com/matrix-org/matrix-js-sdk/pull/1535)
--   await idb operations from crypto store for dehydration
-    [\#1533](https://github.com/matrix-org/matrix-js-sdk/pull/1533)
--   Fix stuck never-sending messages
-    [\#1531](https://github.com/matrix-org/matrix-js-sdk/pull/1531)
--   Await key cache check to avoid prompts
-    [\#1529](https://github.com/matrix-org/matrix-js-sdk/pull/1529)
--   Improve ICE candidate batching
-    [\#1524](https://github.com/matrix-org/matrix-js-sdk/pull/1524)
--   Convert logger to typescript
-    [\#1527](https://github.com/matrix-org/matrix-js-sdk/pull/1527)
--   Fix logger typo
-    [\#1525](https://github.com/matrix-org/matrix-js-sdk/pull/1525)
--   bind online listener to window instead of document
-    [\#1523](https://github.com/matrix-org/matrix-js-sdk/pull/1523)
--   Support m.call.select_answer
-    [\#1522](https://github.com/matrix-org/matrix-js-sdk/pull/1522)
-
-# Changes in [9.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.1) (2020-10-28)
-
+ * Fix spelling error in the server ACL event type
+   [\#1535](https://github.com/matrix-org/matrix-js-sdk/pull/1535)
+ * await idb operations from crypto store for dehydration
+   [\#1533](https://github.com/matrix-org/matrix-js-sdk/pull/1533)
+ * Fix stuck never-sending messages
+   [\#1531](https://github.com/matrix-org/matrix-js-sdk/pull/1531)
+ * Await key cache check to avoid prompts
+   [\#1529](https://github.com/matrix-org/matrix-js-sdk/pull/1529)
+ * Improve ICE candidate batching
+   [\#1524](https://github.com/matrix-org/matrix-js-sdk/pull/1524)
+ * Convert logger to typescript
+   [\#1527](https://github.com/matrix-org/matrix-js-sdk/pull/1527)
+ * Fix logger typo
+   [\#1525](https://github.com/matrix-org/matrix-js-sdk/pull/1525)
+ * bind online listener to window instead of document
+   [\#1523](https://github.com/matrix-org/matrix-js-sdk/pull/1523)
+ * Support m.call.select_answer
+   [\#1522](https://github.com/matrix-org/matrix-js-sdk/pull/1522)
+
+Changes in [9.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.1) (2020-10-28)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.0...v9.0.1)
 
--   [Release] Await key cache check to avoid prompts
-    [\#1530](https://github.com/matrix-org/matrix-js-sdk/pull/1530)
-
-# Changes in [9.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0) (2020-10-26)
+ * [Release] Await key cache check to avoid prompts
+   [\#1530](https://github.com/matrix-org/matrix-js-sdk/pull/1530)
 
+Changes in [9.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0) (2020-10-26)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v9.0.0-rc.1...v9.0.0)
 
--   Fix logger typo
-    [\#1528](https://github.com/matrix-org/matrix-js-sdk/pull/1528)
-
-# Changes in [9.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0-rc.1) (2020-10-21)
+ * Fix logger typo
+   [\#1528](https://github.com/matrix-org/matrix-js-sdk/pull/1528)
 
+Changes in [9.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v9.0.0-rc.1) (2020-10-21)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.5.0...v9.0.0-rc.1)
 
-## BREAKING CHANGES
-
--   `hasPendingEvent` now returns false instead of throwing when pending ordering mode is not `detached`
-
-## All changes
-
--   Don't cache failures when fetching /versions
-    [\#1521](https://github.com/matrix-org/matrix-js-sdk/pull/1521)
--   Install deps first as part of release
-    [\#1518](https://github.com/matrix-org/matrix-js-sdk/pull/1518)
--   [Breaking] Change hasPendingEvent to return false if pending ordering
-    !detached
-    [\#1517](https://github.com/matrix-org/matrix-js-sdk/pull/1517)
--   Skip editor prompts for merges
-    [\#1519](https://github.com/matrix-org/matrix-js-sdk/pull/1519)
--   Convert call test to TypeScript
-    [\#1516](https://github.com/matrix-org/matrix-js-sdk/pull/1516)
--   Support party_id
-    [\#1512](https://github.com/matrix-org/matrix-js-sdk/pull/1512)
--   Support m.call.reject
-    [\#1510](https://github.com/matrix-org/matrix-js-sdk/pull/1510)
--   Remove specbuild from .gitignore
-    [\#1515](https://github.com/matrix-org/matrix-js-sdk/pull/1515)
--   Log the error when we failed to send candidates
-    [\#1514](https://github.com/matrix-org/matrix-js-sdk/pull/1514)
--   Fixes for call state machine
-    [\#1503](https://github.com/matrix-org/matrix-js-sdk/pull/1503)
--   Fix call event handler listener removing
-    [\#1506](https://github.com/matrix-org/matrix-js-sdk/pull/1506)
--   Set the type of the call based on the tracks
-    [\#1501](https://github.com/matrix-org/matrix-js-sdk/pull/1501)
--   Use new local timestamp for calls
-    [\#1499](https://github.com/matrix-org/matrix-js-sdk/pull/1499)
--   Adjust types and APIs to match React SDK
-    [\#1502](https://github.com/matrix-org/matrix-js-sdk/pull/1502)
--   Make an accurate version of 'age' for events
-    [\#1495](https://github.com/matrix-org/matrix-js-sdk/pull/1495)
--   Make 'options' parameter optional
-    [\#1498](https://github.com/matrix-org/matrix-js-sdk/pull/1498)
--   Create a giant event type enum
-    [\#1497](https://github.com/matrix-org/matrix-js-sdk/pull/1497)
--   Convert call.js to Typescript & update WebRTC APIs (re-apply)
-    [\#1494](https://github.com/matrix-org/matrix-js-sdk/pull/1494)
-
-# Changes in [8.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0) (2020-10-12)
-
+BREAKING CHANGES
+---
+
+ * `hasPendingEvent` now returns false instead of throwing when pending ordering mode is not `detached`
+
+All changes
+---
+
+ * Don't cache failures when fetching /versions
+   [\#1521](https://github.com/matrix-org/matrix-js-sdk/pull/1521)
+ * Install deps first as part of release
+   [\#1518](https://github.com/matrix-org/matrix-js-sdk/pull/1518)
+ * [Breaking] Change hasPendingEvent to return false if pending ordering
+   !detached
+   [\#1517](https://github.com/matrix-org/matrix-js-sdk/pull/1517)
+ * Skip editor prompts for merges
+   [\#1519](https://github.com/matrix-org/matrix-js-sdk/pull/1519)
+ * Convert call test to TypeScript
+   [\#1516](https://github.com/matrix-org/matrix-js-sdk/pull/1516)
+ * Support party_id
+   [\#1512](https://github.com/matrix-org/matrix-js-sdk/pull/1512)
+ * Support m.call.reject
+   [\#1510](https://github.com/matrix-org/matrix-js-sdk/pull/1510)
+ * Remove specbuild from .gitignore
+   [\#1515](https://github.com/matrix-org/matrix-js-sdk/pull/1515)
+ * Log the error when we failed to send candidates
+   [\#1514](https://github.com/matrix-org/matrix-js-sdk/pull/1514)
+ * Fixes for call state machine
+   [\#1503](https://github.com/matrix-org/matrix-js-sdk/pull/1503)
+ * Fix call event handler listener removing
+   [\#1506](https://github.com/matrix-org/matrix-js-sdk/pull/1506)
+ * Set the type of the call based on the tracks
+   [\#1501](https://github.com/matrix-org/matrix-js-sdk/pull/1501)
+ * Use new local timestamp for calls
+   [\#1499](https://github.com/matrix-org/matrix-js-sdk/pull/1499)
+ * Adjust types and APIs to match React SDK
+   [\#1502](https://github.com/matrix-org/matrix-js-sdk/pull/1502)
+ * Make an accurate version of 'age' for events
+   [\#1495](https://github.com/matrix-org/matrix-js-sdk/pull/1495)
+ * Make 'options' parameter optional
+   [\#1498](https://github.com/matrix-org/matrix-js-sdk/pull/1498)
+ * Create a giant event type enum
+   [\#1497](https://github.com/matrix-org/matrix-js-sdk/pull/1497)
+ * Convert call.js to Typescript & update WebRTC APIs (re-apply)
+   [\#1494](https://github.com/matrix-org/matrix-js-sdk/pull/1494)
+
+Changes in [8.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0) (2020-10-12)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.5.0-rc.1...v8.5.0)
 
--   No changes since rc.1
-
-# Changes in [8.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0-rc.1) (2020-10-07)
+* No changes since rc.1
 
+Changes in [8.5.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.5.0-rc.1) (2020-10-07)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.4.1...v8.5.0-rc.1)
 
--   Add support for olm fallback keys
-    [\#1467](https://github.com/matrix-org/matrix-js-sdk/pull/1467)
--   Fix editing local echoes not updating them in real time
-    [\#1492](https://github.com/matrix-org/matrix-js-sdk/pull/1492)
--   Fix re-emit of Event.replaced to be on client and not room
-    [\#1491](https://github.com/matrix-org/matrix-js-sdk/pull/1491)
--   Add space to log line
-    [\#1496](https://github.com/matrix-org/matrix-js-sdk/pull/1496)
--   Revert "Convert call.js to Typescript & update WebRTC APIs"
-    [\#1493](https://github.com/matrix-org/matrix-js-sdk/pull/1493)
--   Convert call.js to Typescript & update WebRTC APIs
-    [\#1487](https://github.com/matrix-org/matrix-js-sdk/pull/1487)
--   Dehydrate and rehydrate devices
-    [\#1436](https://github.com/matrix-org/matrix-js-sdk/pull/1436)
--   Keep local device after processing device list sync
-    [\#1490](https://github.com/matrix-org/matrix-js-sdk/pull/1490)
--   Enforce logger module via lint rules
-    [\#1489](https://github.com/matrix-org/matrix-js-sdk/pull/1489)
--   Extend method redactEvent with reason
-    [\#1462](https://github.com/matrix-org/matrix-js-sdk/pull/1462)
--   Catch exception from call event handler
-    [\#1484](https://github.com/matrix-org/matrix-js-sdk/pull/1484)
--   Ignore invalid candidates
-    [\#1483](https://github.com/matrix-org/matrix-js-sdk/pull/1483)
--   Always push docs if they are generated
-    [\#1478](https://github.com/matrix-org/matrix-js-sdk/pull/1478)
--   Only sign key backup with cross-signing keys when available
-    [\#1481](https://github.com/matrix-org/matrix-js-sdk/pull/1481)
--   Upgrade dependencies
-    [\#1479](https://github.com/matrix-org/matrix-js-sdk/pull/1479)
-
-# Changes in [8.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.1) (2020-09-28)
-
+ * Add support for olm fallback keys
+   [\#1467](https://github.com/matrix-org/matrix-js-sdk/pull/1467)
+ * Fix editing local echoes not updating them in real time
+   [\#1492](https://github.com/matrix-org/matrix-js-sdk/pull/1492)
+ * Fix re-emit of Event.replaced to be on client and not room
+   [\#1491](https://github.com/matrix-org/matrix-js-sdk/pull/1491)
+ * Add space to log line
+   [\#1496](https://github.com/matrix-org/matrix-js-sdk/pull/1496)
+ * Revert "Convert call.js to Typescript & update WebRTC APIs"
+   [\#1493](https://github.com/matrix-org/matrix-js-sdk/pull/1493)
+ * Convert call.js to Typescript & update WebRTC APIs
+   [\#1487](https://github.com/matrix-org/matrix-js-sdk/pull/1487)
+ * Dehydrate and rehydrate devices
+   [\#1436](https://github.com/matrix-org/matrix-js-sdk/pull/1436)
+ * Keep local device after processing device list sync
+   [\#1490](https://github.com/matrix-org/matrix-js-sdk/pull/1490)
+ * Enforce logger module via lint rules
+   [\#1489](https://github.com/matrix-org/matrix-js-sdk/pull/1489)
+ * Extend method redactEvent with reason
+   [\#1462](https://github.com/matrix-org/matrix-js-sdk/pull/1462)
+ * Catch exception from call event handler
+   [\#1484](https://github.com/matrix-org/matrix-js-sdk/pull/1484)
+ * Ignore invalid candidates
+   [\#1483](https://github.com/matrix-org/matrix-js-sdk/pull/1483)
+ * Always push docs if they are generated
+   [\#1478](https://github.com/matrix-org/matrix-js-sdk/pull/1478)
+ * Only sign key backup with cross-signing keys when available
+   [\#1481](https://github.com/matrix-org/matrix-js-sdk/pull/1481)
+ * Upgrade dependencies
+   [\#1479](https://github.com/matrix-org/matrix-js-sdk/pull/1479)
+
+Changes in [8.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.1) (2020-09-28)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.4.0...v8.4.1)
 
--   Catch exception from call event handler
-    [\#1486](https://github.com/matrix-org/matrix-js-sdk/pull/1486)
--   Ignore invalid candidates
-    [\#1485](https://github.com/matrix-org/matrix-js-sdk/pull/1485)
-
-# Changes in [8.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0) (2020-09-28)
+ * Catch exception from call event handler
+   [\#1486](https://github.com/matrix-org/matrix-js-sdk/pull/1486)
+ * Ignore invalid candidates
+   [\#1485](https://github.com/matrix-org/matrix-js-sdk/pull/1485)
 
+Changes in [8.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0) (2020-09-28)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.4.0-rc.1...v8.4.0)
 
--   Only sign key backup with cross-signing keys when available
-    [\#1482](https://github.com/matrix-org/matrix-js-sdk/pull/1482)
-
-# Changes in [8.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0-rc.1) (2020-09-23)
+ * Only sign key backup with cross-signing keys when available
+   [\#1482](https://github.com/matrix-org/matrix-js-sdk/pull/1482)
 
+Changes in [8.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.4.0-rc.1) (2020-09-23)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.3.0...v8.4.0-rc.1)
 
--   If there are extraParams set, ensure that queryParams is defined
-    [\#1477](https://github.com/matrix-org/matrix-js-sdk/pull/1477)
--   Add diagnostics to security bootstrap paths
-    [\#1475](https://github.com/matrix-org/matrix-js-sdk/pull/1475)
--   Switch to a combination of better-docs and docdash
-    [\#1459](https://github.com/matrix-org/matrix-js-sdk/pull/1459)
--   Undo attempts to cache private keys aggressively
-    [\#1474](https://github.com/matrix-org/matrix-js-sdk/pull/1474)
--   Repair secret storage reset, cache keys when missing
-    [\#1472](https://github.com/matrix-org/matrix-js-sdk/pull/1472)
--   Prevent parallel getVersions calls
-    [\#1471](https://github.com/matrix-org/matrix-js-sdk/pull/1471)
--   Send end-of-candidates
-    [\#1473](https://github.com/matrix-org/matrix-js-sdk/pull/1473)
--   Add a function for checking the /versions flag for forced e2ee
-    [\#1470](https://github.com/matrix-org/matrix-js-sdk/pull/1470)
--   Add option to allow users of pantialaimon to use the SDK
-    [\#1469](https://github.com/matrix-org/matrix-js-sdk/pull/1469)
--   Fixed Yarn broken link
-    [\#1468](https://github.com/matrix-org/matrix-js-sdk/pull/1468)
--   some TypeScript and doc fixes
-    [\#1466](https://github.com/matrix-org/matrix-js-sdk/pull/1466)
--   Remove Travis CI reference
-    [\#1464](https://github.com/matrix-org/matrix-js-sdk/pull/1464)
--   Inject identity server token for 3pid invites on createRoom
-    [\#1463](https://github.com/matrix-org/matrix-js-sdk/pull/1463)
-
-# Changes in [8.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0) (2020-09-14)
-
+ * If there are extraParams set, ensure that queryParams is defined
+   [\#1477](https://github.com/matrix-org/matrix-js-sdk/pull/1477)
+ * Add diagnostics to security bootstrap paths
+   [\#1475](https://github.com/matrix-org/matrix-js-sdk/pull/1475)
+ * Switch to a combination of better-docs and docdash
+   [\#1459](https://github.com/matrix-org/matrix-js-sdk/pull/1459)
+ * Undo attempts to cache private keys aggressively
+   [\#1474](https://github.com/matrix-org/matrix-js-sdk/pull/1474)
+ * Repair secret storage reset, cache keys when missing
+   [\#1472](https://github.com/matrix-org/matrix-js-sdk/pull/1472)
+ * Prevent parallel getVersions calls
+   [\#1471](https://github.com/matrix-org/matrix-js-sdk/pull/1471)
+ * Send end-of-candidates
+   [\#1473](https://github.com/matrix-org/matrix-js-sdk/pull/1473)
+ * Add a function for checking the /versions flag for forced e2ee
+   [\#1470](https://github.com/matrix-org/matrix-js-sdk/pull/1470)
+ * Add option to allow users of pantialaimon to use the SDK
+   [\#1469](https://github.com/matrix-org/matrix-js-sdk/pull/1469)
+ * Fixed Yarn broken link
+   [\#1468](https://github.com/matrix-org/matrix-js-sdk/pull/1468)
+ * some TypeScript and doc fixes
+   [\#1466](https://github.com/matrix-org/matrix-js-sdk/pull/1466)
+ * Remove Travis CI reference
+   [\#1464](https://github.com/matrix-org/matrix-js-sdk/pull/1464)
+ * Inject identity server token for 3pid invites on createRoom
+   [\#1463](https://github.com/matrix-org/matrix-js-sdk/pull/1463)
+
+Changes in [8.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0) (2020-09-14)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.3.0-rc.1...v8.3.0)
 
--   No changes since rc.1
-
-# Changes in [8.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0-rc.1) (2020-09-09)
+* No changes since rc.1
 
+Changes in [8.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.3.0-rc.1) (2020-09-09)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.2.0...v8.3.0-rc.1)
 
--   Add missing options in ICreateClientOpts
-    [\#1452](https://github.com/matrix-org/matrix-js-sdk/pull/1452)
--   Ensure ready functions return boolean values
-    [\#1457](https://github.com/matrix-org/matrix-js-sdk/pull/1457)
--   Handle missing cross-signing keys gracefully
-    [\#1456](https://github.com/matrix-org/matrix-js-sdk/pull/1456)
--   Fix eslint ts override tsx matching
-    [\#1451](https://github.com/matrix-org/matrix-js-sdk/pull/1451)
--   Untangle cross-signing and secret storage
-    [\#1450](https://github.com/matrix-org/matrix-js-sdk/pull/1450)
-
-# Changes in [8.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0) (2020-09-01)
-
+ * Add missing options in ICreateClientOpts
+   [\#1452](https://github.com/matrix-org/matrix-js-sdk/pull/1452)
+ * Ensure ready functions return boolean values
+   [\#1457](https://github.com/matrix-org/matrix-js-sdk/pull/1457)
+ * Handle missing cross-signing keys gracefully
+   [\#1456](https://github.com/matrix-org/matrix-js-sdk/pull/1456)
+ * Fix eslint ts override tsx matching
+   [\#1451](https://github.com/matrix-org/matrix-js-sdk/pull/1451)
+ * Untangle cross-signing and secret storage
+   [\#1450](https://github.com/matrix-org/matrix-js-sdk/pull/1450)
+
+Changes in [8.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0) (2020-09-01)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.2.0-rc.1...v8.2.0)
 
 ## Security notice
@@ -1681,2131 +1629,2150 @@ Security Disclosure Policy.
 
 ## All changes
 
--   No changes since rc.1
-
-# Changes in [8.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0-rc.1) (2020-08-26)
+* No changes since rc.1
 
+Changes in [8.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.2.0-rc.1) (2020-08-26)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.1.0...v8.2.0-rc.1)
 
--   Add state event check
-    [\#1449](https://github.com/matrix-org/matrix-js-sdk/pull/1449)
--   Add method to check whether client .well-known has been fetched
-    [\#1444](https://github.com/matrix-org/matrix-js-sdk/pull/1444)
--   Handle auth errors during cross-signing key upload
-    [\#1443](https://github.com/matrix-org/matrix-js-sdk/pull/1443)
--   Don't fail if the requested audio output isn't available
-    [\#1448](https://github.com/matrix-org/matrix-js-sdk/pull/1448)
--   Fix logging failures
-    [\#1447](https://github.com/matrix-org/matrix-js-sdk/pull/1447)
--   Log the constraints we pass to getUserMedia
-    [\#1446](https://github.com/matrix-org/matrix-js-sdk/pull/1446)
--   Use SAS emoji data from matrix-doc
-    [\#1440](https://github.com/matrix-org/matrix-js-sdk/pull/1440)
-
-# Changes in [8.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0) (2020-08-17)
-
+ * Add state event check
+   [\#1449](https://github.com/matrix-org/matrix-js-sdk/pull/1449)
+ * Add method to check whether client .well-known has been fetched
+   [\#1444](https://github.com/matrix-org/matrix-js-sdk/pull/1444)
+ * Handle auth errors during cross-signing key upload
+   [\#1443](https://github.com/matrix-org/matrix-js-sdk/pull/1443)
+ * Don't fail if the requested audio output isn't available
+   [\#1448](https://github.com/matrix-org/matrix-js-sdk/pull/1448)
+ * Fix logging failures
+   [\#1447](https://github.com/matrix-org/matrix-js-sdk/pull/1447)
+ * Log the constraints we pass to getUserMedia
+   [\#1446](https://github.com/matrix-org/matrix-js-sdk/pull/1446)
+ * Use SAS emoji data from matrix-doc
+   [\#1440](https://github.com/matrix-org/matrix-js-sdk/pull/1440)
+
+Changes in [8.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0) (2020-08-17)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.1.0-rc.1...v8.1.0)
 
--   No changes since rc.1
-
-# Changes in [8.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0-rc.1) (2020-08-13)
+* No changes since rc.1
 
+Changes in [8.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.1.0-rc.1) (2020-08-13)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.0.1...v8.1.0-rc.1)
 
--   Update on Promises
-    [\#1438](https://github.com/matrix-org/matrix-js-sdk/pull/1438)
--   Store and request master cross-signing key
-    [\#1437](https://github.com/matrix-org/matrix-js-sdk/pull/1437)
--   Filter out non-string display names
-    [\#1433](https://github.com/matrix-org/matrix-js-sdk/pull/1433)
--   Bump elliptic from 6.5.2 to 6.5.3
-    [\#1427](https://github.com/matrix-org/matrix-js-sdk/pull/1427)
--   Replace Riot with Element in docs and comments
-    [\#1431](https://github.com/matrix-org/matrix-js-sdk/pull/1431)
--   Remove leftover bits of TSLint
-    [\#1430](https://github.com/matrix-org/matrix-js-sdk/pull/1430)
-
-# Changes in [8.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1) (2020-08-05)
-
+ * Update on Promises
+   [\#1438](https://github.com/matrix-org/matrix-js-sdk/pull/1438)
+ * Store and request master cross-signing key
+   [\#1437](https://github.com/matrix-org/matrix-js-sdk/pull/1437)
+ * Filter out non-string display names
+   [\#1433](https://github.com/matrix-org/matrix-js-sdk/pull/1433)
+ * Bump elliptic from 6.5.2 to 6.5.3
+   [\#1427](https://github.com/matrix-org/matrix-js-sdk/pull/1427)
+ * Replace Riot with Element in docs and comments
+   [\#1431](https://github.com/matrix-org/matrix-js-sdk/pull/1431)
+ * Remove leftover bits of TSLint
+   [\#1430](https://github.com/matrix-org/matrix-js-sdk/pull/1430)
+
+Changes in [8.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1) (2020-08-05)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.0.1-rc.1...v8.0.1)
 
--   Filter out non-string display names
-    [\#1434](https://github.com/matrix-org/matrix-js-sdk/pull/1434)
-
-# Changes in [8.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1-rc.1) (2020-07-31)
+ * Filter out non-string display names
+   [\#1434](https://github.com/matrix-org/matrix-js-sdk/pull/1434)
 
+Changes in [8.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.1-rc.1) (2020-07-31)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v8.0.0...v8.0.1-rc.1)
 
--   Remove redundant lint dependencies
-    [\#1426](https://github.com/matrix-org/matrix-js-sdk/pull/1426)
--   Upload all keys when we start using a new key backup version
-    [\#1428](https://github.com/matrix-org/matrix-js-sdk/pull/1428)
--   Expose countSessionsNeedingBackup
-    [\#1429](https://github.com/matrix-org/matrix-js-sdk/pull/1429)
--   Configure and use new eslint package
-    [\#1422](https://github.com/matrix-org/matrix-js-sdk/pull/1422)
-
-# Changes in [8.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.0) (2020-07-27)
-
+ * Remove redundant lint dependencies
+   [\#1426](https://github.com/matrix-org/matrix-js-sdk/pull/1426)
+ * Upload all keys when we start using a new key backup version
+   [\#1428](https://github.com/matrix-org/matrix-js-sdk/pull/1428)
+ * Expose countSessionsNeedingBackup
+   [\#1429](https://github.com/matrix-org/matrix-js-sdk/pull/1429)
+ * Configure and use new eslint package
+   [\#1422](https://github.com/matrix-org/matrix-js-sdk/pull/1422)
+
+Changes in [8.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v8.0.0) (2020-07-27)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.1.0...v8.0.0)
 
-## BREAKING CHANGES
-
--   `RoomState` events changed to use a Map instead of an object, which changes the collection APIs available to access them.
+BREAKING CHANGES
+---
 
-## All Changes
+* `RoomState` events changed to use a Map instead of an object, which changes the collection APIs available to access them.
 
--   Properly support txnId
-    [\#1424](https://github.com/matrix-org/matrix-js-sdk/pull/1424)
--   [BREAKING] Remove deprecated getIdenticonUri
-    [\#1423](https://github.com/matrix-org/matrix-js-sdk/pull/1423)
--   Bump lodash from 4.17.15 to 4.17.19
-    [\#1421](https://github.com/matrix-org/matrix-js-sdk/pull/1421)
--   [BREAKING] Convert RoomState's stored state map to a real map
-    [\#1419](https://github.com/matrix-org/matrix-js-sdk/pull/1419)
+All Changes
+---
 
-# Changes in [7.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0) (2020-07-03)
+ * Properly support txnId
+   [\#1424](https://github.com/matrix-org/matrix-js-sdk/pull/1424)
+ * [BREAKING] Remove deprecated getIdenticonUri
+   [\#1423](https://github.com/matrix-org/matrix-js-sdk/pull/1423)
+ * Bump lodash from 4.17.15 to 4.17.19
+   [\#1421](https://github.com/matrix-org/matrix-js-sdk/pull/1421)
+ * [BREAKING] Convert RoomState's stored state map to a real map
+   [\#1419](https://github.com/matrix-org/matrix-js-sdk/pull/1419)
 
+Changes in [7.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0) (2020-07-03)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.1.0-rc.1...v7.1.0)
 
--   No changes since rc.1
-
-# Changes in [7.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0-rc.1) (2020-07-01)
+* No changes since rc.1
 
+Changes in [7.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.1.0-rc.1) (2020-07-01)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.0.0...v7.1.0-rc.1)
 
--   Ask general crypto callbacks for 4S privkey if operation adapter doesn't
-    have it yet
-    [\#1414](https://github.com/matrix-org/matrix-js-sdk/pull/1414)
--   Fix ICreateClientOpts missing idBaseUrl
-    [\#1413](https://github.com/matrix-org/matrix-js-sdk/pull/1413)
--   Increase max event listeners for rooms
-    [\#1411](https://github.com/matrix-org/matrix-js-sdk/pull/1411)
--   Don't trust keys megolm received from backup for verifying the sender
-    [\#1406](https://github.com/matrix-org/matrix-js-sdk/pull/1406)
--   Raise the last known account data / state event for an update
-    [\#1410](https://github.com/matrix-org/matrix-js-sdk/pull/1410)
--   Isolate encryption bootstrap side-effects
-    [\#1380](https://github.com/matrix-org/matrix-js-sdk/pull/1380)
--   Add method to get current in-flight to-device requests
-    [\#1405](https://github.com/matrix-org/matrix-js-sdk/pull/1405)
-
-# Changes in [7.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0) (2020-06-23)
-
+ * Ask general crypto callbacks for 4S privkey if operation adapter doesn't
+   have it yet
+   [\#1414](https://github.com/matrix-org/matrix-js-sdk/pull/1414)
+ * Fix ICreateClientOpts missing idBaseUrl
+   [\#1413](https://github.com/matrix-org/matrix-js-sdk/pull/1413)
+ * Increase max event listeners for rooms
+   [\#1411](https://github.com/matrix-org/matrix-js-sdk/pull/1411)
+ * Don't trust keys megolm received from backup for verifying the sender
+   [\#1406](https://github.com/matrix-org/matrix-js-sdk/pull/1406)
+ * Raise the last known account data / state event for an update
+   [\#1410](https://github.com/matrix-org/matrix-js-sdk/pull/1410)
+ * Isolate encryption bootstrap side-effects
+   [\#1380](https://github.com/matrix-org/matrix-js-sdk/pull/1380)
+ * Add method to get current in-flight to-device requests
+   [\#1405](https://github.com/matrix-org/matrix-js-sdk/pull/1405)
+
+Changes in [7.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0) (2020-06-23)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v7.0.0-rc.1...v7.0.0)
 
--   No changes since rc.1
-
-# Changes in [7.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0-rc.1) (2020-06-17)
+* No changes since rc.1
 
+Changes in [7.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v7.0.0-rc.1) (2020-06-17)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.2...v7.0.0-rc.1)
 
-## BREAKING CHANGES
-
--   Presence lists were removed from the spec in r0.5.0, and the corresponding methods have now been removed here as well:
-    -   `getPresenceList`
-    -   `inviteToPresenceList`
-    -   `dropFromPresenceList`
-
-## All changes
-
--   Remove support for unspecced device-specific push rules
-    [\#1404](https://github.com/matrix-org/matrix-js-sdk/pull/1404)
--   Use existing session id for fetching flows as to not get a new session
-    [\#1403](https://github.com/matrix-org/matrix-js-sdk/pull/1403)
--   Upgrade deps
-    [\#1400](https://github.com/matrix-org/matrix-js-sdk/pull/1400)
--   Bring back backup key format migration
-    [\#1398](https://github.com/matrix-org/matrix-js-sdk/pull/1398)
--   Fix: more informative error message when we cant find a key to decrypt with
-    [\#1313](https://github.com/matrix-org/matrix-js-sdk/pull/1313)
--   Add js-sdk mechanism for polling client well-known for config
-    [\#1394](https://github.com/matrix-org/matrix-js-sdk/pull/1394)
--   Fix verification request timeouts to match spec
-    [\#1388](https://github.com/matrix-org/matrix-js-sdk/pull/1388)
--   Drop presence list methods
-    [\#1391](https://github.com/matrix-org/matrix-js-sdk/pull/1391)
--   Batch up URL previews to prevent excessive requests
-    [\#1395](https://github.com/matrix-org/matrix-js-sdk/pull/1395)
-
-# Changes in [6.2.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.2) (2020-06-16)
-
+BREAKING CHANGES
+---
+
+ * Presence lists were removed from the spec in r0.5.0, and the corresponding methods have now been removed here as well:
+   * `getPresenceList`
+   * `inviteToPresenceList`
+   * `dropFromPresenceList`
+
+All changes
+---
+
+ * Remove support for unspecced device-specific push rules
+   [\#1404](https://github.com/matrix-org/matrix-js-sdk/pull/1404)
+ * Use existing session id for fetching flows as to not get a new session
+   [\#1403](https://github.com/matrix-org/matrix-js-sdk/pull/1403)
+ * Upgrade deps
+   [\#1400](https://github.com/matrix-org/matrix-js-sdk/pull/1400)
+ * Bring back backup key format migration
+   [\#1398](https://github.com/matrix-org/matrix-js-sdk/pull/1398)
+ * Fix: more informative error message when we cant find a key to decrypt with
+   [\#1313](https://github.com/matrix-org/matrix-js-sdk/pull/1313)
+ * Add js-sdk mechanism for polling client well-known for config
+   [\#1394](https://github.com/matrix-org/matrix-js-sdk/pull/1394)
+ * Fix verification request timeouts to match spec
+   [\#1388](https://github.com/matrix-org/matrix-js-sdk/pull/1388)
+ * Drop presence list methods
+   [\#1391](https://github.com/matrix-org/matrix-js-sdk/pull/1391)
+ * Batch up URL previews to prevent excessive requests
+   [\#1395](https://github.com/matrix-org/matrix-js-sdk/pull/1395)
+
+Changes in [6.2.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.2) (2020-06-16)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.1...v6.2.2)
 
--   Use existing session id for fetching flows as to not get a new session
-    [\#1407](https://github.com/matrix-org/matrix-js-sdk/pull/1407)
-
-# Changes in [6.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.1) (2020-06-05)
+ * Use existing session id for fetching flows as to not get a new session
+   [\#1407](https://github.com/matrix-org/matrix-js-sdk/pull/1407)
 
+Changes in [6.2.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.1) (2020-06-05)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.0...v6.2.1)
 
--   Bring back backup key format migration
-    [\#1399](https://github.com/matrix-org/matrix-js-sdk/pull/1399)
-
-# Changes in [6.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0) (2020-06-04)
+ * Bring back backup key format migration
+   [\#1399](https://github.com/matrix-org/matrix-js-sdk/pull/1399)
 
+Changes in [6.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0) (2020-06-04)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.2.0-rc.1...v6.2.0)
 
--   No changes since rc.1
-
-# Changes in [6.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0-rc.1) (2020-06-02)
+ * No changes since rc.1
 
+Changes in [6.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.2.0-rc.1) (2020-06-02)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.1.0...v6.2.0-rc.1)
 
--   Make auth argument in the register request compliant with r0.6.0
-    [\#1304](https://github.com/matrix-org/matrix-js-sdk/pull/1304)
--   Send the wrong auth params with the right auth params
-    [\#1393](https://github.com/matrix-org/matrix-js-sdk/pull/1393)
--   encrypt cached keys with pickle key
-    [\#1387](https://github.com/matrix-org/matrix-js-sdk/pull/1387)
--   Fix replying to key share requests
-    [\#1385](https://github.com/matrix-org/matrix-js-sdk/pull/1385)
--   Add dist to package.json files so CDNs can serve it
-    [\#1384](https://github.com/matrix-org/matrix-js-sdk/pull/1384)
--   Fix getVersion warning saying undefined room
-    [\#1382](https://github.com/matrix-org/matrix-js-sdk/pull/1382)
--   Combine the two places we processed client-level default push rules
-    [\#1379](https://github.com/matrix-org/matrix-js-sdk/pull/1379)
--   make MAC check robust against unpadded vs padded base64 differences
-    [\#1378](https://github.com/matrix-org/matrix-js-sdk/pull/1378)
--   Remove key backup format migration
-    [\#1375](https://github.com/matrix-org/matrix-js-sdk/pull/1375)
--   Add simple browserify browser-matrix.js tests
-    [\#1241](https://github.com/matrix-org/matrix-js-sdk/pull/1241)
--   support new key agreement method for SAS
-    [\#1376](https://github.com/matrix-org/matrix-js-sdk/pull/1376)
-
-# Changes in [6.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0) (2020-05-19)
-
+ * Make auth argument in the register request compliant with r0.6.0
+   [\#1304](https://github.com/matrix-org/matrix-js-sdk/pull/1304)
+ * Send the wrong auth params with the right auth params
+   [\#1393](https://github.com/matrix-org/matrix-js-sdk/pull/1393)
+ * encrypt cached keys with pickle key
+   [\#1387](https://github.com/matrix-org/matrix-js-sdk/pull/1387)
+ * Fix replying to key share requests
+   [\#1385](https://github.com/matrix-org/matrix-js-sdk/pull/1385)
+ * Add dist to package.json files so CDNs can serve it
+   [\#1384](https://github.com/matrix-org/matrix-js-sdk/pull/1384)
+ * Fix getVersion warning saying undefined room
+   [\#1382](https://github.com/matrix-org/matrix-js-sdk/pull/1382)
+ * Combine the two places we processed client-level default push rules
+   [\#1379](https://github.com/matrix-org/matrix-js-sdk/pull/1379)
+ * make MAC check robust against unpadded vs padded base64 differences
+   [\#1378](https://github.com/matrix-org/matrix-js-sdk/pull/1378)
+ * Remove key backup format migration
+   [\#1375](https://github.com/matrix-org/matrix-js-sdk/pull/1375)
+ * Add simple browserify browser-matrix.js tests
+   [\#1241](https://github.com/matrix-org/matrix-js-sdk/pull/1241)
+ * support new key agreement method for SAS
+   [\#1376](https://github.com/matrix-org/matrix-js-sdk/pull/1376)
+
+Changes in [6.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0) (2020-05-19)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.1.0-rc.1...v6.1.0)
 
--   No changes since rc.1
-
-# Changes in [6.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0-rc.1) (2020-05-14)
+ * No changes since rc.1
 
+Changes in [6.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.1.0-rc.1) (2020-05-14)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.0.0...v6.1.0-rc.1)
 
--   Remove support for asymmetric 4S encryption
-    [\#1373](https://github.com/matrix-org/matrix-js-sdk/pull/1373)
--   Increase timeout for 2nd phase of Olm session creation
-    [\#1367](https://github.com/matrix-org/matrix-js-sdk/pull/1367)
--   Add logging on decryption retries
-    [\#1366](https://github.com/matrix-org/matrix-js-sdk/pull/1366)
--   Emit event when a trusted self-key is stored
-    [\#1364](https://github.com/matrix-org/matrix-js-sdk/pull/1364)
--   Customize error payload for oversized messages
-    [\#1352](https://github.com/matrix-org/matrix-js-sdk/pull/1352)
--   Return null for key backup state when we haven't checked yet
-    [\#1363](https://github.com/matrix-org/matrix-js-sdk/pull/1363)
--   Added a progressCallback for backup key loading
-    [\#1351](https://github.com/matrix-org/matrix-js-sdk/pull/1351)
--   Add initialFetch param to willUpdateDevices / devicesUpdated
-    [\#1360](https://github.com/matrix-org/matrix-js-sdk/pull/1360)
--   Fix race between sending .request and receiving .ready over to_device
-    [\#1359](https://github.com/matrix-org/matrix-js-sdk/pull/1359)
--   Handle race between sending and await next event from other party
-    [\#1357](https://github.com/matrix-org/matrix-js-sdk/pull/1357)
--   Add crypto.willUpdateDevices event and make
-    getStoredDevices/getStoredDevicesForUser synchronous
-    [\#1354](https://github.com/matrix-org/matrix-js-sdk/pull/1354)
--   Fix sender of local echo events in unsigned redactions
-    [\#1350](https://github.com/matrix-org/matrix-js-sdk/pull/1350)
--   Remove redundant key backup setup path
-    [\#1353](https://github.com/matrix-org/matrix-js-sdk/pull/1353)
--   Remove some dead code from \_retryDecryption
-    [\#1349](https://github.com/matrix-org/matrix-js-sdk/pull/1349)
--   Don't send key requests until after sync processing is finished
-    [\#1348](https://github.com/matrix-org/matrix-js-sdk/pull/1348)
--   Prevent attempts to send olm messages to ourselves
-    [\#1346](https://github.com/matrix-org/matrix-js-sdk/pull/1346)
--   Retry account data upload requests
-    [\#1345](https://github.com/matrix-org/matrix-js-sdk/pull/1345)
--   Log first known index with megolm session updates
-    [\#1344](https://github.com/matrix-org/matrix-js-sdk/pull/1344)
--   Prune to_device messages to avoid sending empty messages
-    [\#1343](https://github.com/matrix-org/matrix-js-sdk/pull/1343)
--   Convert bunch of things to TypeScript
-    [\#1335](https://github.com/matrix-org/matrix-js-sdk/pull/1335)
--   Add logging when making new Olm sessions
-    [\#1342](https://github.com/matrix-org/matrix-js-sdk/pull/1342)
--   Fix: handle filter not found
-    [\#1340](https://github.com/matrix-org/matrix-js-sdk/pull/1340)
--   Make getAccountDataFromServer return null if not found
-    [\#1338](https://github.com/matrix-org/matrix-js-sdk/pull/1338)
--   Fix setDefaultKeyId to fail if the request fails
-    [\#1336](https://github.com/matrix-org/matrix-js-sdk/pull/1336)
--   Document setRoomEncryption not modifying room state
-    [\#1328](https://github.com/matrix-org/matrix-js-sdk/pull/1328)
--   Fix: don't do extra /filter request when enabling lazy loading of members
-    [\#1332](https://github.com/matrix-org/matrix-js-sdk/pull/1332)
--   Reject attemptAuth promise if no auth flow found
-    [\#1329](https://github.com/matrix-org/matrix-js-sdk/pull/1329)
--   Fix FilterComponent allowed_values check
-    [\#1327](https://github.com/matrix-org/matrix-js-sdk/pull/1327)
--   Serialise Olm prekey decryptions
-    [\#1326](https://github.com/matrix-org/matrix-js-sdk/pull/1326)
--   Fix: crash when backup key needs fixing from corruption issue
-    [\#1324](https://github.com/matrix-org/matrix-js-sdk/pull/1324)
--   Fix cross-signing/SSSS reset
-    [\#1322](https://github.com/matrix-org/matrix-js-sdk/pull/1322)
--   Implement QR code reciprocate for self-verification with untrusted MSK
-    [\#1320](https://github.com/matrix-org/matrix-js-sdk/pull/1320)
-
-# Changes in [6.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0) (2020-05-05)
-
+ * Remove support for asymmetric 4S encryption
+   [\#1373](https://github.com/matrix-org/matrix-js-sdk/pull/1373)
+ * Increase timeout for 2nd phase of Olm session creation
+   [\#1367](https://github.com/matrix-org/matrix-js-sdk/pull/1367)
+ * Add logging on decryption retries
+   [\#1366](https://github.com/matrix-org/matrix-js-sdk/pull/1366)
+ * Emit event when a trusted self-key is stored
+   [\#1364](https://github.com/matrix-org/matrix-js-sdk/pull/1364)
+ * Customize error payload for oversized messages
+   [\#1352](https://github.com/matrix-org/matrix-js-sdk/pull/1352)
+ * Return null for key backup state when we haven't checked yet
+   [\#1363](https://github.com/matrix-org/matrix-js-sdk/pull/1363)
+ * Added a progressCallback for backup key loading
+   [\#1351](https://github.com/matrix-org/matrix-js-sdk/pull/1351)
+ * Add initialFetch param to willUpdateDevices / devicesUpdated
+   [\#1360](https://github.com/matrix-org/matrix-js-sdk/pull/1360)
+ * Fix race between sending .request and receiving .ready over to_device
+   [\#1359](https://github.com/matrix-org/matrix-js-sdk/pull/1359)
+ * Handle race between sending and await next event from other party
+   [\#1357](https://github.com/matrix-org/matrix-js-sdk/pull/1357)
+ * Add crypto.willUpdateDevices event and make
+   getStoredDevices/getStoredDevicesForUser synchronous
+   [\#1354](https://github.com/matrix-org/matrix-js-sdk/pull/1354)
+ * Fix sender of local echo events in unsigned redactions
+   [\#1350](https://github.com/matrix-org/matrix-js-sdk/pull/1350)
+ * Remove redundant key backup setup path
+   [\#1353](https://github.com/matrix-org/matrix-js-sdk/pull/1353)
+ * Remove some dead code from _retryDecryption
+   [\#1349](https://github.com/matrix-org/matrix-js-sdk/pull/1349)
+ * Don't send key requests until after sync processing is finished
+   [\#1348](https://github.com/matrix-org/matrix-js-sdk/pull/1348)
+ * Prevent attempts to send olm messages to ourselves
+   [\#1346](https://github.com/matrix-org/matrix-js-sdk/pull/1346)
+ * Retry account data upload requests
+   [\#1345](https://github.com/matrix-org/matrix-js-sdk/pull/1345)
+ * Log first known index with megolm session updates
+   [\#1344](https://github.com/matrix-org/matrix-js-sdk/pull/1344)
+ * Prune to_device messages to avoid sending empty messages
+   [\#1343](https://github.com/matrix-org/matrix-js-sdk/pull/1343)
+ * Convert bunch of things to TypeScript
+   [\#1335](https://github.com/matrix-org/matrix-js-sdk/pull/1335)
+ * Add logging when making new Olm sessions
+   [\#1342](https://github.com/matrix-org/matrix-js-sdk/pull/1342)
+ * Fix: handle filter not found
+   [\#1340](https://github.com/matrix-org/matrix-js-sdk/pull/1340)
+ * Make getAccountDataFromServer return null if not found
+   [\#1338](https://github.com/matrix-org/matrix-js-sdk/pull/1338)
+ * Fix setDefaultKeyId to fail if the request fails
+   [\#1336](https://github.com/matrix-org/matrix-js-sdk/pull/1336)
+ * Document setRoomEncryption not modifying room state
+   [\#1328](https://github.com/matrix-org/matrix-js-sdk/pull/1328)
+ * Fix: don't do extra /filter request when enabling lazy loading of members
+   [\#1332](https://github.com/matrix-org/matrix-js-sdk/pull/1332)
+ * Reject attemptAuth promise if no auth flow found
+   [\#1329](https://github.com/matrix-org/matrix-js-sdk/pull/1329)
+ * Fix FilterComponent allowed_values check
+   [\#1327](https://github.com/matrix-org/matrix-js-sdk/pull/1327)
+ * Serialise Olm prekey decryptions
+   [\#1326](https://github.com/matrix-org/matrix-js-sdk/pull/1326)
+ * Fix: crash when backup key needs fixing from corruption issue
+   [\#1324](https://github.com/matrix-org/matrix-js-sdk/pull/1324)
+ * Fix cross-signing/SSSS reset
+   [\#1322](https://github.com/matrix-org/matrix-js-sdk/pull/1322)
+ * Implement QR code reciprocate for self-verification with untrusted MSK
+   [\#1320](https://github.com/matrix-org/matrix-js-sdk/pull/1320)
+
+Changes in [6.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0) (2020-05-05)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.0.0-rc.2...v6.0.0)
 
--   Add progress callback for key backups
-    [\#1368](https://github.com/matrix-org/matrix-js-sdk/pull/1368)
-
-# Changes in [6.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.2) (2020-05-01)
+ * Add progress callback for key backups
+   [\#1368](https://github.com/matrix-org/matrix-js-sdk/pull/1368)
 
+Changes in [6.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.2) (2020-05-01)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v6.0.0-rc.1...v6.0.0-rc.2)
 
--   Emit event when a trusted self-key is stored
-    [\#1365](https://github.com/matrix-org/matrix-js-sdk/pull/1365)
-
-# Changes in [6.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.1) (2020-04-30)
+ * Emit event when a trusted self-key is stored
+   [\#1365](https://github.com/matrix-org/matrix-js-sdk/pull/1365)
 
+Changes in [6.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v6.0.0-rc.1) (2020-04-30)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.4...v6.0.0-rc.1)
 
-## BREAKING CHANGES
+BREAKING CHANGES
+---
 
--   client.getStoredDevicesForUser and client.getStoredDevices are no longer async
+ * client.getStoredDevicesForUser and client.getStoredDevices are no longer async
 
-## All Changes
+All Changes
+---
 
--   Add initialFetch param to willUpdateDevices / devicesUpdated
-    [\#1362](https://github.com/matrix-org/matrix-js-sdk/pull/1362)
--   Fix race between sending .request and receiving .ready over to_device
-    [\#1361](https://github.com/matrix-org/matrix-js-sdk/pull/1361)
--   Handle race between sending and await next event from other party
-    [\#1358](https://github.com/matrix-org/matrix-js-sdk/pull/1358)
--   Add crypto.willUpdateDevices event and make
-    getStoredDevices/getStoredDevicesForUser synchronous
-    [\#1356](https://github.com/matrix-org/matrix-js-sdk/pull/1356)
--   Remove redundant key backup setup path
-    [\#1355](https://github.com/matrix-org/matrix-js-sdk/pull/1355)
-
-# Changes in [5.3.1-rc.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.4) (2020-04-23)
+ * Add initialFetch param to willUpdateDevices / devicesUpdated
+   [\#1362](https://github.com/matrix-org/matrix-js-sdk/pull/1362)
+ * Fix race between sending .request and receiving .ready over to_device
+   [\#1361](https://github.com/matrix-org/matrix-js-sdk/pull/1361)
+ * Handle race between sending and await next event from other party
+   [\#1358](https://github.com/matrix-org/matrix-js-sdk/pull/1358)
+ * Add crypto.willUpdateDevices event and make
+   getStoredDevices/getStoredDevicesForUser synchronous
+   [\#1356](https://github.com/matrix-org/matrix-js-sdk/pull/1356)
+ * Remove redundant key backup setup path
+   [\#1355](https://github.com/matrix-org/matrix-js-sdk/pull/1355)
 
+Changes in [5.3.1-rc.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.4) (2020-04-23)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.3...v5.3.1-rc.4)
 
--   Retry account data upload requests
-    [\#1347](https://github.com/matrix-org/matrix-js-sdk/pull/1347)
--   Fix: handle filter not found
-    [\#1341](https://github.com/matrix-org/matrix-js-sdk/pull/1341)
--   Make getAccountDataFromServer return null if not found
-    [\#1339](https://github.com/matrix-org/matrix-js-sdk/pull/1339)
--   Fix setDefaultKeyId to fail if the request fails
-    [\#1337](https://github.com/matrix-org/matrix-js-sdk/pull/1337)
--   Fix: don't do extra /filter request when enabling lazy loading of members
-    [\#1333](https://github.com/matrix-org/matrix-js-sdk/pull/1333)
--   Reject attemptAuth promise if no auth flow found
-    [\#1331](https://github.com/matrix-org/matrix-js-sdk/pull/1331)
--   Serialise Olm prekey decryptions
-    [\#1330](https://github.com/matrix-org/matrix-js-sdk/pull/1330)
-
-# Changes in [5.3.1-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.3) (2020-04-17)
-
+ * Retry account data upload requests
+   [\#1347](https://github.com/matrix-org/matrix-js-sdk/pull/1347)
+ * Fix: handle filter not found
+   [\#1341](https://github.com/matrix-org/matrix-js-sdk/pull/1341)
+ * Make getAccountDataFromServer return null if not found
+   [\#1339](https://github.com/matrix-org/matrix-js-sdk/pull/1339)
+ * Fix setDefaultKeyId to fail if the request fails
+   [\#1337](https://github.com/matrix-org/matrix-js-sdk/pull/1337)
+ * Fix: don't do extra /filter request when enabling lazy loading of members
+   [\#1333](https://github.com/matrix-org/matrix-js-sdk/pull/1333)
+ * Reject attemptAuth promise if no auth flow found
+   [\#1331](https://github.com/matrix-org/matrix-js-sdk/pull/1331)
+ * Serialise Olm prekey decryptions
+   [\#1330](https://github.com/matrix-org/matrix-js-sdk/pull/1330)
+
+Changes in [5.3.1-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.3) (2020-04-17)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.2...v5.3.1-rc.3)
 
--   Fix cross-signing/SSSS reset
-    [\#1323](https://github.com/matrix-org/matrix-js-sdk/pull/1323)
--   Fix: crash when backup key needs fixing from corruption issue
-    [\#1325](https://github.com/matrix-org/matrix-js-sdk/pull/1325)
-
-# Changes in [5.3.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.2) (2020-04-16)
+ * Fix cross-signing/SSSS reset
+   [\#1323](https://github.com/matrix-org/matrix-js-sdk/pull/1323)
+ * Fix: crash when backup key needs fixing from corruption issue
+   [\#1325](https://github.com/matrix-org/matrix-js-sdk/pull/1325)
 
+Changes in [5.3.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.2) (2020-04-16)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.1-rc.1...v5.3.1-rc.2)
 
--   Implement QR code reciprocate for self-verification with untrusted MSK
-    [\#1321](https://github.com/matrix-org/matrix-js-sdk/pull/1321)
-
-# Changes in [5.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.1) (2020-04-15)
+ * Implement QR code reciprocate for self-verification with untrusted MSK
+   [\#1321](https://github.com/matrix-org/matrix-js-sdk/pull/1321)
 
+Changes in [5.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.1-rc.1) (2020-04-15)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.3.0-rc.1...v5.3.1-rc.1)
 
--   Adapt release script for riot-desktop
-    [\#1319](https://github.com/matrix-org/matrix-js-sdk/pull/1319)
--   Fix: prevent spurious notifications from indexer
-    [\#1318](https://github.com/matrix-org/matrix-js-sdk/pull/1318)
--   Always create our own user object
-    [\#1317](https://github.com/matrix-org/matrix-js-sdk/pull/1317)
--   Fix incorrect backup key format in SSSS
-    [\#1311](https://github.com/matrix-org/matrix-js-sdk/pull/1311)
--   Fix e2ee crash after refreshing after having received a cross-singing key
-    reset
-    [\#1315](https://github.com/matrix-org/matrix-js-sdk/pull/1315)
--   Fix: catch send errors in SAS verifier
-    [\#1314](https://github.com/matrix-org/matrix-js-sdk/pull/1314)
--   Clear cross-signing keys when detecting the keys have changed
-    [\#1312](https://github.com/matrix-org/matrix-js-sdk/pull/1312)
--   Upgrade deps
-    [\#1310](https://github.com/matrix-org/matrix-js-sdk/pull/1310)
-
-# Changes in [5.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.0-rc.1) (2020-04-08)
-
+ * Adapt release script for riot-desktop
+   [\#1319](https://github.com/matrix-org/matrix-js-sdk/pull/1319)
+ * Fix: prevent spurious notifications from indexer
+   [\#1318](https://github.com/matrix-org/matrix-js-sdk/pull/1318)
+ * Always create our own user object
+   [\#1317](https://github.com/matrix-org/matrix-js-sdk/pull/1317)
+ * Fix incorrect backup key format in SSSS
+   [\#1311](https://github.com/matrix-org/matrix-js-sdk/pull/1311)
+ * Fix e2ee crash after refreshing after having received a cross-singing key
+   reset
+   [\#1315](https://github.com/matrix-org/matrix-js-sdk/pull/1315)
+ * Fix: catch send errors in SAS verifier
+   [\#1314](https://github.com/matrix-org/matrix-js-sdk/pull/1314)
+ * Clear cross-signing keys when detecting the keys have changed
+   [\#1312](https://github.com/matrix-org/matrix-js-sdk/pull/1312)
+ * Upgrade deps
+   [\#1310](https://github.com/matrix-org/matrix-js-sdk/pull/1310)
+
+Changes in [5.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.3.0-rc.1) (2020-04-08)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.2.0...v5.3.0-rc.1)
 
--   Store key backup key in cache as Uint8Array
-    [\#1308](https://github.com/matrix-org/matrix-js-sdk/pull/1308)
--   Use the correct request body for the /keys/query endpoint.
-    [\#1307](https://github.com/matrix-org/matrix-js-sdk/pull/1307)
--   Avoid creating two devices on registration
-    [\#1305](https://github.com/matrix-org/matrix-js-sdk/pull/1305)
--   Lower max-warnings to 81
-    [\#1306](https://github.com/matrix-org/matrix-js-sdk/pull/1306)
--   Move key backup key creation before caching
-    [\#1303](https://github.com/matrix-org/matrix-js-sdk/pull/1303)
--   Expose function to force-reset outgoing room key requests
-    [\#1298](https://github.com/matrix-org/matrix-js-sdk/pull/1298)
--   Add isSelfVerification property to VerificationRequest
-    [\#1302](https://github.com/matrix-org/matrix-js-sdk/pull/1302)
--   QR code reciprocation
-    [\#1297](https://github.com/matrix-org/matrix-js-sdk/pull/1297)
--   Add ability to check symmetric SSSS key before we try to use it
-    [\#1294](https://github.com/matrix-org/matrix-js-sdk/pull/1294)
--   Add some debug logging for events stuck to bottom of timeline
-    [\#1296](https://github.com/matrix-org/matrix-js-sdk/pull/1296)
--   Fix: spontanous verification request cancellation under some circumstances
-    [\#1295](https://github.com/matrix-org/matrix-js-sdk/pull/1295)
--   Receive private key for caching from the app layer
-    [\#1293](https://github.com/matrix-org/matrix-js-sdk/pull/1293)
--   Track whether we have verified a user before
-    [\#1292](https://github.com/matrix-org/matrix-js-sdk/pull/1292)
--   Fix: error during tests
-    [\#1222](https://github.com/matrix-org/matrix-js-sdk/pull/1222)
--   Send .done event for to_device verification
-    [\#1288](https://github.com/matrix-org/matrix-js-sdk/pull/1288)
--   Request the key backup key & restore backup
-    [\#1291](https://github.com/matrix-org/matrix-js-sdk/pull/1291)
--   Make screen sharing works on Chrome using getDisplayMedia()
-    [\#1276](https://github.com/matrix-org/matrix-js-sdk/pull/1276)
--   Fix isVerified returning false
-    [\#1289](https://github.com/matrix-org/matrix-js-sdk/pull/1289)
--   Fix: verification gets cancelled when event gets duplicated
-    [\#1286](https://github.com/matrix-org/matrix-js-sdk/pull/1286)
--   Use requestSecret on the client to request secrets
-    [\#1287](https://github.com/matrix-org/matrix-js-sdk/pull/1287)
--   Allow guests to fetch TURN servers
-    [\#1277](https://github.com/matrix-org/matrix-js-sdk/pull/1277)
-
-# Changes in [5.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0) (2020-03-30)
-
+ * Store key backup key in cache as Uint8Array
+   [\#1308](https://github.com/matrix-org/matrix-js-sdk/pull/1308)
+ * Use the correct request body for the /keys/query endpoint.
+   [\#1307](https://github.com/matrix-org/matrix-js-sdk/pull/1307)
+ * Avoid creating two devices on registration
+   [\#1305](https://github.com/matrix-org/matrix-js-sdk/pull/1305)
+ * Lower max-warnings to 81
+   [\#1306](https://github.com/matrix-org/matrix-js-sdk/pull/1306)
+ * Move key backup key creation before caching
+   [\#1303](https://github.com/matrix-org/matrix-js-sdk/pull/1303)
+ * Expose function to force-reset outgoing room key requests
+   [\#1298](https://github.com/matrix-org/matrix-js-sdk/pull/1298)
+ * Add isSelfVerification property to VerificationRequest
+   [\#1302](https://github.com/matrix-org/matrix-js-sdk/pull/1302)
+ * QR code reciprocation
+   [\#1297](https://github.com/matrix-org/matrix-js-sdk/pull/1297)
+ * Add ability to check symmetric SSSS key before we try to use it
+   [\#1294](https://github.com/matrix-org/matrix-js-sdk/pull/1294)
+ * Add some debug logging for events stuck to bottom of timeline
+   [\#1296](https://github.com/matrix-org/matrix-js-sdk/pull/1296)
+ * Fix: spontanous verification request cancellation under some circumstances
+   [\#1295](https://github.com/matrix-org/matrix-js-sdk/pull/1295)
+ * Receive private key for caching from the app layer
+   [\#1293](https://github.com/matrix-org/matrix-js-sdk/pull/1293)
+ * Track whether we have verified a user before
+   [\#1292](https://github.com/matrix-org/matrix-js-sdk/pull/1292)
+ * Fix: error during tests
+   [\#1222](https://github.com/matrix-org/matrix-js-sdk/pull/1222)
+ * Send .done event for to_device verification
+   [\#1288](https://github.com/matrix-org/matrix-js-sdk/pull/1288)
+ * Request the key backup key & restore backup
+   [\#1291](https://github.com/matrix-org/matrix-js-sdk/pull/1291)
+ * Make screen sharing works on Chrome using getDisplayMedia()
+   [\#1276](https://github.com/matrix-org/matrix-js-sdk/pull/1276)
+ * Fix isVerified returning false
+   [\#1289](https://github.com/matrix-org/matrix-js-sdk/pull/1289)
+ * Fix: verification gets cancelled when event gets duplicated
+   [\#1286](https://github.com/matrix-org/matrix-js-sdk/pull/1286)
+ * Use requestSecret on the client to request secrets
+   [\#1287](https://github.com/matrix-org/matrix-js-sdk/pull/1287)
+ * Allow guests to fetch TURN servers
+   [\#1277](https://github.com/matrix-org/matrix-js-sdk/pull/1277)
+
+Changes in [5.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0) (2020-03-30)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.2.0-rc.1...v5.2.0)
 
--   Fix isVerified returning false
-    [\#1290](https://github.com/matrix-org/matrix-js-sdk/pull/1290)
-
-# Changes in [5.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0-rc.1) (2020-03-26)
+ * Fix isVerified returning false
+   [\#1290](https://github.com/matrix-org/matrix-js-sdk/pull/1290)
 
+Changes in [5.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.2.0-rc.1) (2020-03-26)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.1...v5.2.0-rc.1)
 
--   Add a flag for whether cross signing signatures are trusted
-    [\#1285](https://github.com/matrix-org/matrix-js-sdk/pull/1285)
--   Cache user and self signing keys during bootstrap
-    [\#1282](https://github.com/matrix-org/matrix-js-sdk/pull/1282)
--   remove unnecessary promise
-    [\#1283](https://github.com/matrix-org/matrix-js-sdk/pull/1283)
--   Functions to cache session backups key automatically
-    [\#1281](https://github.com/matrix-org/matrix-js-sdk/pull/1281)
--   Add function for checking cross-signing is ready
-    [\#1279](https://github.com/matrix-org/matrix-js-sdk/pull/1279)
--   Use symmetric encryption for SSSS
-    [\#1228](https://github.com/matrix-org/matrix-js-sdk/pull/1228)
--   Migrate SSSS to use symmetric algorithm
-    [\#1238](https://github.com/matrix-org/matrix-js-sdk/pull/1238)
--   Migration to symmetric SSSS
-    [\#1272](https://github.com/matrix-org/matrix-js-sdk/pull/1272)
--   Reduce number of one-time-key requests
-    [\#1280](https://github.com/matrix-org/matrix-js-sdk/pull/1280)
--   Fix: assume the requested method is supported by other party with to_device
-    [\#1275](https://github.com/matrix-org/matrix-js-sdk/pull/1275)
--   Use checkDeviceTrust when computing untrusted devices
-    [\#1278](https://github.com/matrix-org/matrix-js-sdk/pull/1278)
--   Add a store for backup keys
-    [\#1271](https://github.com/matrix-org/matrix-js-sdk/pull/1271)
--   Upload only new device signature of master key
-    [\#1268](https://github.com/matrix-org/matrix-js-sdk/pull/1268)
--   Expose prepareToEncrypt in the client API
-    [\#1270](https://github.com/matrix-org/matrix-js-sdk/pull/1270)
--   Don't kill the whole device download if one device gives an error
-    [\#1269](https://github.com/matrix-org/matrix-js-sdk/pull/1269)
--   Handle racing .start event during self verification
-    [\#1267](https://github.com/matrix-org/matrix-js-sdk/pull/1267)
--   A crypto.keySignatureUploadFailure event reported the wrong source
-    [\#1266](https://github.com/matrix-org/matrix-js-sdk/pull/1266)
--   Fix editing of unsent messages by waiting for actual event id
-    [\#1263](https://github.com/matrix-org/matrix-js-sdk/pull/1263)
--   Fix: ensureOlmSessionsForDevices parameter format
-    [\#1264](https://github.com/matrix-org/matrix-js-sdk/pull/1264)
--   Remove stuff that yarn install doesn't think we need
-    [\#1261](https://github.com/matrix-org/matrix-js-sdk/pull/1261)
--   Fix: prevent error being thrown during sync in some cases
-    [\#1258](https://github.com/matrix-org/matrix-js-sdk/pull/1258)
--   Force `is_verified` for key backups to bool and fix computation
-    [\#1259](https://github.com/matrix-org/matrix-js-sdk/pull/1259)
--   Add a method for legacy single device verification, returning a verification
-    request
-    [\#1257](https://github.com/matrix-org/matrix-js-sdk/pull/1257)
--   yarn upgrade
-    [\#1256](https://github.com/matrix-org/matrix-js-sdk/pull/1256)
-
-# Changes in [5.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1) (2020-03-17)
-
+ * Add a flag for whether cross signing signatures are trusted
+   [\#1285](https://github.com/matrix-org/matrix-js-sdk/pull/1285)
+ * Cache user and self signing keys during bootstrap
+   [\#1282](https://github.com/matrix-org/matrix-js-sdk/pull/1282)
+ * remove unnecessary promise
+   [\#1283](https://github.com/matrix-org/matrix-js-sdk/pull/1283)
+ * Functions to cache session backups key automatically
+   [\#1281](https://github.com/matrix-org/matrix-js-sdk/pull/1281)
+ * Add function for checking cross-signing is ready
+   [\#1279](https://github.com/matrix-org/matrix-js-sdk/pull/1279)
+ * Use symmetric encryption for SSSS
+   [\#1228](https://github.com/matrix-org/matrix-js-sdk/pull/1228)
+ * Migrate SSSS to use symmetric algorithm
+   [\#1238](https://github.com/matrix-org/matrix-js-sdk/pull/1238)
+ * Migration to symmetric SSSS
+   [\#1272](https://github.com/matrix-org/matrix-js-sdk/pull/1272)
+ * Reduce number of one-time-key requests
+   [\#1280](https://github.com/matrix-org/matrix-js-sdk/pull/1280)
+ * Fix: assume the requested method is supported by other party with to_device
+   [\#1275](https://github.com/matrix-org/matrix-js-sdk/pull/1275)
+ * Use checkDeviceTrust when computing untrusted devices
+   [\#1278](https://github.com/matrix-org/matrix-js-sdk/pull/1278)
+ * Add a store for backup keys
+   [\#1271](https://github.com/matrix-org/matrix-js-sdk/pull/1271)
+ * Upload only new device signature of master key
+   [\#1268](https://github.com/matrix-org/matrix-js-sdk/pull/1268)
+ * Expose prepareToEncrypt in the client API
+   [\#1270](https://github.com/matrix-org/matrix-js-sdk/pull/1270)
+ * Don't kill the whole device download if one device gives an error
+   [\#1269](https://github.com/matrix-org/matrix-js-sdk/pull/1269)
+ * Handle racing .start event during self verification
+   [\#1267](https://github.com/matrix-org/matrix-js-sdk/pull/1267)
+ * A crypto.keySignatureUploadFailure event reported the wrong source
+   [\#1266](https://github.com/matrix-org/matrix-js-sdk/pull/1266)
+ * Fix editing of unsent messages by waiting for actual event id
+   [\#1263](https://github.com/matrix-org/matrix-js-sdk/pull/1263)
+ * Fix: ensureOlmSessionsForDevices parameter format
+   [\#1264](https://github.com/matrix-org/matrix-js-sdk/pull/1264)
+ * Remove stuff that yarn install doesn't think we need
+   [\#1261](https://github.com/matrix-org/matrix-js-sdk/pull/1261)
+ * Fix: prevent error being thrown during sync in some cases
+   [\#1258](https://github.com/matrix-org/matrix-js-sdk/pull/1258)
+ * Force `is_verified` for key backups to bool and fix computation
+   [\#1259](https://github.com/matrix-org/matrix-js-sdk/pull/1259)
+ * Add a method for legacy single device verification, returning a verification
+   request
+   [\#1257](https://github.com/matrix-org/matrix-js-sdk/pull/1257)
+ * yarn upgrade
+   [\#1256](https://github.com/matrix-org/matrix-js-sdk/pull/1256)
+
+Changes in [5.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1) (2020-03-17)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.1-rc.1...v5.1.1)
 
--   Fix: ensureOlmSessionsForDevices parameter format
-    [\#1265](https://github.com/matrix-org/matrix-js-sdk/pull/1265)
--   Fix: prevent error being thrown during sync in some cases
-    [\#1262](https://github.com/matrix-org/matrix-js-sdk/pull/1262)
--   Force `is_verified` for key backups to bool and fix computation
-    [\#1260](https://github.com/matrix-org/matrix-js-sdk/pull/1260)
-
-# Changes in [5.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1-rc.1) (2020-03-11)
+ * Fix: ensureOlmSessionsForDevices parameter format
+   [\#1265](https://github.com/matrix-org/matrix-js-sdk/pull/1265)
+ * Fix: prevent error being thrown during sync in some cases
+   [\#1262](https://github.com/matrix-org/matrix-js-sdk/pull/1262)
+ * Force `is_verified` for key backups to bool and fix computation
+   [\#1260](https://github.com/matrix-org/matrix-js-sdk/pull/1260)
 
+Changes in [5.1.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.1-rc.1) (2020-03-11)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.0...v5.1.1-rc.1)
 
--   refactor megolm encryption to improve perceived speed
-    [\#1252](https://github.com/matrix-org/matrix-js-sdk/pull/1252)
--   Remove v1 identity server fallbacks
-    [\#1253](https://github.com/matrix-org/matrix-js-sdk/pull/1253)
--   Use alt_aliases instead of local ones for room names
-    [\#1251](https://github.com/matrix-org/matrix-js-sdk/pull/1251)
--   Upload cross-signing key signatures in the background
-    [\#1250](https://github.com/matrix-org/matrix-js-sdk/pull/1250)
--   Fix secret sharing names to match spec
-    [\#1249](https://github.com/matrix-org/matrix-js-sdk/pull/1249)
--   Cleanup: remove crypto.verification.start event
-    [\#1248](https://github.com/matrix-org/matrix-js-sdk/pull/1248)
--   Fix regression in key backup request params
-    [\#1246](https://github.com/matrix-org/matrix-js-sdk/pull/1246)
--   Use cross-signing trust to mark backups verified
-    [\#1244](https://github.com/matrix-org/matrix-js-sdk/pull/1244)
--   Check both cross-signing and local trust for key sharing
-    [\#1243](https://github.com/matrix-org/matrix-js-sdk/pull/1243)
--   Fixed up tests to match new way that crypto stores are created
-    [\#1242](https://github.com/matrix-org/matrix-js-sdk/pull/1242)
--   Store USK and SSK locally
-    [\#1235](https://github.com/matrix-org/matrix-js-sdk/pull/1235)
--   Use unpadded base64 for QR code secrets
-    [\#1236](https://github.com/matrix-org/matrix-js-sdk/pull/1236)
--   Don't require .done event for finishing self-verification
-    [\#1239](https://github.com/matrix-org/matrix-js-sdk/pull/1239)
--   Don't cancel as 3rd party in verification request
-    [\#1237](https://github.com/matrix-org/matrix-js-sdk/pull/1237)
--   Verification: log when switching start event
-    [\#1234](https://github.com/matrix-org/matrix-js-sdk/pull/1234)
--   Perform crypto store operations directly after transaction
-    [\#1233](https://github.com/matrix-org/matrix-js-sdk/pull/1233)
--   More verification request logging
-    [\#1232](https://github.com/matrix-org/matrix-js-sdk/pull/1232)
--   Upgrade deps
-    [\#1231](https://github.com/matrix-org/matrix-js-sdk/pull/1231)
-
-# Changes in [5.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0) (2020-03-02)
-
+ * refactor megolm encryption to improve perceived speed
+   [\#1252](https://github.com/matrix-org/matrix-js-sdk/pull/1252)
+ * Remove v1 identity server fallbacks
+   [\#1253](https://github.com/matrix-org/matrix-js-sdk/pull/1253)
+ * Use alt_aliases instead of local ones for room names
+   [\#1251](https://github.com/matrix-org/matrix-js-sdk/pull/1251)
+ * Upload cross-signing key signatures in the background
+   [\#1250](https://github.com/matrix-org/matrix-js-sdk/pull/1250)
+ * Fix secret sharing names to match spec
+   [\#1249](https://github.com/matrix-org/matrix-js-sdk/pull/1249)
+ * Cleanup: remove crypto.verification.start event
+   [\#1248](https://github.com/matrix-org/matrix-js-sdk/pull/1248)
+ * Fix regression in key backup request params
+   [\#1246](https://github.com/matrix-org/matrix-js-sdk/pull/1246)
+ * Use cross-signing trust to mark backups verified
+   [\#1244](https://github.com/matrix-org/matrix-js-sdk/pull/1244)
+ * Check both cross-signing and local trust for key sharing
+   [\#1243](https://github.com/matrix-org/matrix-js-sdk/pull/1243)
+ * Fixed up tests to match new way that crypto stores are created
+   [\#1242](https://github.com/matrix-org/matrix-js-sdk/pull/1242)
+ * Store USK and SSK locally
+   [\#1235](https://github.com/matrix-org/matrix-js-sdk/pull/1235)
+ * Use unpadded base64 for QR code secrets
+   [\#1236](https://github.com/matrix-org/matrix-js-sdk/pull/1236)
+ * Don't require .done event for finishing self-verification
+   [\#1239](https://github.com/matrix-org/matrix-js-sdk/pull/1239)
+ * Don't cancel as 3rd party in verification request
+   [\#1237](https://github.com/matrix-org/matrix-js-sdk/pull/1237)
+ * Verification: log when switching start event
+   [\#1234](https://github.com/matrix-org/matrix-js-sdk/pull/1234)
+ * Perform crypto store operations directly after transaction
+   [\#1233](https://github.com/matrix-org/matrix-js-sdk/pull/1233)
+ * More verification request logging
+   [\#1232](https://github.com/matrix-org/matrix-js-sdk/pull/1232)
+ * Upgrade deps
+   [\#1231](https://github.com/matrix-org/matrix-js-sdk/pull/1231)
+
+Changes in [5.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0) (2020-03-02)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.1.0-rc.1...v5.1.0)
 
--   No changes since rc.1
-
-# Changes in [5.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0-rc.1) (2020-02-26)
+ * No changes since rc.1
 
+Changes in [5.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.1.0-rc.1) (2020-02-26)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.0.1...v5.1.0-rc.1)
 
--   Add latest dist-tag for releases
-    [\#1230](https://github.com/matrix-org/matrix-js-sdk/pull/1230)
--   Add room method for alt_aliases
-    [\#1225](https://github.com/matrix-org/matrix-js-sdk/pull/1225)
--   Remove buildkite pipeline
-    [\#1227](https://github.com/matrix-org/matrix-js-sdk/pull/1227)
--   don't assume verify has been called when receiving a cancellation in
-    verifier
-    [\#1226](https://github.com/matrix-org/matrix-js-sdk/pull/1226)
--   Reduce secret size for new binary packing
-    [\#1221](https://github.com/matrix-org/matrix-js-sdk/pull/1221)
--   misc rageshake fixes
-    [\#1223](https://github.com/matrix-org/matrix-js-sdk/pull/1223)
--   Fix cancelled historical requests not appearing as cancelled
-    [\#1220](https://github.com/matrix-org/matrix-js-sdk/pull/1220)
--   Fix renaming error that broke QR code verification
-    [\#1217](https://github.com/matrix-org/matrix-js-sdk/pull/1217)
-
-# Changes in [5.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.1) (2020-02-19)
-
+ * Add latest dist-tag for releases
+   [\#1230](https://github.com/matrix-org/matrix-js-sdk/pull/1230)
+ * Add room method for alt_aliases
+   [\#1225](https://github.com/matrix-org/matrix-js-sdk/pull/1225)
+ * Remove buildkite pipeline
+   [\#1227](https://github.com/matrix-org/matrix-js-sdk/pull/1227)
+ * don't assume verify has been called when receiving a cancellation in
+   verifier
+   [\#1226](https://github.com/matrix-org/matrix-js-sdk/pull/1226)
+ * Reduce secret size for new binary packing
+   [\#1221](https://github.com/matrix-org/matrix-js-sdk/pull/1221)
+ * misc rageshake fixes
+   [\#1223](https://github.com/matrix-org/matrix-js-sdk/pull/1223)
+ * Fix cancelled historical requests not appearing as cancelled
+   [\#1220](https://github.com/matrix-org/matrix-js-sdk/pull/1220)
+ * Fix renaming error that broke QR code verification
+   [\#1217](https://github.com/matrix-org/matrix-js-sdk/pull/1217)
+
+Changes in [5.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.1) (2020-02-19)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.0.0...v5.0.1)
 
--   add method for new /aliases endpoint
-    [\#1219](https://github.com/matrix-org/matrix-js-sdk/pull/1219)
--   method for checking if other party supports verification method
-    [\#1213](https://github.com/matrix-org/matrix-js-sdk/pull/1213)
--   add local echo state for accepting or declining a verif req
-    [\#1210](https://github.com/matrix-org/matrix-js-sdk/pull/1210)
--   make logging compatible with rageshakes
-    [\#1214](https://github.com/matrix-org/matrix-js-sdk/pull/1214)
--   Find existing requests when starting a new verification request
-    [\#1209](https://github.com/matrix-org/matrix-js-sdk/pull/1209)
--   log MAC calculation during SAS
-    [\#1211](https://github.com/matrix-org/matrix-js-sdk/pull/1211)
-
-# Changes in [5.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0) (2020-02-17)
-
+ * add method for new /aliases endpoint
+   [\#1219](https://github.com/matrix-org/matrix-js-sdk/pull/1219)
+ * method for checking if other party supports verification method
+   [\#1213](https://github.com/matrix-org/matrix-js-sdk/pull/1213)
+ * add local echo state for accepting or declining a verif req
+   [\#1210](https://github.com/matrix-org/matrix-js-sdk/pull/1210)
+ * make logging compatible with rageshakes
+   [\#1214](https://github.com/matrix-org/matrix-js-sdk/pull/1214)
+ * Find existing requests when starting a new verification request
+   [\#1209](https://github.com/matrix-org/matrix-js-sdk/pull/1209)
+ * log MAC calculation during SAS
+   [\#1211](https://github.com/matrix-org/matrix-js-sdk/pull/1211)
+
+Changes in [5.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0) (2020-02-17)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v5.0.0-rc.1...v5.0.0)
 
--   No changes since rc.1
-
-# Changes in [5.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0-rc.1) (2020-02-13)
+ * No changes since rc.1
 
+Changes in [5.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v5.0.0-rc.1) (2020-02-13)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v4.0.0...v5.0.0-rc.1)
 
-## BREAKING CHANGES
-
--   The verification methods API has removed an argument ([\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206))
-
-## All Changes
-
--   Remove methods argument to verification
-    [\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206)
--   don't do a dynamic import of request
-    [\#1207](https://github.com/matrix-org/matrix-js-sdk/pull/1207)
--   QR self-verification fixes
-    [\#1201](https://github.com/matrix-org/matrix-js-sdk/pull/1201)
--   Log every verification event
-    [\#1204](https://github.com/matrix-org/matrix-js-sdk/pull/1204)
--   dont require .done event from other party
-    [\#1203](https://github.com/matrix-org/matrix-js-sdk/pull/1203)
--   New option to fully reset Secret Storage keys in boostrapSecretStorage
-    [\#1202](https://github.com/matrix-org/matrix-js-sdk/pull/1202)
--   Add function to estimate target device for a VerificationRequest
-    [\#1190](https://github.com/matrix-org/matrix-js-sdk/pull/1190)
--   pass ssss item name to callback so we can differentiate UI on it
-    [\#1200](https://github.com/matrix-org/matrix-js-sdk/pull/1200)
--   add export/import of Olm devices
-    [\#1167](https://github.com/matrix-org/matrix-js-sdk/pull/1167)
--   Convert utils.js -> utils.ts
-    [\#1199](https://github.com/matrix-org/matrix-js-sdk/pull/1199)
--   Don't sign ourselves as a user
-    [\#1197](https://github.com/matrix-org/matrix-js-sdk/pull/1197)
--   Add a bunch of logging to verification
-    [\#1196](https://github.com/matrix-org/matrix-js-sdk/pull/1196)
--   Fix: always return a valid string from InRoomChannel.getEventType
-    [\#1198](https://github.com/matrix-org/matrix-js-sdk/pull/1198)
--   add logging when a request is being cancelled
-    [\#1195](https://github.com/matrix-org/matrix-js-sdk/pull/1195)
--   Don't explode verification validation if we don't have an event type
-    [\#1194](https://github.com/matrix-org/matrix-js-sdk/pull/1194)
--   Fix: verification request appearing for users that are not the receiver or
-    sender if they are in room
-    [\#1193](https://github.com/matrix-org/matrix-js-sdk/pull/1193)
--   Fix getting secrets encoded with passthrough keys
-    [\#1192](https://github.com/matrix-org/matrix-js-sdk/pull/1192)
--   Update QR code handling for new spec
-    [\#1175](https://github.com/matrix-org/matrix-js-sdk/pull/1175)
--   Don't add ephemeral events to timeline when peeking
-    [\#1188](https://github.com/matrix-org/matrix-js-sdk/pull/1188)
--   Fix typo
-    [\#1189](https://github.com/matrix-org/matrix-js-sdk/pull/1189)
--   Verification: resolve race between .start events from both parties
-    [\#1187](https://github.com/matrix-org/matrix-js-sdk/pull/1187)
--   Add option to bootstrap to start new key backup
-    [\#1184](https://github.com/matrix-org/matrix-js-sdk/pull/1184)
--   Add a bunch of null guards to feature checks
-    [\#1182](https://github.com/matrix-org/matrix-js-sdk/pull/1182)
--   docs: fix MatrixClient reference
-    [\#1183](https://github.com/matrix-org/matrix-js-sdk/pull/1183)
--   Add helper to obtain the cancellation code for a verification request
-    [\#1180](https://github.com/matrix-org/matrix-js-sdk/pull/1180)
--   Publish pre-releases as a separate tag on npm
-    [\#1178](https://github.com/matrix-org/matrix-js-sdk/pull/1178)
--   Fix support for passthrough keys
-    [\#1177](https://github.com/matrix-org/matrix-js-sdk/pull/1177)
--   Trust our own cross-signing keys if we verify them with another device
-    [\#1174](https://github.com/matrix-org/matrix-js-sdk/pull/1174)
--   Ensure cross-signing keys are downloaded when checking trust
-    [\#1176](https://github.com/matrix-org/matrix-js-sdk/pull/1176)
--   Don't log verification validation errors for normal messages
-    [\#1172](https://github.com/matrix-org/matrix-js-sdk/pull/1172)
--   Fix bootstrap cleanup
-    [\#1173](https://github.com/matrix-org/matrix-js-sdk/pull/1173)
--   QR code verification
-    [\#1155](https://github.com/matrix-org/matrix-js-sdk/pull/1155)
--   expose deviceId prop on device channel
-    [\#1171](https://github.com/matrix-org/matrix-js-sdk/pull/1171)
--   Move & upgrade babel runtime into dependencies (like it wants)
-    [\#1169](https://github.com/matrix-org/matrix-js-sdk/pull/1169)
--   Add unit tests for verifying your own device, remove .event property on
-    verification request
-    [\#1166](https://github.com/matrix-org/matrix-js-sdk/pull/1166)
--   For dm-verification, also consider events sent by other devices of same user
-    as "our" events
-    [\#1163](https://github.com/matrix-org/matrix-js-sdk/pull/1163)
--   Add a prepare script
-    [\#1161](https://github.com/matrix-org/matrix-js-sdk/pull/1161)
--   Remove :deviceId from /keys/upload/:deviceId as not spec-compliant
-    [\#1162](https://github.com/matrix-org/matrix-js-sdk/pull/1162)
--   Refactor and expose some logic publicly for the TimelineWindow class.
-    [\#1159](https://github.com/matrix-org/matrix-js-sdk/pull/1159)
--   Allow a device key upload request without auth
-    [\#1158](https://github.com/matrix-org/matrix-js-sdk/pull/1158)
--   Support for .ready verification event (MSC2366) & other things
-    [\#1140](https://github.com/matrix-org/matrix-js-sdk/pull/1140)
-
-# Changes in [4.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0) (2020-01-27)
-
+BREAKING CHANGES
+---
+
+ * The verification methods API has removed an argument ([\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206))
+
+All Changes
+---
+
+ * Remove methods argument to verification
+   [\#1206](https://github.com/matrix-org/matrix-js-sdk/pull/1206)
+ * don't do a dynamic import of request
+   [\#1207](https://github.com/matrix-org/matrix-js-sdk/pull/1207)
+ * QR self-verification fixes
+   [\#1201](https://github.com/matrix-org/matrix-js-sdk/pull/1201)
+ * Log every verification event
+   [\#1204](https://github.com/matrix-org/matrix-js-sdk/pull/1204)
+ * dont require .done event from other party
+   [\#1203](https://github.com/matrix-org/matrix-js-sdk/pull/1203)
+ * New option to fully reset Secret Storage keys in boostrapSecretStorage
+   [\#1202](https://github.com/matrix-org/matrix-js-sdk/pull/1202)
+ * Add function to estimate target device for a VerificationRequest
+   [\#1190](https://github.com/matrix-org/matrix-js-sdk/pull/1190)
+ * pass ssss item name to callback so we can differentiate UI on it
+   [\#1200](https://github.com/matrix-org/matrix-js-sdk/pull/1200)
+ * add export/import of Olm devices
+   [\#1167](https://github.com/matrix-org/matrix-js-sdk/pull/1167)
+ * Convert utils.js -> utils.ts
+   [\#1199](https://github.com/matrix-org/matrix-js-sdk/pull/1199)
+ * Don't sign ourselves as a user
+   [\#1197](https://github.com/matrix-org/matrix-js-sdk/pull/1197)
+ * Add a bunch of logging to verification
+   [\#1196](https://github.com/matrix-org/matrix-js-sdk/pull/1196)
+ * Fix: always return a valid string from InRoomChannel.getEventType
+   [\#1198](https://github.com/matrix-org/matrix-js-sdk/pull/1198)
+ * add logging when a request is being cancelled
+   [\#1195](https://github.com/matrix-org/matrix-js-sdk/pull/1195)
+ * Don't explode verification validation if we don't have an event type
+   [\#1194](https://github.com/matrix-org/matrix-js-sdk/pull/1194)
+ * Fix: verification request appearing for users that are not the receiver or
+   sender if they are in room
+   [\#1193](https://github.com/matrix-org/matrix-js-sdk/pull/1193)
+ * Fix getting secrets encoded with passthrough keys
+   [\#1192](https://github.com/matrix-org/matrix-js-sdk/pull/1192)
+ * Update QR code handling for new spec
+   [\#1175](https://github.com/matrix-org/matrix-js-sdk/pull/1175)
+ * Don't add ephemeral events to timeline when peeking
+   [\#1188](https://github.com/matrix-org/matrix-js-sdk/pull/1188)
+ * Fix typo
+   [\#1189](https://github.com/matrix-org/matrix-js-sdk/pull/1189)
+ * Verification: resolve race between .start events from both parties
+   [\#1187](https://github.com/matrix-org/matrix-js-sdk/pull/1187)
+ * Add option to bootstrap to start new key backup
+   [\#1184](https://github.com/matrix-org/matrix-js-sdk/pull/1184)
+ * Add a bunch of null guards to feature checks
+   [\#1182](https://github.com/matrix-org/matrix-js-sdk/pull/1182)
+ * docs: fix MatrixClient reference
+   [\#1183](https://github.com/matrix-org/matrix-js-sdk/pull/1183)
+ * Add helper to obtain the cancellation code for a verification request
+   [\#1180](https://github.com/matrix-org/matrix-js-sdk/pull/1180)
+ * Publish pre-releases as a separate tag on npm
+   [\#1178](https://github.com/matrix-org/matrix-js-sdk/pull/1178)
+ * Fix support for passthrough keys
+   [\#1177](https://github.com/matrix-org/matrix-js-sdk/pull/1177)
+ * Trust our own cross-signing keys if we verify them with another device
+   [\#1174](https://github.com/matrix-org/matrix-js-sdk/pull/1174)
+ * Ensure cross-signing keys are downloaded when checking trust
+   [\#1176](https://github.com/matrix-org/matrix-js-sdk/pull/1176)
+ * Don't log verification validation errors for normal messages
+   [\#1172](https://github.com/matrix-org/matrix-js-sdk/pull/1172)
+ * Fix bootstrap cleanup
+   [\#1173](https://github.com/matrix-org/matrix-js-sdk/pull/1173)
+ * QR code verification
+   [\#1155](https://github.com/matrix-org/matrix-js-sdk/pull/1155)
+ * expose deviceId prop on device channel
+   [\#1171](https://github.com/matrix-org/matrix-js-sdk/pull/1171)
+ * Move & upgrade babel runtime into dependencies (like it wants)
+   [\#1169](https://github.com/matrix-org/matrix-js-sdk/pull/1169)
+ * Add unit tests for verifying your own device, remove .event property on
+   verification request
+   [\#1166](https://github.com/matrix-org/matrix-js-sdk/pull/1166)
+ * For dm-verification, also consider events sent by other devices of same user
+   as "our" events
+   [\#1163](https://github.com/matrix-org/matrix-js-sdk/pull/1163)
+ * Add a prepare script
+   [\#1161](https://github.com/matrix-org/matrix-js-sdk/pull/1161)
+ * Remove :deviceId from /keys/upload/:deviceId as not spec-compliant
+   [\#1162](https://github.com/matrix-org/matrix-js-sdk/pull/1162)
+ * Refactor and expose some logic publicly for the TimelineWindow class.
+   [\#1159](https://github.com/matrix-org/matrix-js-sdk/pull/1159)
+ * Allow a device key upload request without auth
+   [\#1158](https://github.com/matrix-org/matrix-js-sdk/pull/1158)
+ * Support for .ready verification event (MSC2366) & other things
+   [\#1140](https://github.com/matrix-org/matrix-js-sdk/pull/1140)
+
+Changes in [4.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0) (2020-01-27)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v4.0.0-rc.1...v4.0.0)
 
--   Move & upgrade babel runtime into dependencies (like it wants)
-    [\#1170](https://github.com/matrix-org/matrix-js-sdk/pull/1170)
--   Add a prepare script
-    [\#1164](https://github.com/matrix-org/matrix-js-sdk/pull/1164)
-
-# Changes in [4.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0-rc.1) (2020-01-20)
+ * Move & upgrade babel runtime into dependencies (like it wants)
+   [\#1170](https://github.com/matrix-org/matrix-js-sdk/pull/1170)
+ * Add a prepare script
+   [\#1164](https://github.com/matrix-org/matrix-js-sdk/pull/1164)
 
+Changes in [4.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v4.0.0-rc.1) (2020-01-20)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v3.0.0...v4.0.0-rc.1)
 
-# BREAKING CHANGES
-
--   The js-sdk node module now exports ES6 rather than ES5. If you
-    wish to supports target that aren't compatible with ES6, you
-    will need to transpile the js-sdk to a suitable dialect.
-
-# All Changes
-
--   Convert secret storage to new account data API
-    [\#1154](https://github.com/matrix-org/matrix-js-sdk/pull/1154)
--   Add v5 as a safe room version
-    [\#1157](https://github.com/matrix-org/matrix-js-sdk/pull/1157)
--   Add API to get account data from server
-    [\#1153](https://github.com/matrix-org/matrix-js-sdk/pull/1153)
--   Fix sourcemaps by refactoring the build system
-    [\#1151](https://github.com/matrix-org/matrix-js-sdk/pull/1151)
--   record, report, and notify about olm errors
-    [\#1146](https://github.com/matrix-org/matrix-js-sdk/pull/1146)
--   Send device messages for the same user in same API call.
-    [\#1148](https://github.com/matrix-org/matrix-js-sdk/pull/1148)
--   Add an option to ignore unverified devices
-    [\#1150](https://github.com/matrix-org/matrix-js-sdk/pull/1150)
--   Sign key backup with cross-signing key on upgrade
-    [\#1144](https://github.com/matrix-org/matrix-js-sdk/pull/1144)
--   Emoji verification: Change name of 🔒 to lock
-    [\#1145](https://github.com/matrix-org/matrix-js-sdk/pull/1145)
--   use a separate object for each encrypted content
-    [\#1147](https://github.com/matrix-org/matrix-js-sdk/pull/1147)
--   Sourcemaps: develop -> feature branch
-    [\#1143](https://github.com/matrix-org/matrix-js-sdk/pull/1143)
--   Use a safer import/export scheme for the ContentRepo utilities
-    [\#1134](https://github.com/matrix-org/matrix-js-sdk/pull/1134)
--   Fix error handling in decryptGroupMessage
-    [\#1142](https://github.com/matrix-org/matrix-js-sdk/pull/1142)
--   Add additional properties to package.json for riot-web's webpack
-    [\#1131](https://github.com/matrix-org/matrix-js-sdk/pull/1131)
--   Fix import for indexeddb crypto store
-    [\#1133](https://github.com/matrix-org/matrix-js-sdk/pull/1133)
--   Use the right request when creating clients
-    [\#1132](https://github.com/matrix-org/matrix-js-sdk/pull/1132)
--   Target NodeJS 10, minified browser bundle, and other publishing/package
-    things
-    [\#1127](https://github.com/matrix-org/matrix-js-sdk/pull/1127)
--   Re-focus sourcemap generation
-    [\#1126](https://github.com/matrix-org/matrix-js-sdk/pull/1126)
--   Remove ancient polyfill for prototype inheritance
-    [\#1125](https://github.com/matrix-org/matrix-js-sdk/pull/1125)
--   Remove "source-map-support" from tests because it makes sourcemaps worse
-    [\#1124](https://github.com/matrix-org/matrix-js-sdk/pull/1124)
--   Remove ancient "use strict" annotations
-    [\#1123](https://github.com/matrix-org/matrix-js-sdk/pull/1123)
--   Use ES6 imports/exports instead of older CommonJS ones
-    [\#1122](https://github.com/matrix-org/matrix-js-sdk/pull/1122)
--   [BREAKING] Refactor the entire build process
-    [\#1113](https://github.com/matrix-org/matrix-js-sdk/pull/1113)
-
-# Changes in [3.42.2-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.42.2-rc.3) (2022-04-08)
+BREAKING CHANGES
+================
+ * The js-sdk node module now exports ES6 rather than ES5. If you
+   wish to supports target that aren't compatible with ES6, you
+   will need to transpile the js-sdk to a suitable dialect.
+
+All Changes
+===========
+ * Convert secret storage to new account data API
+   [\#1154](https://github.com/matrix-org/matrix-js-sdk/pull/1154)
+ * Add v5 as a safe room version
+   [\#1157](https://github.com/matrix-org/matrix-js-sdk/pull/1157)
+ * Add API to get account data from server
+   [\#1153](https://github.com/matrix-org/matrix-js-sdk/pull/1153)
+ * Fix sourcemaps by refactoring the build system
+   [\#1151](https://github.com/matrix-org/matrix-js-sdk/pull/1151)
+ * record, report, and notify about olm errors
+   [\#1146](https://github.com/matrix-org/matrix-js-sdk/pull/1146)
+ * Send device messages for the same user in same API call.
+   [\#1148](https://github.com/matrix-org/matrix-js-sdk/pull/1148)
+ * Add an option to ignore unverified devices
+   [\#1150](https://github.com/matrix-org/matrix-js-sdk/pull/1150)
+ * Sign key backup with cross-signing key on upgrade
+   [\#1144](https://github.com/matrix-org/matrix-js-sdk/pull/1144)
+ * Emoji verification: Change name of 🔒 to lock
+   [\#1145](https://github.com/matrix-org/matrix-js-sdk/pull/1145)
+ * use a separate object for each encrypted content
+   [\#1147](https://github.com/matrix-org/matrix-js-sdk/pull/1147)
+ * Sourcemaps: develop -> feature branch
+   [\#1143](https://github.com/matrix-org/matrix-js-sdk/pull/1143)
+ * Use a safer import/export scheme for the ContentRepo utilities
+   [\#1134](https://github.com/matrix-org/matrix-js-sdk/pull/1134)
+ * Fix error handling in decryptGroupMessage
+   [\#1142](https://github.com/matrix-org/matrix-js-sdk/pull/1142)
+ * Add additional properties to package.json for riot-web's webpack
+   [\#1131](https://github.com/matrix-org/matrix-js-sdk/pull/1131)
+ * Fix import for indexeddb crypto store
+   [\#1133](https://github.com/matrix-org/matrix-js-sdk/pull/1133)
+ * Use the right request when creating clients
+   [\#1132](https://github.com/matrix-org/matrix-js-sdk/pull/1132)
+ * Target NodeJS 10, minified browser bundle, and other publishing/package
+   things
+   [\#1127](https://github.com/matrix-org/matrix-js-sdk/pull/1127)
+ * Re-focus sourcemap generation
+   [\#1126](https://github.com/matrix-org/matrix-js-sdk/pull/1126)
+ * Remove ancient polyfill for prototype inheritance
+   [\#1125](https://github.com/matrix-org/matrix-js-sdk/pull/1125)
+ * Remove "source-map-support" from tests because it makes sourcemaps worse
+   [\#1124](https://github.com/matrix-org/matrix-js-sdk/pull/1124)
+ * Remove ancient "use strict" annotations
+   [\#1123](https://github.com/matrix-org/matrix-js-sdk/pull/1123)
+ * Use ES6 imports/exports instead of older CommonJS ones
+   [\#1122](https://github.com/matrix-org/matrix-js-sdk/pull/1122)
+ * [BREAKING] Refactor the entire build process
+   [\#1113](https://github.com/matrix-org/matrix-js-sdk/pull/1113)
+
+Changes in [3.42.2-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.42.2-rc.3) (2022-04-08)
+============================================================================================================
 
 ## 🐛 Bug Fixes
+ * Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
 
--   Make self membership less prone to races ([\#2277](https://github.com/matrix-org/matrix-js-sdk/pull/2277)). Fixes vector-im/element-web#21661.
-
-# Changes in [3.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0) (2020-01-13)
-
+Changes in [3.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0) (2020-01-13)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v3.0.0-rc.1...v3.0.0)
 
--   No changes from rc.1
-
-# Changes in [3.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0-rc.1) (2020-01-06)
+ * No changes from rc.1
 
+Changes in [3.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v3.0.0-rc.1) (2020-01-06)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.6...v3.0.0-rc.1)
 
-# BREAKING CHANGES
-
--   matrix-js-sdk no longer uses bluebird promises, so promises returned
-    by the js-sdk no longer support the done() method. Code that calls
-    done() on promises returned by the js-sdk will break and will need
-    to be updated to remove the done() call.
-
-# All Changes
-
--   Make displayName disambiguation more fuzzy especially against RTL/LTR
-    content
-    [\#1141](https://github.com/matrix-org/matrix-js-sdk/pull/1141)
--   stop trying to resend event if we get M_TOO_LARGE
-    [\#1129](https://github.com/matrix-org/matrix-js-sdk/pull/1129)
--   Fix creating a key backup with cross signing diabled
-    [\#1139](https://github.com/matrix-org/matrix-js-sdk/pull/1139)
--   Use checkDeviceTrust with key backup
-    [\#1138](https://github.com/matrix-org/matrix-js-sdk/pull/1138)
--   Add support for passthrough SSSS secrets
-    [\#1128](https://github.com/matrix-org/matrix-js-sdk/pull/1128)
--   Add support for key backups using secret storage
-    [\#1118](https://github.com/matrix-org/matrix-js-sdk/pull/1118)
--   Remove unused user verification event
-    [\#1117](https://github.com/matrix-org/matrix-js-sdk/pull/1117)
--   Fix check for private keys
-    [\#1116](https://github.com/matrix-org/matrix-js-sdk/pull/1116)
--   Restore watching mode for `start:watch`
-    [\#1115](https://github.com/matrix-org/matrix-js-sdk/pull/1115)
--   Add secret storage bootstrap flow
-    [\#1079](https://github.com/matrix-org/matrix-js-sdk/pull/1079)
--   Part 1 of many: Upgrade to babel@7 and TypeScript
-    [\#1112](https://github.com/matrix-org/matrix-js-sdk/pull/1112)
--   Remove Bluebird: phase 2.5
-    [\#1100](https://github.com/matrix-org/matrix-js-sdk/pull/1100)
--   Remove Bluebird: phase 3
-    [\#1088](https://github.com/matrix-org/matrix-js-sdk/pull/1088)
--   ignore m.key.verification.done messages when we don't expect any more
-    messages
-    [\#1104](https://github.com/matrix-org/matrix-js-sdk/pull/1104)
--   dont cancel on remote echo of own .request event
-    [\#1111](https://github.com/matrix-org/matrix-js-sdk/pull/1111)
--   Refactor verification request code
-    [\#1109](https://github.com/matrix-org/matrix-js-sdk/pull/1109)
--   Fix device list's cross-signing storage path
-    [\#1105](https://github.com/matrix-org/matrix-js-sdk/pull/1105)
--   yarn upgrade
-    [\#1103](https://github.com/matrix-org/matrix-js-sdk/pull/1103)
-
-# Changes in [2.4.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6) (2019-12-09)
-
+BREAKING CHANGES
+================
+ * matrix-js-sdk no longer uses bluebird promises, so promises returned
+   by the js-sdk no longer support the done() method. Code that calls
+   done() on promises returned by the js-sdk will break and will need
+   to be updated to remove the done() call.
+
+All Changes
+===========
+ * Make displayName disambiguation more fuzzy especially against RTL/LTR
+   content
+   [\#1141](https://github.com/matrix-org/matrix-js-sdk/pull/1141)
+ * stop trying to resend event if we get M_TOO_LARGE
+   [\#1129](https://github.com/matrix-org/matrix-js-sdk/pull/1129)
+ * Fix creating a key backup with cross signing diabled
+   [\#1139](https://github.com/matrix-org/matrix-js-sdk/pull/1139)
+ * Use checkDeviceTrust with key backup
+   [\#1138](https://github.com/matrix-org/matrix-js-sdk/pull/1138)
+ * Add support for passthrough SSSS secrets
+   [\#1128](https://github.com/matrix-org/matrix-js-sdk/pull/1128)
+ * Add support for key backups using secret storage
+   [\#1118](https://github.com/matrix-org/matrix-js-sdk/pull/1118)
+ * Remove unused user verification event
+   [\#1117](https://github.com/matrix-org/matrix-js-sdk/pull/1117)
+ * Fix check for private keys
+   [\#1116](https://github.com/matrix-org/matrix-js-sdk/pull/1116)
+ * Restore watching mode for `start:watch`
+   [\#1115](https://github.com/matrix-org/matrix-js-sdk/pull/1115)
+ * Add secret storage bootstrap flow
+   [\#1079](https://github.com/matrix-org/matrix-js-sdk/pull/1079)
+ * Part 1 of many: Upgrade to babel@7 and TypeScript
+   [\#1112](https://github.com/matrix-org/matrix-js-sdk/pull/1112)
+ * Remove Bluebird: phase 2.5
+   [\#1100](https://github.com/matrix-org/matrix-js-sdk/pull/1100)
+ * Remove Bluebird: phase 3
+   [\#1088](https://github.com/matrix-org/matrix-js-sdk/pull/1088)
+ * ignore m.key.verification.done messages when we don't expect any more
+   messages
+   [\#1104](https://github.com/matrix-org/matrix-js-sdk/pull/1104)
+ * dont cancel on remote echo of own .request event
+   [\#1111](https://github.com/matrix-org/matrix-js-sdk/pull/1111)
+ * Refactor verification request code
+   [\#1109](https://github.com/matrix-org/matrix-js-sdk/pull/1109)
+ * Fix device list's cross-signing storage path
+   [\#1105](https://github.com/matrix-org/matrix-js-sdk/pull/1105)
+ * yarn upgrade
+   [\#1103](https://github.com/matrix-org/matrix-js-sdk/pull/1103)
+
+Changes in [2.4.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6) (2019-12-09)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.6-rc.1...v2.4.6)
 
--   No changes since rc.1
-
-# Changes in [2.4.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6-rc.1) (2019-12-04)
+ * No changes since rc.1
 
+Changes in [2.4.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.6-rc.1) (2019-12-04)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.5...v2.4.6-rc.1)
 
--   Update alias handling
-    [\#1102](https://github.com/matrix-org/matrix-js-sdk/pull/1102)
--   increase timeout on flush to fix failing unit test
-    [\#1096](https://github.com/matrix-org/matrix-js-sdk/pull/1096)
--   Disable broken cross-signing test
-    [\#1095](https://github.com/matrix-org/matrix-js-sdk/pull/1095)
--   Fix a couple SAS tests
-    [\#1094](https://github.com/matrix-org/matrix-js-sdk/pull/1094)
--   Fix Olm unwedging test
-    [\#1093](https://github.com/matrix-org/matrix-js-sdk/pull/1093)
--   Fix empty string handling in push notifications
-    [\#1089](https://github.com/matrix-org/matrix-js-sdk/pull/1089)
--   expand e2ee logging to better debug UISIs
-    [\#1090](https://github.com/matrix-org/matrix-js-sdk/pull/1090)
--   Remove Bluebird: phase 2
-    [\#1087](https://github.com/matrix-org/matrix-js-sdk/pull/1087)
--   Relax identity server discovery checks to FAIL_PROMPT
-    [\#1062](https://github.com/matrix-org/matrix-js-sdk/pull/1062)
--   Fix incorrect return value of MatrixClient.prototype.uploadKeys
-    [\#1061](https://github.com/matrix-org/matrix-js-sdk/pull/1061)
--   Fix calls in e2e rooms
-    [\#1086](https://github.com/matrix-org/matrix-js-sdk/pull/1086)
--   Monitor verification request over DM as well
-    [\#1085](https://github.com/matrix-org/matrix-js-sdk/pull/1085)
--   Remove 'check' npm script
-    [\#1084](https://github.com/matrix-org/matrix-js-sdk/pull/1084)
--   Always process call events in batches
-    [\#1083](https://github.com/matrix-org/matrix-js-sdk/pull/1083)
--   Fix ringing chirp on loading
-    [\#1082](https://github.com/matrix-org/matrix-js-sdk/pull/1082)
--   Remove _most_ bluebird specific things
-    [\#1081](https://github.com/matrix-org/matrix-js-sdk/pull/1081)
--   Switch to Jest
-    [\#1080](https://github.com/matrix-org/matrix-js-sdk/pull/1080)
-
-# Changes in [2.4.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.5) (2019-11-27)
-
+ * Update alias handling
+   [\#1102](https://github.com/matrix-org/matrix-js-sdk/pull/1102)
+ * increase timeout on flush to fix failing unit test
+   [\#1096](https://github.com/matrix-org/matrix-js-sdk/pull/1096)
+ * Disable broken cross-signing test
+   [\#1095](https://github.com/matrix-org/matrix-js-sdk/pull/1095)
+ * Fix a couple SAS tests
+   [\#1094](https://github.com/matrix-org/matrix-js-sdk/pull/1094)
+ * Fix Olm unwedging test
+   [\#1093](https://github.com/matrix-org/matrix-js-sdk/pull/1093)
+ * Fix empty string handling in push notifications
+   [\#1089](https://github.com/matrix-org/matrix-js-sdk/pull/1089)
+ * expand e2ee logging to better debug UISIs
+   [\#1090](https://github.com/matrix-org/matrix-js-sdk/pull/1090)
+ * Remove Bluebird: phase 2
+   [\#1087](https://github.com/matrix-org/matrix-js-sdk/pull/1087)
+ * Relax identity server discovery checks to FAIL_PROMPT
+   [\#1062](https://github.com/matrix-org/matrix-js-sdk/pull/1062)
+ * Fix incorrect return value of MatrixClient.prototype.uploadKeys
+   [\#1061](https://github.com/matrix-org/matrix-js-sdk/pull/1061)
+ * Fix calls in e2e rooms
+   [\#1086](https://github.com/matrix-org/matrix-js-sdk/pull/1086)
+ * Monitor verification request over DM as well
+   [\#1085](https://github.com/matrix-org/matrix-js-sdk/pull/1085)
+ * Remove 'check' npm script
+   [\#1084](https://github.com/matrix-org/matrix-js-sdk/pull/1084)
+ * Always process call events in batches
+   [\#1083](https://github.com/matrix-org/matrix-js-sdk/pull/1083)
+ * Fix ringing chirp on loading
+   [\#1082](https://github.com/matrix-org/matrix-js-sdk/pull/1082)
+ * Remove *most* bluebird specific things
+   [\#1081](https://github.com/matrix-org/matrix-js-sdk/pull/1081)
+ * Switch to Jest
+   [\#1080](https://github.com/matrix-org/matrix-js-sdk/pull/1080)
+
+Changes in [2.4.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.5) (2019-11-27)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.4...v2.4.5)
 
--   Relax identity server discovery checks to FAIL_PROMPT
--   Expand E2EE debug logging to diagnose "unable to decrypt" errors
-
-# Changes in [2.4.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4) (2019-11-25)
+* Relax identity server discovery checks to FAIL_PROMPT
+* Expand E2EE debug logging to diagnose "unable to decrypt" errors
 
+Changes in [2.4.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4) (2019-11-25)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.4-rc.1...v2.4.4)
 
--   No changes since rc.1
-
-# Changes in [2.4.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4-rc.1) (2019-11-20)
+ * No changes since rc.1
 
+Changes in [2.4.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.4-rc.1) (2019-11-20)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.3...v2.4.4-rc.1)
 
--   Fix SAS verification in encrypted DMs
-    [\#1077](https://github.com/matrix-org/matrix-js-sdk/pull/1077)
--   Cross-signing / secret storage tweaks
-    [\#1078](https://github.com/matrix-org/matrix-js-sdk/pull/1078)
--   Fix local trust for key backups
-    [\#1075](https://github.com/matrix-org/matrix-js-sdk/pull/1075)
--   Add method to get last active timestamp in room
-    [\#1072](https://github.com/matrix-org/matrix-js-sdk/pull/1072)
--   Check the right Synapse endpoint for determining admin capabilities
-    [\#1071](https://github.com/matrix-org/matrix-js-sdk/pull/1071)
--   Cross Signing Support
-    [\#832](https://github.com/matrix-org/matrix-js-sdk/pull/832)
--   Don't double cancel verification request
-    [\#1064](https://github.com/matrix-org/matrix-js-sdk/pull/1064)
--   Support for verification requests in the timeline
-    [\#1067](https://github.com/matrix-org/matrix-js-sdk/pull/1067)
--   Use stable API prefix for 3PID APIs when supported
-    [\#1066](https://github.com/matrix-org/matrix-js-sdk/pull/1066)
--   Remove Jenkins scripts
-    [\#1063](https://github.com/matrix-org/matrix-js-sdk/pull/1063)
-
-# Changes in [2.4.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3) (2019-11-04)
-
+ * Fix SAS verification in encrypted DMs
+   [\#1077](https://github.com/matrix-org/matrix-js-sdk/pull/1077)
+ * Cross-signing / secret storage tweaks
+   [\#1078](https://github.com/matrix-org/matrix-js-sdk/pull/1078)
+ * Fix local trust for key backups
+   [\#1075](https://github.com/matrix-org/matrix-js-sdk/pull/1075)
+ * Add method to get last active timestamp in room
+   [\#1072](https://github.com/matrix-org/matrix-js-sdk/pull/1072)
+ * Check the right Synapse endpoint for determining admin capabilities
+   [\#1071](https://github.com/matrix-org/matrix-js-sdk/pull/1071)
+ * Cross Signing Support
+   [\#832](https://github.com/matrix-org/matrix-js-sdk/pull/832)
+ * Don't double cancel verification request
+   [\#1064](https://github.com/matrix-org/matrix-js-sdk/pull/1064)
+ * Support for verification requests in the timeline
+   [\#1067](https://github.com/matrix-org/matrix-js-sdk/pull/1067)
+ * Use stable API prefix for 3PID APIs when supported
+   [\#1066](https://github.com/matrix-org/matrix-js-sdk/pull/1066)
+ * Remove Jenkins scripts
+   [\#1063](https://github.com/matrix-org/matrix-js-sdk/pull/1063)
+
+Changes in [2.4.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3) (2019-11-04)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.3-rc.1...v2.4.3)
 
--   No changes since rc.1
-
-# Changes in [2.4.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3-rc.1) (2019-10-30)
+ * No changes since rc.1
 
+Changes in [2.4.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.3-rc.1) (2019-10-30)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.2...v2.4.3-rc.1)
 
--   fix the path in references to logger.js
-    [\#1056](https://github.com/matrix-org/matrix-js-sdk/pull/1056)
--   verification in DMs
-    [\#1050](https://github.com/matrix-org/matrix-js-sdk/pull/1050)
--   Properly documented the function possible returns
-    [\#1054](https://github.com/matrix-org/matrix-js-sdk/pull/1054)
--   Downgrade to Bluebird 3.5.5 to fix Firefox
-    [\#1055](https://github.com/matrix-org/matrix-js-sdk/pull/1055)
--   Upgrade safe deps to latest major version
-    [\#1053](https://github.com/matrix-org/matrix-js-sdk/pull/1053)
--   Don't include .js in the import string.
-    [\#1052](https://github.com/matrix-org/matrix-js-sdk/pull/1052)
-
-# Changes in [2.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2) (2019-10-18)
-
+ * fix the path in references to logger.js
+   [\#1056](https://github.com/matrix-org/matrix-js-sdk/pull/1056)
+ * verification in DMs
+   [\#1050](https://github.com/matrix-org/matrix-js-sdk/pull/1050)
+ * Properly documented the function possible returns
+   [\#1054](https://github.com/matrix-org/matrix-js-sdk/pull/1054)
+ * Downgrade to Bluebird 3.5.5 to fix Firefox
+   [\#1055](https://github.com/matrix-org/matrix-js-sdk/pull/1055)
+ * Upgrade safe deps to latest major version
+   [\#1053](https://github.com/matrix-org/matrix-js-sdk/pull/1053)
+ * Don't include .js in the import string.
+   [\#1052](https://github.com/matrix-org/matrix-js-sdk/pull/1052)
+
+Changes in [2.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2) (2019-10-18)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.2-rc.1...v2.4.2)
 
--   No changes since v2.4.2-rc.1
-
-# Changes in [2.4.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2-rc.1) (2019-10-09)
+ * No changes since v2.4.2-rc.1
 
+Changes in [2.4.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.2-rc.1) (2019-10-09)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.1...v2.4.2-rc.1)
 
--   Log state of Olm sessions
-    [\#1047](https://github.com/matrix-org/matrix-js-sdk/pull/1047)
--   Add method to get access to all timelines
-    [\#1048](https://github.com/matrix-org/matrix-js-sdk/pull/1048)
-
-# Changes in [2.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.1) (2019-10-01)
+ * Log state of Olm sessions
+   [\#1047](https://github.com/matrix-org/matrix-js-sdk/pull/1047)
+ * Add method to get access to all timelines
+   [\#1048](https://github.com/matrix-org/matrix-js-sdk/pull/1048)
 
+Changes in [2.4.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.1) (2019-10-01)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.0...v2.4.1)
 
--   Upgrade deps
-    [\#1046](https://github.com/matrix-org/matrix-js-sdk/pull/1046)
--   Ignore crypto events with no content
-    [\#1043](https://github.com/matrix-org/matrix-js-sdk/pull/1043)
-
-# Changes in [2.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0) (2019-09-27)
+ * Upgrade deps
+   [\#1046](https://github.com/matrix-org/matrix-js-sdk/pull/1046)
+ * Ignore crypto events with no content
+   [\#1043](https://github.com/matrix-org/matrix-js-sdk/pull/1043)
 
+Changes in [2.4.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0) (2019-09-27)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.4.0-rc.1...v2.4.0)
 
--   Clean Yarn cache during release
-    [\#1045](https://github.com/matrix-org/matrix-js-sdk/pull/1045)
-
-# Changes in [2.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0-rc.1) (2019-09-25)
+ * Clean Yarn cache during release
+   [\#1045](https://github.com/matrix-org/matrix-js-sdk/pull/1045)
 
+Changes in [2.4.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.4.0-rc.1) (2019-09-25)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.2...v2.4.0-rc.1)
 
--   Remove id_server from creds for interactive auth
-    [\#1044](https://github.com/matrix-org/matrix-js-sdk/pull/1044)
--   Remove IS details from requestToken to HS
-    [\#1041](https://github.com/matrix-org/matrix-js-sdk/pull/1041)
--   Add support for sending MSISDN tokens to alternate URLs
-    [\#1040](https://github.com/matrix-org/matrix-js-sdk/pull/1040)
--   Add separate 3PID add and bind APIs
-    [\#1038](https://github.com/matrix-org/matrix-js-sdk/pull/1038)
--   Bump eslint-utils from 1.4.0 to 1.4.2
-    [\#1037](https://github.com/matrix-org/matrix-js-sdk/pull/1037)
--   Handle WebRTC security errors as non-fatal
-    [\#1036](https://github.com/matrix-org/matrix-js-sdk/pull/1036)
--   Check for r0.6.0 support in addition to unstable feature flags
-    [\#1035](https://github.com/matrix-org/matrix-js-sdk/pull/1035)
--   Update room members on member event redaction
-    [\#1030](https://github.com/matrix-org/matrix-js-sdk/pull/1030)
--   Support hidden read receipts
-    [\#1028](https://github.com/matrix-org/matrix-js-sdk/pull/1028)
--   Do 3pid lookups in lowercase
-    [\#1029](https://github.com/matrix-org/matrix-js-sdk/pull/1029)
--   Add Synapse admin functions for deactivating a user
-    [\#1027](https://github.com/matrix-org/matrix-js-sdk/pull/1027)
--   Fix addPendingEvent with pending event order == chronological
-    [\#1026](https://github.com/matrix-org/matrix-js-sdk/pull/1026)
--   Add AutoDiscovery.getRawClientConfig() for easy .well-known lookups
-    [\#1024](https://github.com/matrix-org/matrix-js-sdk/pull/1024)
--   Don't convert errors to JSON if they are JSON already
-    [\#1025](https://github.com/matrix-org/matrix-js-sdk/pull/1025)
--   Send id_access_token to HS for use in proxied IS requests
-    [\#1022](https://github.com/matrix-org/matrix-js-sdk/pull/1022)
--   Clean up JSON handling in identity server requests
-    [\#1023](https://github.com/matrix-org/matrix-js-sdk/pull/1023)
--   Use the v2 (hashed) lookup for identity server queries
-    [\#1021](https://github.com/matrix-org/matrix-js-sdk/pull/1021)
--   Add getIdServer() & doesServerRequireIdServerParam()
-    [\#1018](https://github.com/matrix-org/matrix-js-sdk/pull/1018)
--   Make requestToken endpoints work without ID Server
-    [\#1019](https://github.com/matrix-org/matrix-js-sdk/pull/1019)
--   Fix setIdentityServer
-    [\#1016](https://github.com/matrix-org/matrix-js-sdk/pull/1016)
--   Change ICE fallback server and make fallback opt-in
-    [\#1015](https://github.com/matrix-org/matrix-js-sdk/pull/1015)
--   Throw an exception if trying to do an ID server request with no ID server
-    [\#1014](https://github.com/matrix-org/matrix-js-sdk/pull/1014)
--   Add setIdentityServerUrl
-    [\#1013](https://github.com/matrix-org/matrix-js-sdk/pull/1013)
--   Add matrix base API to report an event
-    [\#1011](https://github.com/matrix-org/matrix-js-sdk/pull/1011)
--   Fix POST body for v2 IS requests
-    [\#1010](https://github.com/matrix-org/matrix-js-sdk/pull/1010)
--   Add API for bulk lookup on the Identity Server
-    [\#1009](https://github.com/matrix-org/matrix-js-sdk/pull/1009)
--   Remove deprecated authedRequestWithPrefix and requestWithPrefix
-    [\#1000](https://github.com/matrix-org/matrix-js-sdk/pull/1000)
--   Add API for checking IS account info
-    [\#1007](https://github.com/matrix-org/matrix-js-sdk/pull/1007)
--   Support rewriting push rules when our internal defaults change
-    [\#1006](https://github.com/matrix-org/matrix-js-sdk/pull/1006)
--   Upgrade dependencies
-    [\#1005](https://github.com/matrix-org/matrix-js-sdk/pull/1005)
-
-# Changes in [2.3.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2) (2019-09-16)
-
+ * Remove id_server from creds for interactive auth
+   [\#1044](https://github.com/matrix-org/matrix-js-sdk/pull/1044)
+ * Remove IS details from requestToken to HS
+   [\#1041](https://github.com/matrix-org/matrix-js-sdk/pull/1041)
+ * Add support for sending MSISDN tokens to alternate URLs
+   [\#1040](https://github.com/matrix-org/matrix-js-sdk/pull/1040)
+ * Add separate 3PID add and bind APIs
+   [\#1038](https://github.com/matrix-org/matrix-js-sdk/pull/1038)
+ * Bump eslint-utils from 1.4.0 to 1.4.2
+   [\#1037](https://github.com/matrix-org/matrix-js-sdk/pull/1037)
+ * Handle WebRTC security errors as non-fatal
+   [\#1036](https://github.com/matrix-org/matrix-js-sdk/pull/1036)
+ * Check for r0.6.0 support in addition to unstable feature flags
+   [\#1035](https://github.com/matrix-org/matrix-js-sdk/pull/1035)
+ * Update room members on member event redaction
+   [\#1030](https://github.com/matrix-org/matrix-js-sdk/pull/1030)
+ * Support hidden read receipts
+   [\#1028](https://github.com/matrix-org/matrix-js-sdk/pull/1028)
+ * Do 3pid lookups in lowercase
+   [\#1029](https://github.com/matrix-org/matrix-js-sdk/pull/1029)
+ * Add Synapse admin functions for deactivating a user
+   [\#1027](https://github.com/matrix-org/matrix-js-sdk/pull/1027)
+ * Fix addPendingEvent with pending event order == chronological
+   [\#1026](https://github.com/matrix-org/matrix-js-sdk/pull/1026)
+ * Add AutoDiscovery.getRawClientConfig() for easy .well-known lookups
+   [\#1024](https://github.com/matrix-org/matrix-js-sdk/pull/1024)
+ * Don't convert errors to JSON if they are JSON already
+   [\#1025](https://github.com/matrix-org/matrix-js-sdk/pull/1025)
+ * Send id_access_token to HS for use in proxied IS requests
+   [\#1022](https://github.com/matrix-org/matrix-js-sdk/pull/1022)
+ * Clean up JSON handling in identity server requests
+   [\#1023](https://github.com/matrix-org/matrix-js-sdk/pull/1023)
+ * Use the v2 (hashed) lookup for identity server queries
+   [\#1021](https://github.com/matrix-org/matrix-js-sdk/pull/1021)
+ * Add getIdServer() & doesServerRequireIdServerParam()
+   [\#1018](https://github.com/matrix-org/matrix-js-sdk/pull/1018)
+ * Make requestToken endpoints work without ID Server
+   [\#1019](https://github.com/matrix-org/matrix-js-sdk/pull/1019)
+ * Fix setIdentityServer
+   [\#1016](https://github.com/matrix-org/matrix-js-sdk/pull/1016)
+ * Change ICE fallback server and make fallback opt-in
+   [\#1015](https://github.com/matrix-org/matrix-js-sdk/pull/1015)
+ * Throw an exception if trying to do an ID server request with no ID server
+   [\#1014](https://github.com/matrix-org/matrix-js-sdk/pull/1014)
+ * Add setIdentityServerUrl
+   [\#1013](https://github.com/matrix-org/matrix-js-sdk/pull/1013)
+ * Add matrix base API to report an event
+   [\#1011](https://github.com/matrix-org/matrix-js-sdk/pull/1011)
+ * Fix POST body for v2 IS requests
+   [\#1010](https://github.com/matrix-org/matrix-js-sdk/pull/1010)
+ * Add API for bulk lookup on the Identity Server
+   [\#1009](https://github.com/matrix-org/matrix-js-sdk/pull/1009)
+ * Remove deprecated authedRequestWithPrefix and requestWithPrefix
+   [\#1000](https://github.com/matrix-org/matrix-js-sdk/pull/1000)
+ * Add API for checking IS account info
+   [\#1007](https://github.com/matrix-org/matrix-js-sdk/pull/1007)
+ * Support rewriting push rules when our internal defaults change
+   [\#1006](https://github.com/matrix-org/matrix-js-sdk/pull/1006)
+ * Upgrade dependencies
+   [\#1005](https://github.com/matrix-org/matrix-js-sdk/pull/1005)
+
+Changes in [2.3.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2) (2019-09-16)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.2-rc.1...v2.3.2)
 
--   [Release] Fix addPendingEvent with pending event order == chronological
-    [\#1034](https://github.com/matrix-org/matrix-js-sdk/pull/1034)
-
-# Changes in [2.3.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2-rc.1) (2019-09-13)
+ * [Release] Fix addPendingEvent with pending event order == chronological
+   [\#1034](https://github.com/matrix-org/matrix-js-sdk/pull/1034)
 
+Changes in [2.3.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.2-rc.1) (2019-09-13)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.1...v2.3.2-rc.1)
 
--   Synapse admin functions to release
-    [\#1033](https://github.com/matrix-org/matrix-js-sdk/pull/1033)
--   [To Release] Add matrix base API to report an event
-    [\#1032](https://github.com/matrix-org/matrix-js-sdk/pull/1032)
-
-# Changes in [2.3.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1) (2019-09-12)
+ * Synapse admin functions to release
+   [\#1033](https://github.com/matrix-org/matrix-js-sdk/pull/1033)
+ * [To Release] Add matrix base API to report an event
+   [\#1032](https://github.com/matrix-org/matrix-js-sdk/pull/1032)
 
+Changes in [2.3.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1) (2019-09-12)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.1-rc.1...v2.3.1)
 
--   No changes since rc.1
-
-# Changes in [2.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1-rc.1) (2019-09-11)
+ * No changes since rc.1
 
+Changes in [2.3.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.1-rc.1) (2019-09-11)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.0...v2.3.1-rc.1)
 
--   Update room members on member event redaction
-    [\#1031](https://github.com/matrix-org/matrix-js-sdk/pull/1031)
-
-# Changes in [2.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0) (2019-08-05)
+ * Update room members on member event redaction
+   [\#1031](https://github.com/matrix-org/matrix-js-sdk/pull/1031)
 
+Changes in [2.3.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0) (2019-08-05)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.3.0-rc.1...v2.3.0)
 
--   [release] Support rewriting push rules when our internal defaults change
-    [\#1008](https://github.com/matrix-org/matrix-js-sdk/pull/1008)
-
-# Changes in [2.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0-rc.1) (2019-07-31)
+ * [release] Support rewriting push rules when our internal defaults change
+   [\#1008](https://github.com/matrix-org/matrix-js-sdk/pull/1008)
 
+Changes in [2.3.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.3.0-rc.1) (2019-07-31)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.2.0...v2.3.0-rc.1)
 
--   Add support for IS v2 API with authentication
-    [\#1002](https://github.com/matrix-org/matrix-js-sdk/pull/1002)
--   Tombstone bugfixes
-    [\#1001](https://github.com/matrix-org/matrix-js-sdk/pull/1001)
--   Support for MSC2140 (terms of service for IS/IM)
-    [\#988](https://github.com/matrix-org/matrix-js-sdk/pull/988)
--   Add a request method to /devices
-    [\#994](https://github.com/matrix-org/matrix-js-sdk/pull/994)
-
-# Changes in [2.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0) (2019-07-18)
-
+ * Add support for IS v2 API with authentication
+   [\#1002](https://github.com/matrix-org/matrix-js-sdk/pull/1002)
+ * Tombstone bugfixes
+   [\#1001](https://github.com/matrix-org/matrix-js-sdk/pull/1001)
+ * Support for MSC2140 (terms of service for IS/IM)
+   [\#988](https://github.com/matrix-org/matrix-js-sdk/pull/988)
+ * Add a request method to /devices
+   [\#994](https://github.com/matrix-org/matrix-js-sdk/pull/994)
+
+Changes in [2.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0) (2019-07-18)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.2.0-rc.2...v2.2.0)
 
--   Upgrade lodash dependencies
-
-# Changes in [2.2.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.2) (2019-07-12)
+ * Upgrade lodash dependencies
 
+Changes in [2.2.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.2) (2019-07-12)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.2.0-rc.1...v2.2.0-rc.2)
 
--   Fix regression from 2.2.0-rc.1 in request to /devices
-    [\#995](https://github.com/matrix-org/matrix-js-sdk/pull/995)
-
-# Changes in [2.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.1) (2019-07-12)
+ * Fix regression from 2.2.0-rc.1 in request to /devices
+   [\#995](https://github.com/matrix-org/matrix-js-sdk/pull/995)
 
+Changes in [2.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.2.0-rc.1) (2019-07-12)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.1.1...v2.2.0-rc.1)
 
--   End the verification timer when verification is done
-    [\#993](https://github.com/matrix-org/matrix-js-sdk/pull/993)
--   Stabilize usage of stably stable APIs (in a stable way)
-    [\#990](https://github.com/matrix-org/matrix-js-sdk/pull/990)
--   Expose original_event for /relations
-    [\#987](https://github.com/matrix-org/matrix-js-sdk/pull/987)
--   Process ephemeral events outside timeline handling
-    [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
--   Don't accept any locally known edits earlier than the last known server-side
-    aggregated edit
-    [\#986](https://github.com/matrix-org/matrix-js-sdk/pull/986)
--   Get edit date transparently from server aggregations or local echo
-    [\#984](https://github.com/matrix-org/matrix-js-sdk/pull/984)
--   Add a function to flag keys for backup without scheduling a backup
-    [\#982](https://github.com/matrix-org/matrix-js-sdk/pull/982)
--   Block read marker and read receipt from advancing into pending events
-    [\#981](https://github.com/matrix-org/matrix-js-sdk/pull/981)
--   Upgrade dependencies
-    [\#977](https://github.com/matrix-org/matrix-js-sdk/pull/977)
--   Add default push rule to ignore reactions
-    [\#976](https://github.com/matrix-org/matrix-js-sdk/pull/976)
--   Fix exception whilst syncing
-    [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
--   Include the error object when raising Session.logged_out
-    [\#975](https://github.com/matrix-org/matrix-js-sdk/pull/975)
-
-# Changes in [2.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.1) (2019-07-11)
-
+ * End the verification timer when verification is done
+   [\#993](https://github.com/matrix-org/matrix-js-sdk/pull/993)
+ * Stabilize usage of stably stable APIs (in a stable way)
+   [\#990](https://github.com/matrix-org/matrix-js-sdk/pull/990)
+ * Expose original_event for /relations
+   [\#987](https://github.com/matrix-org/matrix-js-sdk/pull/987)
+ * Process ephemeral events outside timeline handling
+   [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
+ * Don't accept any locally known edits earlier than the last known server-side
+   aggregated edit
+   [\#986](https://github.com/matrix-org/matrix-js-sdk/pull/986)
+ * Get edit date transparently from server aggregations or local echo
+   [\#984](https://github.com/matrix-org/matrix-js-sdk/pull/984)
+ * Add a function to flag keys for backup without scheduling a backup
+   [\#982](https://github.com/matrix-org/matrix-js-sdk/pull/982)
+ * Block read marker and read receipt from advancing into pending events
+   [\#981](https://github.com/matrix-org/matrix-js-sdk/pull/981)
+ * Upgrade dependencies
+   [\#977](https://github.com/matrix-org/matrix-js-sdk/pull/977)
+ * Add default push rule to ignore reactions
+   [\#976](https://github.com/matrix-org/matrix-js-sdk/pull/976)
+ * Fix exception whilst syncing
+   [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
+ * Include the error object when raising Session.logged_out
+   [\#975](https://github.com/matrix-org/matrix-js-sdk/pull/975)
+
+Changes in [2.1.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.1) (2019-07-11)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.1.0...v2.1.1)
 
--   Process emphemeral events outside timeline handling
-    [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
-
-# Changes in [2.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0) (2019-07-08)
+ * Process emphemeral events outside timeline handling
+   [\#989](https://github.com/matrix-org/matrix-js-sdk/pull/989)
 
+Changes in [2.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0) (2019-07-08)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.1.0-rc.1...v2.1.0)
 
--   Fix exception whilst syncing
-    [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
-
-# Changes in [2.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0-rc.1) (2019-07-03)
+ * Fix exception whilst syncing
+   [\#979](https://github.com/matrix-org/matrix-js-sdk/pull/979)
 
+Changes in [2.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.1.0-rc.1) (2019-07-03)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.1...v2.1.0-rc.1)
 
--   Handle self read receipts for fixing e2e notification counts
-    [\#974](https://github.com/matrix-org/matrix-js-sdk/pull/974)
--   Add redacts field to event.toJSON
-    [\#973](https://github.com/matrix-org/matrix-js-sdk/pull/973)
--   Handle associated event send failures
-    [\#972](https://github.com/matrix-org/matrix-js-sdk/pull/972)
--   Remove irrelevant debug line from timeline handling
-    [\#971](https://github.com/matrix-org/matrix-js-sdk/pull/971)
--   Handle relations in encrypted rooms
-    [\#969](https://github.com/matrix-org/matrix-js-sdk/pull/969)
--   Relations endpoint support
-    [\#967](https://github.com/matrix-org/matrix-js-sdk/pull/967)
--   Disable event encryption for reactions
-    [\#968](https://github.com/matrix-org/matrix-js-sdk/pull/968)
--   Change the known safe room version to version 4
-    [\#966](https://github.com/matrix-org/matrix-js-sdk/pull/966)
--   Check for lazy-loading support in the spec versions instead
-    [\#965](https://github.com/matrix-org/matrix-js-sdk/pull/965)
--   Use camelCase instead of underscore
-    [\#963](https://github.com/matrix-org/matrix-js-sdk/pull/963)
--   Time out verification attempts after 10 minutes of inactivity
-    [\#961](https://github.com/matrix-org/matrix-js-sdk/pull/961)
--   Don't handle key verification requests which are immediately cancelled
-    [\#962](https://github.com/matrix-org/matrix-js-sdk/pull/962)
-
-# Changes in [2.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1) (2019-06-19)
-
+ * Handle self read receipts for fixing e2e notification counts
+   [\#974](https://github.com/matrix-org/matrix-js-sdk/pull/974)
+ * Add redacts field to event.toJSON
+   [\#973](https://github.com/matrix-org/matrix-js-sdk/pull/973)
+ * Handle associated event send failures
+   [\#972](https://github.com/matrix-org/matrix-js-sdk/pull/972)
+ * Remove irrelevant debug line from timeline handling
+   [\#971](https://github.com/matrix-org/matrix-js-sdk/pull/971)
+ * Handle relations in encrypted rooms
+   [\#969](https://github.com/matrix-org/matrix-js-sdk/pull/969)
+ * Relations endpoint support
+   [\#967](https://github.com/matrix-org/matrix-js-sdk/pull/967)
+ * Disable event encryption for reactions
+   [\#968](https://github.com/matrix-org/matrix-js-sdk/pull/968)
+ * Change the known safe room version to version 4
+   [\#966](https://github.com/matrix-org/matrix-js-sdk/pull/966)
+ * Check for lazy-loading support in the spec versions instead
+   [\#965](https://github.com/matrix-org/matrix-js-sdk/pull/965)
+ * Use camelCase instead of underscore
+   [\#963](https://github.com/matrix-org/matrix-js-sdk/pull/963)
+ * Time out verification attempts after 10 minutes of inactivity
+   [\#961](https://github.com/matrix-org/matrix-js-sdk/pull/961)
+ * Don't handle key verification requests which are immediately cancelled
+   [\#962](https://github.com/matrix-org/matrix-js-sdk/pull/962)
+
+Changes in [2.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1) (2019-06-19)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.1-rc.2...v2.0.1)
 
-No changes since rc.2
-
-# Changes in [2.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.2) (2019-06-18)
+ No changes since rc.2
 
+Changes in [2.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.2) (2019-06-18)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.1-rc.1...v2.0.1-rc.2)
 
--   return 'sending' status for an event that is only locally redacted
-    [\#960](https://github.com/matrix-org/matrix-js-sdk/pull/960)
--   Key verification request fixes
-    [\#954](https://github.com/matrix-org/matrix-js-sdk/pull/954)
--   Add flag to force saving sync store
-    [\#956](https://github.com/matrix-org/matrix-js-sdk/pull/956)
--   Expose the inhibit_login flag to register
-    [\#953](https://github.com/matrix-org/matrix-js-sdk/pull/953)
--   Support redactions and relations of/with unsent events.
-    [\#947](https://github.com/matrix-org/matrix-js-sdk/pull/947)
-
-# Changes in [2.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.1) (2019-06-12)
-
+ * return 'sending' status for an event that is only locally redacted
+   [\#960](https://github.com/matrix-org/matrix-js-sdk/pull/960)
+ * Key verification request fixes
+   [\#954](https://github.com/matrix-org/matrix-js-sdk/pull/954)
+ * Add flag to force saving sync store
+   [\#956](https://github.com/matrix-org/matrix-js-sdk/pull/956)
+ * Expose the inhibit_login flag to register
+   [\#953](https://github.com/matrix-org/matrix-js-sdk/pull/953)
+ *  Support redactions and relations of/with unsent events.
+   [\#947](https://github.com/matrix-org/matrix-js-sdk/pull/947)
+
+Changes in [2.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.1-rc.1) (2019-06-12)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v2.0.0...v2.0.1-rc.1)
 
--   Fix content uploads for modern browsers
-    [\#952](https://github.com/matrix-org/matrix-js-sdk/pull/952)
--   Don't overlap auth submissions with polls
-    [\#951](https://github.com/matrix-org/matrix-js-sdk/pull/951)
--   Add funding details for GitHub sponsor button
-    [\#945](https://github.com/matrix-org/matrix-js-sdk/pull/945)
--   Fix backup sig validation with multiple sigs
-    [\#944](https://github.com/matrix-org/matrix-js-sdk/pull/944)
--   Don't send another token request while one's in flight
-    [\#943](https://github.com/matrix-org/matrix-js-sdk/pull/943)
--   Don't poll UI auth again until current poll finishes
-    [\#942](https://github.com/matrix-org/matrix-js-sdk/pull/942)
--   Provide the discovered URLs when a liveliness error occurs
-    [\#938](https://github.com/matrix-org/matrix-js-sdk/pull/938)
--   Encode event IDs when redacting events
-    [\#941](https://github.com/matrix-org/matrix-js-sdk/pull/941)
--   add missing logger
-    [\#940](https://github.com/matrix-org/matrix-js-sdk/pull/940)
--   verification: don't error if we don't know about some keys
-    [\#939](https://github.com/matrix-org/matrix-js-sdk/pull/939)
--   Local echo for redactions
-    [\#937](https://github.com/matrix-org/matrix-js-sdk/pull/937)
--   Refresh safe room versions when the server looks more modern than us
-    [\#934](https://github.com/matrix-org/matrix-js-sdk/pull/934)
--   Add v4 as a safe room version
-    [\#935](https://github.com/matrix-org/matrix-js-sdk/pull/935)
--   Disable guard-for-in rule
-    [\#933](https://github.com/matrix-org/matrix-js-sdk/pull/933)
--   Extend loglevel logging for the whole project
-    [\#924](https://github.com/matrix-org/matrix-js-sdk/pull/924)
--   fix(login): saves access_token and user_id after login for all login types
-    [\#930](https://github.com/matrix-org/matrix-js-sdk/pull/930)
--   Do not try to request thumbnails with non-integer sizes
-    [\#929](https://github.com/matrix-org/matrix-js-sdk/pull/929)
--   Revert "Add a bunch of debugging to .well-known IS validation"
-    [\#928](https://github.com/matrix-org/matrix-js-sdk/pull/928)
--   Add a bunch of debugging to .well-known IS validation
-    [\#927](https://github.com/matrix-org/matrix-js-sdk/pull/927)
-
-# Changes in [2.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.0) (2019-05-31)
-
+ * Fix content uploads for modern browsers
+   [\#952](https://github.com/matrix-org/matrix-js-sdk/pull/952)
+ * Don't overlap auth submissions with polls
+   [\#951](https://github.com/matrix-org/matrix-js-sdk/pull/951)
+ * Add funding details for GitHub sponsor button
+   [\#945](https://github.com/matrix-org/matrix-js-sdk/pull/945)
+ * Fix backup sig validation with multiple sigs
+   [\#944](https://github.com/matrix-org/matrix-js-sdk/pull/944)
+ * Don't send another token request while one's in flight
+   [\#943](https://github.com/matrix-org/matrix-js-sdk/pull/943)
+ * Don't poll UI auth again until current poll finishes
+   [\#942](https://github.com/matrix-org/matrix-js-sdk/pull/942)
+ * Provide the discovered URLs when a liveliness error occurs
+   [\#938](https://github.com/matrix-org/matrix-js-sdk/pull/938)
+ * Encode event IDs when redacting events
+   [\#941](https://github.com/matrix-org/matrix-js-sdk/pull/941)
+ * add missing logger
+   [\#940](https://github.com/matrix-org/matrix-js-sdk/pull/940)
+ * verification: don't error if we don't know about some keys
+   [\#939](https://github.com/matrix-org/matrix-js-sdk/pull/939)
+ * Local echo for redactions
+   [\#937](https://github.com/matrix-org/matrix-js-sdk/pull/937)
+ * Refresh safe room versions when the server looks more modern than us
+   [\#934](https://github.com/matrix-org/matrix-js-sdk/pull/934)
+ * Add v4 as a safe room version
+   [\#935](https://github.com/matrix-org/matrix-js-sdk/pull/935)
+ * Disable guard-for-in rule
+   [\#933](https://github.com/matrix-org/matrix-js-sdk/pull/933)
+ * Extend loglevel logging for the whole project
+   [\#924](https://github.com/matrix-org/matrix-js-sdk/pull/924)
+ * fix(login): saves access_token and user_id after login for all login types
+   [\#930](https://github.com/matrix-org/matrix-js-sdk/pull/930)
+ * Do not try to request thumbnails with non-integer sizes
+   [\#929](https://github.com/matrix-org/matrix-js-sdk/pull/929)
+ * Revert "Add a bunch of debugging to .well-known IS validation"
+   [\#928](https://github.com/matrix-org/matrix-js-sdk/pull/928)
+ * Add a bunch of debugging to .well-known IS validation
+   [\#927](https://github.com/matrix-org/matrix-js-sdk/pull/927)
+
+Changes in [2.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v2.0.0) (2019-05-31)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.2.0...v2.0.0)
 
-## BREAKING CHANGES
-
--   This package now publishes in ES6 / ES2015 syntax to NPM
--   Saves access_token and user_id after login for all login types
-    [\#932](https://github.com/matrix-org/matrix-js-sdk/pull/932)
--   Fix recovery key encoding for base-x 3.0.5
-    [\#931](https://github.com/matrix-org/matrix-js-sdk/pull/931)
+BREAKING CHANGES
+----------------
 
-# Changes in [1.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0) (2019-05-29)
+ * This package now publishes in ES6 / ES2015 syntax to NPM
+ * Saves access_token and user_id after login for all login types
+   [\#932](https://github.com/matrix-org/matrix-js-sdk/pull/932)
+ * Fix recovery key encoding for base-x 3.0.5
+   [\#931](https://github.com/matrix-org/matrix-js-sdk/pull/931)
 
+Changes in [1.2.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0) (2019-05-29)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.2.0-rc.1...v1.2.0)
 
-# Changes in [1.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0-rc.1) (2019-05-23)
 
+Changes in [1.2.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.2.0-rc.1) (2019-05-23)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.1.0...v1.2.0-rc.1)
 
--   interactive-auth now handles requesting email tokens
-    [\#926](https://github.com/matrix-org/matrix-js-sdk/pull/926)
--   allow access to unreplaced message content
-    [\#923](https://github.com/matrix-org/matrix-js-sdk/pull/923)
--   Add method to retrieve replacing event
-    [\#922](https://github.com/matrix-org/matrix-js-sdk/pull/922)
--   More logging when signature verification fails
-    [\#921](https://github.com/matrix-org/matrix-js-sdk/pull/921)
--   Local echo for m.replace relations
-    [\#920](https://github.com/matrix-org/matrix-js-sdk/pull/920)
--   Track relations as pending and remove when cancelled
-    [\#919](https://github.com/matrix-org/matrix-js-sdk/pull/919)
--   Add stringify helper to summarise events when debugging
-    [\#916](https://github.com/matrix-org/matrix-js-sdk/pull/916)
--   Message editing: filter out replacements for senders that are not the
-    original sender
-    [\#918](https://github.com/matrix-org/matrix-js-sdk/pull/918)
--   Wait until decrypt before aggregating
-    [\#917](https://github.com/matrix-org/matrix-js-sdk/pull/917)
--   Message editing: mark original event as replaced instead of replacing the
-    event object
-    [\#914](https://github.com/matrix-org/matrix-js-sdk/pull/914)
--   Support for replacing message through m.replace relationship.
-    [\#913](https://github.com/matrix-org/matrix-js-sdk/pull/913)
--   Use a short timeout for .well-known requests
-    [\#912](https://github.com/matrix-org/matrix-js-sdk/pull/912)
--   Redaction and change events for relations
-    [\#911](https://github.com/matrix-org/matrix-js-sdk/pull/911)
--   Add basic read path for relations
-    [\#910](https://github.com/matrix-org/matrix-js-sdk/pull/910)
--   Add a concept of default push rules, using it for tombstone notifications
-    [\#860](https://github.com/matrix-org/matrix-js-sdk/pull/860)
--   yarn upgrade
-    [\#907](https://github.com/matrix-org/matrix-js-sdk/pull/907)
-
-# Changes in [1.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0) (2019-05-07)
-
+ * interactive-auth now handles requesting email tokens
+   [\#926](https://github.com/matrix-org/matrix-js-sdk/pull/926)
+ * allow access to unreplaced message content
+   [\#923](https://github.com/matrix-org/matrix-js-sdk/pull/923)
+ * Add method to retrieve replacing event
+   [\#922](https://github.com/matrix-org/matrix-js-sdk/pull/922)
+ * More logging when signature verification fails
+   [\#921](https://github.com/matrix-org/matrix-js-sdk/pull/921)
+ * Local echo for m.replace relations
+   [\#920](https://github.com/matrix-org/matrix-js-sdk/pull/920)
+ * Track relations as pending and remove when cancelled
+   [\#919](https://github.com/matrix-org/matrix-js-sdk/pull/919)
+ * Add stringify helper to summarise events when debugging
+   [\#916](https://github.com/matrix-org/matrix-js-sdk/pull/916)
+ * Message editing: filter out replacements for senders that are not the
+   original sender
+   [\#918](https://github.com/matrix-org/matrix-js-sdk/pull/918)
+ * Wait until decrypt before aggregating
+   [\#917](https://github.com/matrix-org/matrix-js-sdk/pull/917)
+ * Message editing: mark original event as replaced instead of replacing the
+   event object
+   [\#914](https://github.com/matrix-org/matrix-js-sdk/pull/914)
+ * Support for replacing message through m.replace relationship.
+   [\#913](https://github.com/matrix-org/matrix-js-sdk/pull/913)
+ * Use a short timeout for .well-known requests
+   [\#912](https://github.com/matrix-org/matrix-js-sdk/pull/912)
+ * Redaction and change events for relations
+   [\#911](https://github.com/matrix-org/matrix-js-sdk/pull/911)
+ * Add basic read path for relations
+   [\#910](https://github.com/matrix-org/matrix-js-sdk/pull/910)
+ * Add a concept of default push rules, using it for tombstone notifications
+   [\#860](https://github.com/matrix-org/matrix-js-sdk/pull/860)
+ * yarn upgrade
+   [\#907](https://github.com/matrix-org/matrix-js-sdk/pull/907)
+
+Changes in [1.1.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0) (2019-05-07)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.1.0-rc.1...v1.1.0)
 
--   No Changes since rc.1
-
-# Changes in [1.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0-rc.1) (2019-04-30)
+ * No Changes since rc.1
 
+Changes in [1.1.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.1.0-rc.1) (2019-04-30)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.4...v1.1.0-rc.1)
 
--   use the release version of olm 3.1.0
-    [\#903](https://github.com/matrix-org/matrix-js-sdk/pull/903)
--   Use new Olm repo link in README
-    [\#901](https://github.com/matrix-org/matrix-js-sdk/pull/901)
--   Support being fed a .well-known config object for validation
-    [\#897](https://github.com/matrix-org/matrix-js-sdk/pull/897)
--   emit self-membership event at end of handling sync update
-    [\#900](https://github.com/matrix-org/matrix-js-sdk/pull/900)
--   Use packages.matrix.org for Olm
-    [\#898](https://github.com/matrix-org/matrix-js-sdk/pull/898)
--   Fix tests on develop
-    [\#899](https://github.com/matrix-org/matrix-js-sdk/pull/899)
--   Stop syncing when the token is invalid
-    [\#895](https://github.com/matrix-org/matrix-js-sdk/pull/895)
--   change event redact, POST request to PUT request
-    [\#887](https://github.com/matrix-org/matrix-js-sdk/pull/887)
--   Expose better autodiscovery error messages
-    [\#894](https://github.com/matrix-org/matrix-js-sdk/pull/894)
--   Explicitly guard store usage during sync startup
-    [\#892](https://github.com/matrix-org/matrix-js-sdk/pull/892)
--   Flag v3 rooms as safe
-    [\#893](https://github.com/matrix-org/matrix-js-sdk/pull/893)
--   Cache failed capabilities lookups for shorter amounts of time
-    [\#890](https://github.com/matrix-org/matrix-js-sdk/pull/890)
--   Fix highlight notifications for unencrypted rooms
-    [\#891](https://github.com/matrix-org/matrix-js-sdk/pull/891)
--   Document checking crypto state before using `hasUnverifiedDevices`
-    [\#889](https://github.com/matrix-org/matrix-js-sdk/pull/889)
--   Add logging to sync startup path
-    [\#888](https://github.com/matrix-org/matrix-js-sdk/pull/888)
--   Track e2e highlights better, particularly in 'Mentions Only' rooms
-    [\#886](https://github.com/matrix-org/matrix-js-sdk/pull/886)
--   support both the incorrect and correct MAC methods
-    [\#882](https://github.com/matrix-org/matrix-js-sdk/pull/882)
--   Refuse to set forwards pagination token on live timeline
-    [\#885](https://github.com/matrix-org/matrix-js-sdk/pull/885)
--   Degrade `IndexedDBStore` back to memory only on failure
-    [\#884](https://github.com/matrix-org/matrix-js-sdk/pull/884)
--   Refuse to link live timelines into the forwards/backwards position when
-    either is invalid
-    [\#877](https://github.com/matrix-org/matrix-js-sdk/pull/877)
--   Key backup logging improvements
-    [\#883](https://github.com/matrix-org/matrix-js-sdk/pull/883)
--   Don't assume aborts are always from txn.abort()
-    [\#880](https://github.com/matrix-org/matrix-js-sdk/pull/880)
--   Add a bunch of logging
-    [\#878](https://github.com/matrix-org/matrix-js-sdk/pull/878)
--   Refuse splicing the live timeline into a broken position
-    [\#873](https://github.com/matrix-org/matrix-js-sdk/pull/873)
--   Add existence check to local storage based crypto store
-    [\#872](https://github.com/matrix-org/matrix-js-sdk/pull/872)
-
-# Changes in [1.0.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.4) (2019-04-08)
-
+ * use the release version of olm 3.1.0
+   [\#903](https://github.com/matrix-org/matrix-js-sdk/pull/903)
+ * Use new Olm repo link in README
+   [\#901](https://github.com/matrix-org/matrix-js-sdk/pull/901)
+ * Support being fed a .well-known config object for validation
+   [\#897](https://github.com/matrix-org/matrix-js-sdk/pull/897)
+ * emit self-membership event at end of handling sync update
+   [\#900](https://github.com/matrix-org/matrix-js-sdk/pull/900)
+ * Use packages.matrix.org for Olm
+   [\#898](https://github.com/matrix-org/matrix-js-sdk/pull/898)
+ * Fix tests on develop
+   [\#899](https://github.com/matrix-org/matrix-js-sdk/pull/899)
+ * Stop syncing when the token is invalid
+   [\#895](https://github.com/matrix-org/matrix-js-sdk/pull/895)
+ * change event redact,  POST request to PUT request
+   [\#887](https://github.com/matrix-org/matrix-js-sdk/pull/887)
+ * Expose better autodiscovery error messages
+   [\#894](https://github.com/matrix-org/matrix-js-sdk/pull/894)
+ * Explicitly guard store usage during sync startup
+   [\#892](https://github.com/matrix-org/matrix-js-sdk/pull/892)
+ * Flag v3 rooms as safe
+   [\#893](https://github.com/matrix-org/matrix-js-sdk/pull/893)
+ * Cache failed capabilities lookups for shorter amounts of time
+   [\#890](https://github.com/matrix-org/matrix-js-sdk/pull/890)
+ * Fix highlight notifications for unencrypted rooms
+   [\#891](https://github.com/matrix-org/matrix-js-sdk/pull/891)
+ * Document checking crypto state before using `hasUnverifiedDevices`
+   [\#889](https://github.com/matrix-org/matrix-js-sdk/pull/889)
+ * Add logging to sync startup path
+   [\#888](https://github.com/matrix-org/matrix-js-sdk/pull/888)
+ * Track e2e highlights better, particularly in 'Mentions Only' rooms
+   [\#886](https://github.com/matrix-org/matrix-js-sdk/pull/886)
+ * support both the incorrect and correct MAC methods
+   [\#882](https://github.com/matrix-org/matrix-js-sdk/pull/882)
+ * Refuse to set forwards pagination token on live timeline
+   [\#885](https://github.com/matrix-org/matrix-js-sdk/pull/885)
+ * Degrade `IndexedDBStore` back to memory only on failure
+   [\#884](https://github.com/matrix-org/matrix-js-sdk/pull/884)
+ * Refuse to link live timelines into the forwards/backwards position when
+   either is invalid
+   [\#877](https://github.com/matrix-org/matrix-js-sdk/pull/877)
+ * Key backup logging improvements
+   [\#883](https://github.com/matrix-org/matrix-js-sdk/pull/883)
+ * Don't assume aborts are always from txn.abort()
+   [\#880](https://github.com/matrix-org/matrix-js-sdk/pull/880)
+ * Add a bunch of logging
+   [\#878](https://github.com/matrix-org/matrix-js-sdk/pull/878)
+ * Refuse splicing the live timeline into a broken position
+   [\#873](https://github.com/matrix-org/matrix-js-sdk/pull/873)
+ * Add existence check to local storage based crypto store
+   [\#872](https://github.com/matrix-org/matrix-js-sdk/pull/872)
+
+Changes in [1.0.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.4) (2019-04-08)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.3...v1.0.4)
 
--   Hotfix: more logging and potential fixes for timeline corruption issue, see ticket https://github.com/vector-im/riot-web/issues/8593.
-
-# Changes in [1.0.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3) (2019-04-01)
+ * Hotfix: more logging and potential fixes for timeline corruption issue, see ticket https://github.com/vector-im/riot-web/issues/8593.
 
+Changes in [1.0.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3) (2019-04-01)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.3-rc.1...v1.0.3)
 
--   Add existence check to local storage based crypto store
-    [\#874](https://github.com/matrix-org/matrix-js-sdk/pull/874)
-
-# Changes in [1.0.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3-rc.1) (2019-03-27)
+ * Add existence check to local storage based crypto store
+   [\#874](https://github.com/matrix-org/matrix-js-sdk/pull/874)
 
+Changes in [1.0.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.3-rc.1) (2019-03-27)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.2...v1.0.3-rc.1)
 
--   Add IndexedDB existence checks
-    [\#871](https://github.com/matrix-org/matrix-js-sdk/pull/871)
--   Emit sync errors for capturing by clients
-    [\#869](https://github.com/matrix-org/matrix-js-sdk/pull/869)
--   Add functions for getting room upgrade history and leaving those rooms
-    [\#868](https://github.com/matrix-org/matrix-js-sdk/pull/868)
--   Clarify the meaning of 'real name' for contribution
-    [\#867](https://github.com/matrix-org/matrix-js-sdk/pull/867)
--   Remove `sessionStore` to `cryptoStore` migration path
-    [\#865](https://github.com/matrix-org/matrix-js-sdk/pull/865)
--   Add debugging for spurious room version warnings
-    [\#866](https://github.com/matrix-org/matrix-js-sdk/pull/866)
--   Add investigation notes for browser storage
-    [\#864](https://github.com/matrix-org/matrix-js-sdk/pull/864)
--   make sure resolve object is defined before calling it
-    [\#862](https://github.com/matrix-org/matrix-js-sdk/pull/862)
--   Rename `MatrixInMemoryStore` to `MemoryStore`
-    [\#861](https://github.com/matrix-org/matrix-js-sdk/pull/861)
--   Use Buildkite for CI
-    [\#859](https://github.com/matrix-org/matrix-js-sdk/pull/859)
--   only create one session at a time per device
-    [\#857](https://github.com/matrix-org/matrix-js-sdk/pull/857)
-
-# Changes in [1.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2) (2019-03-18)
-
+ * Add IndexedDB existence checks
+   [\#871](https://github.com/matrix-org/matrix-js-sdk/pull/871)
+ * Emit sync errors for capturing by clients
+   [\#869](https://github.com/matrix-org/matrix-js-sdk/pull/869)
+ * Add functions for getting room upgrade history and leaving those rooms
+   [\#868](https://github.com/matrix-org/matrix-js-sdk/pull/868)
+ * Clarify the meaning of 'real name' for contribution
+   [\#867](https://github.com/matrix-org/matrix-js-sdk/pull/867)
+ * Remove `sessionStore` to `cryptoStore` migration path
+   [\#865](https://github.com/matrix-org/matrix-js-sdk/pull/865)
+ * Add debugging for spurious room version warnings
+   [\#866](https://github.com/matrix-org/matrix-js-sdk/pull/866)
+ * Add investigation notes for browser storage
+   [\#864](https://github.com/matrix-org/matrix-js-sdk/pull/864)
+ * make sure resolve object is defined before calling it
+   [\#862](https://github.com/matrix-org/matrix-js-sdk/pull/862)
+ * Rename `MatrixInMemoryStore` to `MemoryStore`
+   [\#861](https://github.com/matrix-org/matrix-js-sdk/pull/861)
+ * Use Buildkite for CI
+   [\#859](https://github.com/matrix-org/matrix-js-sdk/pull/859)
+ * only create one session at a time per device
+   [\#857](https://github.com/matrix-org/matrix-js-sdk/pull/857)
+
+Changes in [1.0.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2) (2019-03-18)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.2-rc.1...v1.0.2)
 
--   No changes since rc.1
-
-# Changes in [1.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2-rc.1) (2019-03-13)
+ * No changes since rc.1
 
+Changes in [1.0.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.2-rc.1) (2019-03-13)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.1...v1.0.2-rc.1)
 
--   Use modern Yarn version on Travis CI
-    [\#858](https://github.com/matrix-org/matrix-js-sdk/pull/858)
--   Switch to `yarn` for dependency management
-    [\#856](https://github.com/matrix-org/matrix-js-sdk/pull/856)
--   More key request fixes
-    [\#855](https://github.com/matrix-org/matrix-js-sdk/pull/855)
--   Calculate encrypted notification counts
-    [\#851](https://github.com/matrix-org/matrix-js-sdk/pull/851)
--   Update dependencies
-    [\#854](https://github.com/matrix-org/matrix-js-sdk/pull/854)
--   make sure key requests get sent
-    [\#850](https://github.com/matrix-org/matrix-js-sdk/pull/850)
--   Use 'ideal' rather than 'exact' for deviceid
-    [\#852](https://github.com/matrix-org/matrix-js-sdk/pull/852)
--   handle partially-shared sessions better
-    [\#848](https://github.com/matrix-org/matrix-js-sdk/pull/848)
-
-# Changes in [1.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1) (2019-03-06)
-
+ * Use modern Yarn version on Travis CI
+   [\#858](https://github.com/matrix-org/matrix-js-sdk/pull/858)
+ * Switch to `yarn` for dependency management
+   [\#856](https://github.com/matrix-org/matrix-js-sdk/pull/856)
+ * More key request fixes
+   [\#855](https://github.com/matrix-org/matrix-js-sdk/pull/855)
+ * Calculate encrypted notification counts
+   [\#851](https://github.com/matrix-org/matrix-js-sdk/pull/851)
+ * Update dependencies
+   [\#854](https://github.com/matrix-org/matrix-js-sdk/pull/854)
+ * make sure key requests get sent
+   [\#850](https://github.com/matrix-org/matrix-js-sdk/pull/850)
+ * Use 'ideal' rather than 'exact' for deviceid
+   [\#852](https://github.com/matrix-org/matrix-js-sdk/pull/852)
+ * handle partially-shared sessions better
+   [\#848](https://github.com/matrix-org/matrix-js-sdk/pull/848)
+
+Changes in [1.0.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1) (2019-03-06)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.1-rc.2...v1.0.1)
 
--   No changes since rc.2
-
-# Changes in [1.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.2) (2019-03-05)
+ * No changes since rc.2
 
+Changes in [1.0.1-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.2) (2019-03-05)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.1-rc.1...v1.0.1-rc.2)
 
--   dont swallow txn errors in crypto store
-    [\#853](https://github.com/matrix-org/matrix-js-sdk/pull/853)
--   Don't swallow txn errors in crypto store
-    [\#849](https://github.com/matrix-org/matrix-js-sdk/pull/849)
-
-# Changes in [1.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.1) (2019-02-28)
+ * dont swallow txn errors in crypto store
+   [\#853](https://github.com/matrix-org/matrix-js-sdk/pull/853)
+ * Don't swallow txn errors in crypto store
+   [\#849](https://github.com/matrix-org/matrix-js-sdk/pull/849)
 
+Changes in [1.0.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.1-rc.1) (2019-02-28)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.0...v1.0.1-rc.1)
 
--   Fix "e is undefined" masking the original error in MegolmDecryption
-    [\#847](https://github.com/matrix-org/matrix-js-sdk/pull/847)
-
-# Changes in [1.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0) (2019-02-14)
+ * Fix "e is undefined" masking the original error in MegolmDecryption
+   [\#847](https://github.com/matrix-org/matrix-js-sdk/pull/847)
 
+Changes in [1.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0) (2019-02-14)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.0-rc.2...v1.0.0)
 
--   Try again to commit package-lock.json
-    [\#841](https://github.com/matrix-org/matrix-js-sdk/pull/841)
-
-# Changes in [1.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.2) (2019-02-14)
+ * Try again to commit package-lock.json
+   [\#841](https://github.com/matrix-org/matrix-js-sdk/pull/841)
 
+Changes in [1.0.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.2) (2019-02-14)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v1.0.0-rc.1...v1.0.0-rc.2)
 
--   Release script: commit package-lock.json
-    [\#839](https://github.com/matrix-org/matrix-js-sdk/pull/839)
--   Add method to force re-check of key backup
-    [\#840](https://github.com/matrix-org/matrix-js-sdk/pull/840)
--   Fix: dont check for unverified devices in left members
-    [\#838](https://github.com/matrix-org/matrix-js-sdk/pull/838)
-
-# Changes in [1.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.1) (2019-02-08)
+ * Release script: commit package-lock.json
+   [\#839](https://github.com/matrix-org/matrix-js-sdk/pull/839)
+ * Add method to force re-check of key backup
+   [\#840](https://github.com/matrix-org/matrix-js-sdk/pull/840)
+ * Fix: dont check for unverified devices in left members
+   [\#838](https://github.com/matrix-org/matrix-js-sdk/pull/838)
 
+Changes in [1.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v1.0.0-rc.1) (2019-02-08)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.3...v1.0.0-rc.1)
 
--   change hex SAS verification to decimal and emoji
-    [\#837](https://github.com/matrix-org/matrix-js-sdk/pull/837)
--   Trust on decrypt
-    [\#836](https://github.com/matrix-org/matrix-js-sdk/pull/836)
--   Always track our own devices
-    [\#835](https://github.com/matrix-org/matrix-js-sdk/pull/835)
--   Make linting rules more consistent
-    [\#834](https://github.com/matrix-org/matrix-js-sdk/pull/834)
--   add method to room to check for unverified devices
-    [\#833](https://github.com/matrix-org/matrix-js-sdk/pull/833)
--   Merge redesign into develop
-    [\#831](https://github.com/matrix-org/matrix-js-sdk/pull/831)
--   Supporting infrastructure for educated decisions on when to upgrade rooms
-    [\#830](https://github.com/matrix-org/matrix-js-sdk/pull/830)
--   Include signature info for unknown devices
-    [\#826](https://github.com/matrix-org/matrix-js-sdk/pull/826)
--   Flag v2 rooms as "safe"
-    [\#828](https://github.com/matrix-org/matrix-js-sdk/pull/828)
--   Update ESLint
-    [\#821](https://github.com/matrix-org/matrix-js-sdk/pull/821)
-
-# Changes in [0.14.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3) (2019-01-22)
-
+ * change hex SAS verification to decimal and emoji
+   [\#837](https://github.com/matrix-org/matrix-js-sdk/pull/837)
+ * Trust on decrypt
+   [\#836](https://github.com/matrix-org/matrix-js-sdk/pull/836)
+ * Always track our own devices
+   [\#835](https://github.com/matrix-org/matrix-js-sdk/pull/835)
+ * Make linting rules more consistent
+   [\#834](https://github.com/matrix-org/matrix-js-sdk/pull/834)
+ * add method to room to check for unverified devices
+   [\#833](https://github.com/matrix-org/matrix-js-sdk/pull/833)
+ * Merge redesign into develop
+   [\#831](https://github.com/matrix-org/matrix-js-sdk/pull/831)
+ * Supporting infrastructure for educated decisions on when to upgrade rooms
+   [\#830](https://github.com/matrix-org/matrix-js-sdk/pull/830)
+ * Include signature info for unknown devices
+   [\#826](https://github.com/matrix-org/matrix-js-sdk/pull/826)
+ * Flag v2 rooms as "safe"
+   [\#828](https://github.com/matrix-org/matrix-js-sdk/pull/828)
+ * Update ESLint
+   [\#821](https://github.com/matrix-org/matrix-js-sdk/pull/821)
+
+Changes in [0.14.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3) (2019-01-22)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.3-rc.1...v0.14.3)
 
--   No changes since rc.1
-
-# Changes in [0.14.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3-rc.1) (2019-01-17)
+ * No changes since rc.1
 
+Changes in [0.14.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.3-rc.1) (2019-01-17)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.2...v0.14.3-rc.1)
 
--   Merge develop into experimental
-    [\#815](https://github.com/matrix-org/matrix-js-sdk/pull/815)
--   Add a getAllEndToEndSessions to crypto store
-    [\#812](https://github.com/matrix-org/matrix-js-sdk/pull/812)
--   T3chguy/fix displayname logic
-    [\#668](https://github.com/matrix-org/matrix-js-sdk/pull/668)
--   Contributing: Note that rebase lets you mass signoff commits
-    [\#814](https://github.com/matrix-org/matrix-js-sdk/pull/814)
--   take into account homoglyphs when calculating similar display names
-    [\#672](https://github.com/matrix-org/matrix-js-sdk/pull/672)
--   Emit for key backup failures
-    [\#809](https://github.com/matrix-org/matrix-js-sdk/pull/809)
--   emit oldEventId on "updatePendingEvent"
-    [\#646](https://github.com/matrix-org/matrix-js-sdk/pull/646)
--   Add getThirdpartyUser to base api
-    [\#589](https://github.com/matrix-org/matrix-js-sdk/pull/589)
--   Support custom status messages
-    [\#805](https://github.com/matrix-org/matrix-js-sdk/pull/805)
--   Extra checks to avoid release script blowing up mid-process.
-    [\#749](https://github.com/matrix-org/matrix-js-sdk/pull/749)
--   Move glob regex utilities out of the pushprocessor and into a more generic
-    place
-    [\#800](https://github.com/matrix-org/matrix-js-sdk/pull/800)
-
-# Changes in [0.14.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2) (2018-12-10)
-
+ * Merge develop into experimental
+   [\#815](https://github.com/matrix-org/matrix-js-sdk/pull/815)
+ * Add a getAllEndToEndSessions to crypto store
+   [\#812](https://github.com/matrix-org/matrix-js-sdk/pull/812)
+ * T3chguy/fix displayname logic
+   [\#668](https://github.com/matrix-org/matrix-js-sdk/pull/668)
+ * Contributing: Note that rebase lets you mass signoff commits
+   [\#814](https://github.com/matrix-org/matrix-js-sdk/pull/814)
+ * take into account homoglyphs when calculating similar display names
+   [\#672](https://github.com/matrix-org/matrix-js-sdk/pull/672)
+ * Emit for key backup failures
+   [\#809](https://github.com/matrix-org/matrix-js-sdk/pull/809)
+ * emit oldEventId on "updatePendingEvent"
+   [\#646](https://github.com/matrix-org/matrix-js-sdk/pull/646)
+ * Add getThirdpartyUser to base api
+   [\#589](https://github.com/matrix-org/matrix-js-sdk/pull/589)
+ * Support custom status messages
+   [\#805](https://github.com/matrix-org/matrix-js-sdk/pull/805)
+ * Extra checks to avoid release script blowing up mid-process.
+   [\#749](https://github.com/matrix-org/matrix-js-sdk/pull/749)
+ * Move glob regex utilities out of the pushprocessor and into a more generic
+   place
+   [\#800](https://github.com/matrix-org/matrix-js-sdk/pull/800)
+
+Changes in [0.14.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2) (2018-12-10)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.2-rc.1...v0.14.2)
 
--   No changes since rc.1
-
-# Changes in [0.14.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2-rc.1) (2018-12-06)
+ * No changes since rc.1
 
+Changes in [0.14.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.2-rc.1) (2018-12-06)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.1...v0.14.2-rc.1)
 
--   fix some assertions in e2e backup unit test
-    [\#794](https://github.com/matrix-org/matrix-js-sdk/pull/794)
--   Config should be called with auth
-    [\#798](https://github.com/matrix-org/matrix-js-sdk/pull/798)
--   Don't re-establish sessions with unknown devices
-    [\#792](https://github.com/matrix-org/matrix-js-sdk/pull/792)
--   e2e key backups
-    [\#684](https://github.com/matrix-org/matrix-js-sdk/pull/684)
--   WIP: online incremental megolm backups
-    [\#595](https://github.com/matrix-org/matrix-js-sdk/pull/595)
--   Support for e2e key backups
-    [\#736](https://github.com/matrix-org/matrix-js-sdk/pull/736)
--   Passphrase Support for e2e backups
-    [\#786](https://github.com/matrix-org/matrix-js-sdk/pull/786)
--   Add 'getSsoLoginUrl' function
-    [\#783](https://github.com/matrix-org/matrix-js-sdk/pull/783)
--   Fix: don't set the room name to null when heroes are missing.
-    [\#784](https://github.com/matrix-org/matrix-js-sdk/pull/784)
--   Handle crypto db version upgrades
-    [\#785](https://github.com/matrix-org/matrix-js-sdk/pull/785)
--   Restart broken Olm sessions
-    [\#780](https://github.com/matrix-org/matrix-js-sdk/pull/780)
--   Use the last olm session that got a message
-    [\#776](https://github.com/matrix-org/matrix-js-sdk/pull/776)
-
-# Changes in [0.14.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.1) (2018-11-22)
-
+ * fix some assertions in e2e backup unit test
+   [\#794](https://github.com/matrix-org/matrix-js-sdk/pull/794)
+ * Config should be called with auth
+   [\#798](https://github.com/matrix-org/matrix-js-sdk/pull/798)
+ * Don't re-establish sessions with unknown devices
+   [\#792](https://github.com/matrix-org/matrix-js-sdk/pull/792)
+ * e2e key backups
+   [\#684](https://github.com/matrix-org/matrix-js-sdk/pull/684)
+ * WIP: online incremental megolm backups
+   [\#595](https://github.com/matrix-org/matrix-js-sdk/pull/595)
+ * Support for e2e key backups
+   [\#736](https://github.com/matrix-org/matrix-js-sdk/pull/736)
+ * Passphrase Support for e2e backups
+   [\#786](https://github.com/matrix-org/matrix-js-sdk/pull/786)
+ * Add 'getSsoLoginUrl' function
+   [\#783](https://github.com/matrix-org/matrix-js-sdk/pull/783)
+ * Fix: don't set the room name to null when heroes are missing.
+   [\#784](https://github.com/matrix-org/matrix-js-sdk/pull/784)
+ * Handle crypto db version upgrades
+   [\#785](https://github.com/matrix-org/matrix-js-sdk/pull/785)
+ * Restart broken Olm sessions
+   [\#780](https://github.com/matrix-org/matrix-js-sdk/pull/780)
+ * Use the last olm session that got a message
+   [\#776](https://github.com/matrix-org/matrix-js-sdk/pull/776)
+
+Changes in [0.14.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.1) (2018-11-22)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.0...v0.14.1)
 
--   Warning when crypto DB is too new to use.
-
-# Changes in [0.14.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0) (2018-11-19)
+ * Warning when crypto DB is too new to use.
 
+Changes in [0.14.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0) (2018-11-19)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.14.0-rc.1...v0.14.0)
 
--   No changes since rc.1
-
-# Changes in [0.14.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0-rc.1) (2018-11-15)
+ * No changes since rc.1
 
+Changes in [0.14.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.14.0-rc.1) (2018-11-15)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.13.1...v0.14.0-rc.1)
 
-## BREAKING CHANGE
-
--   js-sdk now uses Olm 3.0. Apps using Olm must update to 3.0 to
-    continue using Olm with the js-sdk. The js-sdk will call Olm's
-    init() method when the client is started.
-
-## All Changes
-
--   Prevent messages from being sent if other messages have failed to send
-    [\#781](https://github.com/matrix-org/matrix-js-sdk/pull/781)
--   A unit test for olm
-    [\#777](https://github.com/matrix-org/matrix-js-sdk/pull/777)
--   Set access_token and user_id after login in with username and password.
-    [\#778](https://github.com/matrix-org/matrix-js-sdk/pull/778)
--   Add function to get currently joined rooms.
-    [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
--   Remove the request-only stuff we don't need anymore
-    [\#775](https://github.com/matrix-org/matrix-js-sdk/pull/775)
--   Manually construct query strings for browser-request instances
-    [\#770](https://github.com/matrix-org/matrix-js-sdk/pull/770)
--   Fix: correctly check for crypto being present
-    [\#769](https://github.com/matrix-org/matrix-js-sdk/pull/769)
--   Update babel-eslint to 8.1.1
-    [\#768](https://github.com/matrix-org/matrix-js-sdk/pull/768)
--   Support `request` in the browser and support supplying servers to try in
-    joinRoom()
-    [\#764](https://github.com/matrix-org/matrix-js-sdk/pull/764)
--   loglevel should be a normal dependency
-    [\#767](https://github.com/matrix-org/matrix-js-sdk/pull/767)
--   Stop devicelist when client is stopped
-    [\#766](https://github.com/matrix-org/matrix-js-sdk/pull/766)
--   Update to WebAssembly-powered Olm
-    [\#743](https://github.com/matrix-org/matrix-js-sdk/pull/743)
--   Logging lib. Fixes #332
-    [\#763](https://github.com/matrix-org/matrix-js-sdk/pull/763)
--   Use new stop() method on matrix-mock-request
-    [\#765](https://github.com/matrix-org/matrix-js-sdk/pull/765)
-
-# Changes in [0.13.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.1) (2018-11-14)
-
+BREAKING CHANGE
+----------------
+
+ * js-sdk now uses Olm 3.0. Apps using Olm must update to 3.0 to
+   continue using Olm with the js-sdk. The js-sdk will call Olm's
+   init() method when the client is started.
+
+All Changes
+-----------
+
+ * Prevent messages from being sent if other messages have failed to send
+   [\#781](https://github.com/matrix-org/matrix-js-sdk/pull/781)
+ * A unit test for olm
+   [\#777](https://github.com/matrix-org/matrix-js-sdk/pull/777)
+ * Set access_token and user_id after login in with username and password.
+   [\#778](https://github.com/matrix-org/matrix-js-sdk/pull/778)
+ * Add function to get currently joined rooms.
+   [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
+ * Remove the request-only stuff we don't need anymore
+   [\#775](https://github.com/matrix-org/matrix-js-sdk/pull/775)
+ * Manually construct query strings for browser-request instances
+   [\#770](https://github.com/matrix-org/matrix-js-sdk/pull/770)
+ * Fix: correctly check for crypto being present
+   [\#769](https://github.com/matrix-org/matrix-js-sdk/pull/769)
+ * Update babel-eslint to 8.1.1
+   [\#768](https://github.com/matrix-org/matrix-js-sdk/pull/768)
+ * Support `request` in the browser and support supplying servers to try in
+   joinRoom()
+   [\#764](https://github.com/matrix-org/matrix-js-sdk/pull/764)
+ * loglevel should be a normal dependency
+   [\#767](https://github.com/matrix-org/matrix-js-sdk/pull/767)
+ * Stop devicelist when client is stopped
+   [\#766](https://github.com/matrix-org/matrix-js-sdk/pull/766)
+ * Update to WebAssembly-powered Olm
+   [\#743](https://github.com/matrix-org/matrix-js-sdk/pull/743)
+ * Logging lib. Fixes #332
+   [\#763](https://github.com/matrix-org/matrix-js-sdk/pull/763)
+ * Use new stop() method on matrix-mock-request
+   [\#765](https://github.com/matrix-org/matrix-js-sdk/pull/765)
+
+Changes in [0.13.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.1) (2018-11-14)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.13.0...v0.13.1)
 
--   Add function to get currently joined rooms.
-    [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
-
-# Changes in [0.13.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.0) (2018-11-15)
+ * Add function to get currently joined rooms.
+   [\#779](https://github.com/matrix-org/matrix-js-sdk/pull/779)
 
+Changes in [0.13.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.13.0) (2018-11-15)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.1...v0.13.0)
 
-## BREAKING CHANGE
-
--   `MatrixClient::login` now sets client `access_token` and `user_id` following successful login with username and password.
-
-# Changes in [0.12.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1) (2018-10-29)
+BREAKING CHANGE
+----------------
+ * `MatrixClient::login` now sets client `access_token` and `user_id` following successful login with username and password.
 
+Changes in [0.12.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1) (2018-10-29)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.1-rc.1...v0.12.1)
 
--   No changes since rc.1
-
-# Changes in [0.12.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1-rc.1) (2018-10-24)
+ * No changes since rc.1
 
+Changes in [0.12.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.1-rc.1) (2018-10-24)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.0...v0.12.1-rc.1)
 
--   Add repository type to package.json to make it valid
-    [\#762](https://github.com/matrix-org/matrix-js-sdk/pull/762)
--   Add getMediaConfig()
-    [\#761](https://github.com/matrix-org/matrix-js-sdk/pull/761)
--   add new examples, to be expanded into a post
-    [\#739](https://github.com/matrix-org/matrix-js-sdk/pull/739)
-
-# Changes in [0.12.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0) (2018-10-16)
+ * Add repository type to package.json to make it valid
+   [\#762](https://github.com/matrix-org/matrix-js-sdk/pull/762)
+ * Add getMediaConfig()
+   [\#761](https://github.com/matrix-org/matrix-js-sdk/pull/761)
+ * add new examples, to be expanded into a post
+   [\#739](https://github.com/matrix-org/matrix-js-sdk/pull/739)
 
+Changes in [0.12.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0) (2018-10-16)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.12.0-rc.1...v0.12.0)
 
--   No changes since rc.1
-
-# Changes in [0.12.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0-rc.1) (2018-10-11)
+ * No changes since rc.1
 
+Changes in [0.12.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.12.0-rc.1) (2018-10-11)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.1...v0.12.0-rc.1)
 
-## BREAKING CHANGES
-
--   If js-sdk finds data in the store that is incompatible with the options currently being used,
-    it will emit sync state ERROR with an error of type InvalidStoreError. It will also stop trying
-    to sync in this situation: the app must stop the client and then either clear the store or
-    change the options (in this case, enable or disable lazy loading of members) and then start
-    the client again.
-
-## All Changes
-
--   never replace /sync'ed memberships with OOB ones
-    [\#760](https://github.com/matrix-org/matrix-js-sdk/pull/760)
--   Don't fail to start up if lazy load check fails
-    [\#759](https://github.com/matrix-org/matrix-js-sdk/pull/759)
--   Make e2e work on Edge
-    [\#754](https://github.com/matrix-org/matrix-js-sdk/pull/754)
--   throw error with same name and message over idb worker boundary
-    [\#758](https://github.com/matrix-org/matrix-js-sdk/pull/758)
--   Default to a room version of 1 when there is no room create event
-    [\#755](https://github.com/matrix-org/matrix-js-sdk/pull/755)
--   Silence bluebird warnings
-    [\#757](https://github.com/matrix-org/matrix-js-sdk/pull/757)
--   allow non-ff merge from release branch into master
-    [\#750](https://github.com/matrix-org/matrix-js-sdk/pull/750)
--   Reject with the actual error on indexeddb error
-    [\#751](https://github.com/matrix-org/matrix-js-sdk/pull/751)
--   Update mocha to v5
-    [\#744](https://github.com/matrix-org/matrix-js-sdk/pull/744)
--   disable lazy loading for guests as they cant create filters
-    [\#748](https://github.com/matrix-org/matrix-js-sdk/pull/748)
--   Revert "Add getMediaLimits to client"
-    [\#745](https://github.com/matrix-org/matrix-js-sdk/pull/745)
-
-# Changes in [0.11.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1) (2018-10-01)
-
+BREAKING CHANGES
+----------------
+ * If js-sdk finds data in the store that is incompatible with the options currently being used,
+   it will emit sync state ERROR with an error of type InvalidStoreError. It will also stop trying
+   to sync in this situation: the app must stop the client and then either clear the store or
+   change the options (in this case, enable or disable lazy loading of members) and then start
+   the client again.
+
+All Changes
+-----------
+
+ * never replace /sync'ed memberships with OOB ones
+   [\#760](https://github.com/matrix-org/matrix-js-sdk/pull/760)
+ * Don't fail to start up if lazy load check fails
+   [\#759](https://github.com/matrix-org/matrix-js-sdk/pull/759)
+ * Make e2e work on Edge
+   [\#754](https://github.com/matrix-org/matrix-js-sdk/pull/754)
+ * throw error with same name and message over idb worker boundary
+   [\#758](https://github.com/matrix-org/matrix-js-sdk/pull/758)
+ * Default to a room version of 1 when there is no room create event
+   [\#755](https://github.com/matrix-org/matrix-js-sdk/pull/755)
+ * Silence bluebird warnings
+   [\#757](https://github.com/matrix-org/matrix-js-sdk/pull/757)
+ * allow non-ff merge from release branch into master
+   [\#750](https://github.com/matrix-org/matrix-js-sdk/pull/750)
+ * Reject with the actual error on indexeddb error
+   [\#751](https://github.com/matrix-org/matrix-js-sdk/pull/751)
+ * Update mocha to v5
+   [\#744](https://github.com/matrix-org/matrix-js-sdk/pull/744)
+ * disable lazy loading for guests as they cant create filters
+   [\#748](https://github.com/matrix-org/matrix-js-sdk/pull/748)
+ * Revert "Add getMediaLimits to client"
+   [\#745](https://github.com/matrix-org/matrix-js-sdk/pull/745)
+
+Changes in [0.11.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1) (2018-10-01)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.1-rc.1...v0.11.1)
 
--   No changes since rc.1
-
-# Changes in [0.11.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1-rc.1) (2018-09-27)
+ * No changes since rc.1
 
+Changes in [0.11.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.1-rc.1) (2018-09-27)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.0...v0.11.1-rc.1)
 
--   make usage of hub compatible with latest version (2.5)
-    [\#747](https://github.com/matrix-org/matrix-js-sdk/pull/747)
--   Detect when lazy loading has been toggled in client.startClient
-    [\#746](https://github.com/matrix-org/matrix-js-sdk/pull/746)
--   Add getMediaLimits to client
-    [\#644](https://github.com/matrix-org/matrix-js-sdk/pull/644)
--   Split npm start into an init and watch script
-    [\#742](https://github.com/matrix-org/matrix-js-sdk/pull/742)
--   Revert "room name should only take canonical alias into account"
-    [\#738](https://github.com/matrix-org/matrix-js-sdk/pull/738)
--   fix display name disambiguation with LL
-    [\#737](https://github.com/matrix-org/matrix-js-sdk/pull/737)
--   Introduce Room.myMembership event
-    [\#735](https://github.com/matrix-org/matrix-js-sdk/pull/735)
--   room name should only take canonical alias into account
-    [\#733](https://github.com/matrix-org/matrix-js-sdk/pull/733)
--   state events from context response were not wrapped in a MatrixEvent
-    [\#732](https://github.com/matrix-org/matrix-js-sdk/pull/732)
--   Reduce amount of promises created when inserting members
-    [\#724](https://github.com/matrix-org/matrix-js-sdk/pull/724)
--   dont wait for LL members to be stored to resolve the members
-    [\#726](https://github.com/matrix-org/matrix-js-sdk/pull/726)
--   RoomState.members emitted with wrong argument order for OOB members
-    [\#728](https://github.com/matrix-org/matrix-js-sdk/pull/728)
-
-# Changes in [0.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0) (2018-09-10)
-
+ * make usage of hub compatible with latest version (2.5)
+   [\#747](https://github.com/matrix-org/matrix-js-sdk/pull/747)
+ * Detect when lazy loading has been toggled in client.startClient
+   [\#746](https://github.com/matrix-org/matrix-js-sdk/pull/746)
+ * Add getMediaLimits to client
+   [\#644](https://github.com/matrix-org/matrix-js-sdk/pull/644)
+ * Split npm start into an init and watch script
+   [\#742](https://github.com/matrix-org/matrix-js-sdk/pull/742)
+ * Revert "room name should only take canonical alias into account"
+   [\#738](https://github.com/matrix-org/matrix-js-sdk/pull/738)
+ * fix display name disambiguation with LL
+   [\#737](https://github.com/matrix-org/matrix-js-sdk/pull/737)
+ * Introduce Room.myMembership event
+   [\#735](https://github.com/matrix-org/matrix-js-sdk/pull/735)
+ * room name should only take canonical alias into account
+   [\#733](https://github.com/matrix-org/matrix-js-sdk/pull/733)
+ * state events from context response were not wrapped in a MatrixEvent
+   [\#732](https://github.com/matrix-org/matrix-js-sdk/pull/732)
+ * Reduce amount of promises created when inserting members
+   [\#724](https://github.com/matrix-org/matrix-js-sdk/pull/724)
+ * dont wait for LL members to be stored to resolve the members
+   [\#726](https://github.com/matrix-org/matrix-js-sdk/pull/726)
+ * RoomState.members emitted with wrong argument order for OOB members
+   [\#728](https://github.com/matrix-org/matrix-js-sdk/pull/728)
+
+Changes in [0.11.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0) (2018-09-10)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.11.0-rc.1...v0.11.0)
 
-## BREAKING CHANGES
-
--   v0.11.0-rc.1 introduced some breaking changes - see the respective release notes.
+BREAKING CHANGES
+----------------
+ * v0.11.0-rc.1 introduced some breaking changes - see the respective release notes.
 
 No changes since rc.1
 
-# Changes in [0.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0-rc.1) (2018-09-07)
-
+Changes in [0.11.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.11.0-rc.1) (2018-09-07)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.9...v0.11.0-rc.1)
 
--   Support for lazy loading members. This should improve performance for
-    users who joined big rooms a lot. Pass to `lazyLoadMembers = true` option when calling `startClient`.
-
-## BREAKING CHANGES
-
--   `MatrixClient::startClient` now returns a Promise. No method should be called on the client before that promise resolves. Before this method didn't return anything.
--   A new `CATCHUP` sync state, emitted by `MatrixClient#"sync"` and returned by `MatrixClient::getSyncState()`, when doing initial sync after the `ERROR` state. See `MatrixClient` documentation for details.
--   `RoomState::maySendEvent('m.room.message', userId)` & `RoomState::maySendMessage(userId)` do not check the membership of the user anymore, only the power level. To check if the syncing user is allowed to write in a room, use `Room::maySendMessage()` as `RoomState` is not always aware of the syncing user's membership anymore, in case lazy loading of members is enabled.
-
-## All Changes
-
--   Only emit CATCHUP if recovering from conn error
-    [\#727](https://github.com/matrix-org/matrix-js-sdk/pull/727)
--   Fix docstring for sync data.error
-    [\#725](https://github.com/matrix-org/matrix-js-sdk/pull/725)
--   Re-apply "Don't rely on members to query if syncing user can post to room"
-    [\#723](https://github.com/matrix-org/matrix-js-sdk/pull/723)
--   Revert "Don't rely on members to query if syncing user can post to room"
-    [\#721](https://github.com/matrix-org/matrix-js-sdk/pull/721)
--   Don't rely on members to query if syncing user can post to room
-    [\#717](https://github.com/matrix-org/matrix-js-sdk/pull/717)
--   Fixes for room.guessDMUserId
-    [\#719](https://github.com/matrix-org/matrix-js-sdk/pull/719)
--   Fix filepanel also filtering main timeline with LL turned on.
-    [\#716](https://github.com/matrix-org/matrix-js-sdk/pull/716)
--   Remove lazy loaded members when leaving room
-    [\#711](https://github.com/matrix-org/matrix-js-sdk/pull/711)
--   Fix: show spinner again while recovering from connection error
-    [\#702](https://github.com/matrix-org/matrix-js-sdk/pull/702)
--   Add method to query LL state in client
-    [\#714](https://github.com/matrix-org/matrix-js-sdk/pull/714)
--   Fix: also load invited members when lazy loading members
-    [\#707](https://github.com/matrix-org/matrix-js-sdk/pull/707)
--   Pass through function to discard megolm session
-    [\#704](https://github.com/matrix-org/matrix-js-sdk/pull/704)
-
-# Changes in [0.10.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9) (2018-09-03)
-
+ * Support for lazy loading members. This should improve performance for
+   users who joined big rooms a lot. Pass to `lazyLoadMembers = true` option when calling `startClient`.
+
+BREAKING CHANGES
+----------------
+
+ * `MatrixClient::startClient` now returns a Promise. No method should be called on the client before that promise resolves. Before this method didn't return anything.
+ * A new `CATCHUP` sync state, emitted by `MatrixClient#"sync"` and returned by `MatrixClient::getSyncState()`, when doing initial sync after the `ERROR` state. See `MatrixClient` documentation for details.
+ * `RoomState::maySendEvent('m.room.message', userId)` & `RoomState::maySendMessage(userId)` do not check the membership of the user anymore, only the power level. To check if the syncing user is allowed to write in a room, use `Room::maySendMessage()` as `RoomState` is not always aware of the syncing user's membership anymore, in case lazy loading of members is enabled.
+
+All Changes
+-----------
+
+ * Only emit CATCHUP if recovering from conn error
+   [\#727](https://github.com/matrix-org/matrix-js-sdk/pull/727)
+ * Fix docstring for sync data.error
+   [\#725](https://github.com/matrix-org/matrix-js-sdk/pull/725)
+ * Re-apply "Don't rely on members to query if syncing user can post to room"
+   [\#723](https://github.com/matrix-org/matrix-js-sdk/pull/723)
+ * Revert "Don't rely on members to query if syncing user can post to room"
+   [\#721](https://github.com/matrix-org/matrix-js-sdk/pull/721)
+ * Don't rely on members to query if syncing user can post to room
+   [\#717](https://github.com/matrix-org/matrix-js-sdk/pull/717)
+ * Fixes for room.guessDMUserId
+   [\#719](https://github.com/matrix-org/matrix-js-sdk/pull/719)
+ * Fix filepanel also filtering main timeline with LL turned on.
+   [\#716](https://github.com/matrix-org/matrix-js-sdk/pull/716)
+ * Remove lazy loaded members when leaving room
+   [\#711](https://github.com/matrix-org/matrix-js-sdk/pull/711)
+ * Fix: show spinner again while recovering from connection error
+   [\#702](https://github.com/matrix-org/matrix-js-sdk/pull/702)
+ * Add method to query LL state in client
+   [\#714](https://github.com/matrix-org/matrix-js-sdk/pull/714)
+ * Fix: also load invited members when lazy loading members
+   [\#707](https://github.com/matrix-org/matrix-js-sdk/pull/707)
+ * Pass through function to discard megolm session
+   [\#704](https://github.com/matrix-org/matrix-js-sdk/pull/704)
+
+Changes in [0.10.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9) (2018-09-03)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.9-rc.2...v0.10.9)
 
--   No changes since rc.2
-
-# Changes in [0.10.9-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.2) (2018-08-31)
+ * No changes since rc.2
 
+Changes in [0.10.9-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.2) (2018-08-31)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.9-rc.1...v0.10.9-rc.2)
 
--   Fix for "otherMember.getAvatarUrl is not a function"
-    [\#708](https://github.com/matrix-org/matrix-js-sdk/pull/708)
-
-# Changes in [0.10.9-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.1) (2018-08-30)
+ * Fix for "otherMember.getAvatarUrl is not a function"
+   [\#708](https://github.com/matrix-org/matrix-js-sdk/pull/708)
 
+Changes in [0.10.9-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.9-rc.1) (2018-08-30)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.8...v0.10.9-rc.1)
 
--   Fix DM avatar
-    [\#706](https://github.com/matrix-org/matrix-js-sdk/pull/706)
--   Lazy loading: avoid loading members at initial sync for e2e rooms
-    [\#699](https://github.com/matrix-org/matrix-js-sdk/pull/699)
--   Improve setRoomEncryption guard against multiple m.room.encryption st…
-    [\#700](https://github.com/matrix-org/matrix-js-sdk/pull/700)
--   Revert "Lazy loading: don't block on setting up room crypto"
-    [\#698](https://github.com/matrix-org/matrix-js-sdk/pull/698)
--   Lazy loading: don't block on setting up room crypto
-    [\#696](https://github.com/matrix-org/matrix-js-sdk/pull/696)
--   Add getVisibleRooms()
-    [\#695](https://github.com/matrix-org/matrix-js-sdk/pull/695)
--   Add wrapper around getJoinedMemberCount()
-    [\#697](https://github.com/matrix-org/matrix-js-sdk/pull/697)
--   Api to fetch events via /room/.../event/..
-    [\#694](https://github.com/matrix-org/matrix-js-sdk/pull/694)
--   Support for room upgrades
-    [\#693](https://github.com/matrix-org/matrix-js-sdk/pull/693)
--   Lazy loading of room members
-    [\#691](https://github.com/matrix-org/matrix-js-sdk/pull/691)
-
-# Changes in [0.10.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8) (2018-08-20)
-
+ * Fix DM avatar
+   [\#706](https://github.com/matrix-org/matrix-js-sdk/pull/706)
+ * Lazy loading: avoid loading members at initial sync for e2e rooms
+   [\#699](https://github.com/matrix-org/matrix-js-sdk/pull/699)
+ * Improve setRoomEncryption guard against multiple m.room.encryption st…
+   [\#700](https://github.com/matrix-org/matrix-js-sdk/pull/700)
+ * Revert "Lazy loading: don't block on setting up room crypto"
+   [\#698](https://github.com/matrix-org/matrix-js-sdk/pull/698)
+ * Lazy loading: don't block on setting up room crypto
+   [\#696](https://github.com/matrix-org/matrix-js-sdk/pull/696)
+ * Add getVisibleRooms()
+   [\#695](https://github.com/matrix-org/matrix-js-sdk/pull/695)
+ * Add wrapper around getJoinedMemberCount()
+   [\#697](https://github.com/matrix-org/matrix-js-sdk/pull/697)
+ * Api to fetch events via /room/.../event/..
+   [\#694](https://github.com/matrix-org/matrix-js-sdk/pull/694)
+ * Support for room upgrades
+   [\#693](https://github.com/matrix-org/matrix-js-sdk/pull/693)
+ * Lazy loading of room members
+   [\#691](https://github.com/matrix-org/matrix-js-sdk/pull/691)
+
+Changes in [0.10.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8) (2018-08-20)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.8-rc.1...v0.10.8)
 
--   No changes since rc.1
-
-# Changes in [0.10.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8-rc.1) (2018-08-16)
+ * No changes since rc.1
 
+Changes in [0.10.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.8-rc.1) (2018-08-16)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.7...v0.10.8-rc.1)
 
--   Add getVersion to Room
-    [\#689](https://github.com/matrix-org/matrix-js-sdk/pull/689)
--   Add getSyncStateData()
-    [\#680](https://github.com/matrix-org/matrix-js-sdk/pull/680)
--   Send sync error to listener
-    [\#679](https://github.com/matrix-org/matrix-js-sdk/pull/679)
--   make sure room.tags is always a valid object to avoid crashes
-    [\#675](https://github.com/matrix-org/matrix-js-sdk/pull/675)
--   Fix infinite spinner upon joining a room
-    [\#673](https://github.com/matrix-org/matrix-js-sdk/pull/673)
-
-# Changes in [0.10.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7) (2018-07-30)
-
+ * Add getVersion to Room
+   [\#689](https://github.com/matrix-org/matrix-js-sdk/pull/689)
+ * Add getSyncStateData()
+   [\#680](https://github.com/matrix-org/matrix-js-sdk/pull/680)
+ * Send sync error to listener
+   [\#679](https://github.com/matrix-org/matrix-js-sdk/pull/679)
+ * make sure room.tags is always a valid object to avoid crashes
+   [\#675](https://github.com/matrix-org/matrix-js-sdk/pull/675)
+ * Fix infinite spinner upon joining a room
+   [\#673](https://github.com/matrix-org/matrix-js-sdk/pull/673)
+
+Changes in [0.10.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7) (2018-07-30)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.7-rc.1...v0.10.7)
 
--   No changes since rc.1
-
-# Changes in [0.10.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7-rc.1) (2018-07-24)
+ * No changes since rc.1
 
+Changes in [0.10.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.7-rc.1) (2018-07-24)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.6...v0.10.7-rc.1)
 
--   encrypt for invited users if history visibility allows.
-    [\#666](https://github.com/matrix-org/matrix-js-sdk/pull/666)
-
-# Changes in [0.10.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6) (2018-07-09)
+ * encrypt for invited users if history visibility allows.
+   [\#666](https://github.com/matrix-org/matrix-js-sdk/pull/666)
 
+Changes in [0.10.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6) (2018-07-09)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.6-rc.1...v0.10.6)
 
--   No changes since rc.1
-
-# Changes in [0.10.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6-rc.1) (2018-07-06)
+ * No changes since rc.1
 
+Changes in [0.10.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.6-rc.1) (2018-07-06)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.5...v0.10.6-rc.1)
 
--   Expose event decryption error via Event.decrypted event
-    [\#665](https://github.com/matrix-org/matrix-js-sdk/pull/665)
--   Add decryption error codes to base.DecryptionError
-    [\#663](https://github.com/matrix-org/matrix-js-sdk/pull/663)
-
-# Changes in [0.10.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5) (2018-06-29)
+ * Expose event decryption error via Event.decrypted event
+   [\#665](https://github.com/matrix-org/matrix-js-sdk/pull/665)
+ * Add decryption error codes to base.DecryptionError
+   [\#663](https://github.com/matrix-org/matrix-js-sdk/pull/663)
 
+Changes in [0.10.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5) (2018-06-29)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.5-rc.1...v0.10.5)
 
--   No changes since rc.1
-
-# Changes in [0.10.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5-rc.1) (2018-06-21)
+ * No changes since rc.1
 
+Changes in [0.10.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.5-rc.1) (2018-06-21)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.4...v0.10.5-rc.1)
 
--   fix auth header and filename=undefined
-    [\#659](https://github.com/matrix-org/matrix-js-sdk/pull/659)
--   allow setting the output device for webrtc calls
-    [\#650](https://github.com/matrix-org/matrix-js-sdk/pull/650)
--   arguments true and false are actually invalid
-    [\#596](https://github.com/matrix-org/matrix-js-sdk/pull/596)
--   fix typo where `headers` was not being used and thus sent wrong content-type
-    [\#643](https://github.com/matrix-org/matrix-js-sdk/pull/643)
--   fix some documentation typos
-    [\#642](https://github.com/matrix-org/matrix-js-sdk/pull/642)
-
-# Changes in [0.10.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4) (2018-06-12)
-
+ * fix auth header and filename=undefined
+   [\#659](https://github.com/matrix-org/matrix-js-sdk/pull/659)
+ * allow setting the output device for webrtc calls
+   [\#650](https://github.com/matrix-org/matrix-js-sdk/pull/650)
+ * arguments true and false are actually invalid
+   [\#596](https://github.com/matrix-org/matrix-js-sdk/pull/596)
+ * fix typo where `headers` was not being used and thus sent wrong content-type
+   [\#643](https://github.com/matrix-org/matrix-js-sdk/pull/643)
+ * fix some documentation typos
+   [\#642](https://github.com/matrix-org/matrix-js-sdk/pull/642)
+
+Changes in [0.10.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4) (2018-06-12)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.4-rc.1...v0.10.4)
 
--   No changes since rc.1
-
-# Changes in [0.10.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4-rc.1) (2018-06-06)
+ * No changes since rc.1
 
+Changes in [0.10.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.4-rc.1) (2018-06-06)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.3...v0.10.4-rc.1)
 
--   check whether notif level is undefined, because `0` is falsey
-    [\#651](https://github.com/matrix-org/matrix-js-sdk/pull/651)
-
-# Changes in [0.10.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3) (2018-05-25)
+ * check whether notif level is undefined, because `0` is falsey
+   [\#651](https://github.com/matrix-org/matrix-js-sdk/pull/651)
 
+Changes in [0.10.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3) (2018-05-25)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.3-rc.1...v0.10.3)
 
--   No changes since v0.10.3-rc.1
-
-# Changes in [0.10.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3-rc.1) (2018-05-24)
+ * No changes since v0.10.3-rc.1
 
+Changes in [0.10.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.3-rc.1) (2018-05-24)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.2...v0.10.3-rc.1)
 
-## BREAKING CHANGE
+BREAKING CHANGE
+---------------
 
 The deprecated 'callback' parameter has been removed from MatrixBaseApis.deactivateAccount
 
--   Add `erase` option to deactivateAccount
-    [\#649](https://github.com/matrix-org/matrix-js-sdk/pull/649)
--   Emit Session.no_consent when M_CONSENT_NOT_GIVEN received
-    [\#647](https://github.com/matrix-org/matrix-js-sdk/pull/647)
-
-# Changes in [0.10.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2) (2018-04-30)
+ * Add `erase` option to deactivateAccount
+   [\#649](https://github.com/matrix-org/matrix-js-sdk/pull/649)
+ * Emit Session.no_consent when M_CONSENT_NOT_GIVEN received
+   [\#647](https://github.com/matrix-org/matrix-js-sdk/pull/647)
 
+Changes in [0.10.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2) (2018-04-30)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.2-rc.1...v0.10.2)
 
--   No changes from rc.1
-
-# Changes in [0.10.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2-rc.1) (2018-04-25)
+ * No changes from rc.1
 
+Changes in [0.10.2-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.2-rc.1) (2018-04-25)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.1...v0.10.2-rc.1)
 
--   Ignore inserts of dup inbound group sessions, pt 2
-    [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
--   Ignore inserts of duplicate inbound group sessions
-    [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
--   Log IDB errors
-    [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
--   Remove not very useful but veryv spammy log line
-    [\#632](https://github.com/matrix-org/matrix-js-sdk/pull/632)
--   Switch event type to m.sticker.
-    [\#628](https://github.com/matrix-org/matrix-js-sdk/pull/628)
-
-# Changes in [0.10.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.1) (2018-04-12)
-
+ * Ignore inserts of dup inbound group sessions, pt 2
+   [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
+ * Ignore inserts of duplicate inbound group sessions
+   [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
+ * Log IDB errors
+   [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
+ * Remove not very useful but veryv spammy log line
+   [\#632](https://github.com/matrix-org/matrix-js-sdk/pull/632)
+ * Switch event type to m.sticker.
+   [\#628](https://github.com/matrix-org/matrix-js-sdk/pull/628)
+
+Changes in [0.10.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.1) (2018-04-12)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.0...v0.10.1)
 
--   Log IDB errors
-    [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
--   Ignore inserts of duplicate inbound group sessions
-    [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
--   Ignore inserts of dup inbound group sessions, pt 2
-    [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
-
-# Changes in [0.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0) (2018-04-11)
+ * Log IDB errors
+   [\#638](https://github.com/matrix-org/matrix-js-sdk/pull/638)
+ * Ignore inserts of duplicate inbound group sessions
+   [\#639](https://github.com/matrix-org/matrix-js-sdk/pull/639)
+ * Ignore inserts of dup inbound group sessions, pt 2
+   [\#641](https://github.com/matrix-org/matrix-js-sdk/pull/641)
 
+Changes in [0.10.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0) (2018-04-11)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.0-rc.2...v0.10.0)
 
--   No changes
-
-# Changes in [0.10.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.2) (2018-04-09)
+ * No changes
 
+Changes in [0.10.0-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.2) (2018-04-09)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.10.0-rc.1...v0.10.0-rc.2)
 
--   Add wrapper for group join API
--   Add wrapped API to set group join_policy
-
-# Changes in [0.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.1) (2018-03-19)
+ * Add wrapper for group join API
+ * Add wrapped API to set group join\_policy
 
+Changes in [0.10.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.10.0-rc.1) (2018-03-19)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.2...v0.10.0-rc.1)
 
--   Fix duplicated state events in timeline from peek
-    [\#630](https://github.com/matrix-org/matrix-js-sdk/pull/630)
--   Create indexeddb worker when starting the store
-    [\#627](https://github.com/matrix-org/matrix-js-sdk/pull/627)
--   Fix indexeddb logging
-    [\#626](https://github.com/matrix-org/matrix-js-sdk/pull/626)
--   Don't do /keys/changes on incremental sync
-    [\#625](https://github.com/matrix-org/matrix-js-sdk/pull/625)
--   Don't mark devicelist dirty unnecessarily
-    [\#623](https://github.com/matrix-org/matrix-js-sdk/pull/623)
--   Cache the joined member count for a room state
-    [\#619](https://github.com/matrix-org/matrix-js-sdk/pull/619)
--   Fix JS doc
-    [\#618](https://github.com/matrix-org/matrix-js-sdk/pull/618)
--   Precompute push actions for state events
-    [\#617](https://github.com/matrix-org/matrix-js-sdk/pull/617)
--   Fix bug where global "Never send to unverified..." is ignored
-    [\#616](https://github.com/matrix-org/matrix-js-sdk/pull/616)
--   Intern legacy top-level 'membership' field
-    [\#615](https://github.com/matrix-org/matrix-js-sdk/pull/615)
--   Don't synthesize RR for m.room.redaction as causes the RR to go missing.
-    [\#598](https://github.com/matrix-org/matrix-js-sdk/pull/598)
--   Make Events create Dates on demand
-    [\#613](https://github.com/matrix-org/matrix-js-sdk/pull/613)
--   Stop cloning events when adding to state
-    [\#612](https://github.com/matrix-org/matrix-js-sdk/pull/612)
--   De-dup code: use the initialiseState function
-    [\#611](https://github.com/matrix-org/matrix-js-sdk/pull/611)
--   Create sentinel members on-demand
-    [\#610](https://github.com/matrix-org/matrix-js-sdk/pull/610)
--   Some more doc on how sentinels work
-    [\#609](https://github.com/matrix-org/matrix-js-sdk/pull/609)
--   Migrate room encryption store to crypto store
-    [\#597](https://github.com/matrix-org/matrix-js-sdk/pull/597)
--   add parameter to getIdentityServerUrl to strip the protocol for invites
-    [\#600](https://github.com/matrix-org/matrix-js-sdk/pull/600)
--   Move Device Tracking Data to Crypto Store
-    [\#594](https://github.com/matrix-org/matrix-js-sdk/pull/594)
--   Optimise pushprocessor
-    [\#591](https://github.com/matrix-org/matrix-js-sdk/pull/591)
--   Set event error before emitting
-    [\#592](https://github.com/matrix-org/matrix-js-sdk/pull/592)
--   Add event type for stickers [WIP]
-    [\#590](https://github.com/matrix-org/matrix-js-sdk/pull/590)
--   Migrate inbound sessions to cryptostore
-    [\#587](https://github.com/matrix-org/matrix-js-sdk/pull/587)
--   Disambiguate names if they contain an mxid
-    [\#588](https://github.com/matrix-org/matrix-js-sdk/pull/588)
--   Check for sessions in indexeddb before migrating
-    [\#585](https://github.com/matrix-org/matrix-js-sdk/pull/585)
--   Emit an event for crypto store migration
-    [\#586](https://github.com/matrix-org/matrix-js-sdk/pull/586)
--   Supporting fixes For making UnknownDeviceDialog not pop up automatically
-    [\#575](https://github.com/matrix-org/matrix-js-sdk/pull/575)
--   Move sessions to the crypto store
-    [\#584](https://github.com/matrix-org/matrix-js-sdk/pull/584)
--   Change crypto store transaction API
-    [\#582](https://github.com/matrix-org/matrix-js-sdk/pull/582)
--   Add some missed copyright notices
-    [\#581](https://github.com/matrix-org/matrix-js-sdk/pull/581)
--   Move Olm account to IndexedDB
-    [\#579](https://github.com/matrix-org/matrix-js-sdk/pull/579)
--   Fix logging of DecryptionErrors to be more useful
-    [\#580](https://github.com/matrix-org/matrix-js-sdk/pull/580)
--   [BREAKING] Change the behaviour of the unverfied devices blacklist flag
-    [\#568](https://github.com/matrix-org/matrix-js-sdk/pull/568)
--   Support set_presence=offline for syncing
-    [\#557](https://github.com/matrix-org/matrix-js-sdk/pull/557)
--   Consider cases where the sender may not redact their own event
-    [\#556](https://github.com/matrix-org/matrix-js-sdk/pull/556)
-
-# Changes in [0.9.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.2) (2017-12-04)
-
+ * Fix duplicated state events in timeline from peek
+   [\#630](https://github.com/matrix-org/matrix-js-sdk/pull/630)
+ * Create indexeddb worker when starting the store
+   [\#627](https://github.com/matrix-org/matrix-js-sdk/pull/627)
+ * Fix indexeddb logging
+   [\#626](https://github.com/matrix-org/matrix-js-sdk/pull/626)
+ * Don't do /keys/changes on incremental sync
+   [\#625](https://github.com/matrix-org/matrix-js-sdk/pull/625)
+ * Don't mark devicelist dirty unnecessarily
+   [\#623](https://github.com/matrix-org/matrix-js-sdk/pull/623)
+ * Cache the joined member count for a room state
+   [\#619](https://github.com/matrix-org/matrix-js-sdk/pull/619)
+ * Fix JS doc
+   [\#618](https://github.com/matrix-org/matrix-js-sdk/pull/618)
+ * Precompute push actions for state events
+   [\#617](https://github.com/matrix-org/matrix-js-sdk/pull/617)
+ * Fix bug where global "Never send to unverified..." is ignored
+   [\#616](https://github.com/matrix-org/matrix-js-sdk/pull/616)
+ * Intern legacy top-level 'membership' field
+   [\#615](https://github.com/matrix-org/matrix-js-sdk/pull/615)
+ * Don't synthesize RR for m.room.redaction as causes the RR to go missing.
+   [\#598](https://github.com/matrix-org/matrix-js-sdk/pull/598)
+ * Make Events create Dates on demand
+   [\#613](https://github.com/matrix-org/matrix-js-sdk/pull/613)
+ * Stop cloning events when adding to state
+   [\#612](https://github.com/matrix-org/matrix-js-sdk/pull/612)
+ * De-dup code: use the initialiseState function
+   [\#611](https://github.com/matrix-org/matrix-js-sdk/pull/611)
+ * Create sentinel members on-demand
+   [\#610](https://github.com/matrix-org/matrix-js-sdk/pull/610)
+ * Some more doc on how sentinels work
+   [\#609](https://github.com/matrix-org/matrix-js-sdk/pull/609)
+ * Migrate room encryption store to crypto store
+   [\#597](https://github.com/matrix-org/matrix-js-sdk/pull/597)
+ * add parameter to getIdentityServerUrl to strip the protocol for invites
+   [\#600](https://github.com/matrix-org/matrix-js-sdk/pull/600)
+ * Move Device Tracking Data to Crypto Store
+   [\#594](https://github.com/matrix-org/matrix-js-sdk/pull/594)
+ * Optimise pushprocessor
+   [\#591](https://github.com/matrix-org/matrix-js-sdk/pull/591)
+ * Set event error before emitting
+   [\#592](https://github.com/matrix-org/matrix-js-sdk/pull/592)
+ * Add event type for stickers [WIP]
+   [\#590](https://github.com/matrix-org/matrix-js-sdk/pull/590)
+ * Migrate inbound sessions to cryptostore
+   [\#587](https://github.com/matrix-org/matrix-js-sdk/pull/587)
+ * Disambiguate names if they contain an mxid
+   [\#588](https://github.com/matrix-org/matrix-js-sdk/pull/588)
+ * Check for sessions in indexeddb before migrating
+   [\#585](https://github.com/matrix-org/matrix-js-sdk/pull/585)
+ * Emit an event for crypto store migration
+   [\#586](https://github.com/matrix-org/matrix-js-sdk/pull/586)
+ * Supporting fixes For making UnknownDeviceDialog not pop up automatically
+   [\#575](https://github.com/matrix-org/matrix-js-sdk/pull/575)
+ * Move sessions to the crypto store
+   [\#584](https://github.com/matrix-org/matrix-js-sdk/pull/584)
+ * Change crypto store transaction API
+   [\#582](https://github.com/matrix-org/matrix-js-sdk/pull/582)
+ * Add some missed copyright notices
+   [\#581](https://github.com/matrix-org/matrix-js-sdk/pull/581)
+ * Move Olm account to IndexedDB
+   [\#579](https://github.com/matrix-org/matrix-js-sdk/pull/579)
+ * Fix logging of DecryptionErrors to be more useful
+   [\#580](https://github.com/matrix-org/matrix-js-sdk/pull/580)
+ * [BREAKING] Change the behaviour of the unverfied devices blacklist flag
+   [\#568](https://github.com/matrix-org/matrix-js-sdk/pull/568)
+ * Support set_presence=offline for syncing
+   [\#557](https://github.com/matrix-org/matrix-js-sdk/pull/557)
+ * Consider cases where the sender may not redact their own event
+   [\#556](https://github.com/matrix-org/matrix-js-sdk/pull/556)
+
+Changes in [0.9.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.2) (2017-12-04)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.1...v0.9.2)
 
-# Changes in [0.9.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.1) (2017-11-17)
 
+Changes in [0.9.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.1) (2017-11-17)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.0...v0.9.1)
 
--   Fix the force TURN option
-    [\#577](https://github.com/matrix-org/matrix-js-sdk/pull/577)
-
-# Changes in [0.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0) (2017-11-15)
+ * Fix the force TURN option
+   [\#577](https://github.com/matrix-org/matrix-js-sdk/pull/577)
 
+Changes in [0.9.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0) (2017-11-15)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.9.0-rc.1...v0.9.0)
 
-# Changes in [0.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0-rc.1) (2017-11-10)
 
+Changes in [0.9.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.9.0-rc.1) (2017-11-10)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.5...v0.9.0-rc.1)
 
--   Modify addRoomToGroup to allow setting isPublic, create alias
-    updateGroupRoomAssociation
-    [\#567](https://github.com/matrix-org/matrix-js-sdk/pull/567)
--   Expose more functionality of pushprocessor
-    [\#565](https://github.com/matrix-org/matrix-js-sdk/pull/565)
--   Function for working out notif trigger permission
-    [\#566](https://github.com/matrix-org/matrix-js-sdk/pull/566)
--   keep track of event ID and timestamp of decrypted messages
-    [\#555](https://github.com/matrix-org/matrix-js-sdk/pull/555)
--   Fix notifEvent computation
-    [\#564](https://github.com/matrix-org/matrix-js-sdk/pull/564)
--   Fix power level of sentinel members
-    [\#563](https://github.com/matrix-org/matrix-js-sdk/pull/563)
--   don't try to decrypt a redacted message (fixes vector-im/riot-web#3744)
-    [\#554](https://github.com/matrix-org/matrix-js-sdk/pull/554)
--   Support room notifs
-    [\#562](https://github.com/matrix-org/matrix-js-sdk/pull/562)
--   Fix the glob-to-regex code
-    [\#558](https://github.com/matrix-org/matrix-js-sdk/pull/558)
-
-# Changes in [0.8.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5) (2017-10-16)
-
+ * Modify addRoomToGroup to allow setting isPublic, create alias
+   updateGroupRoomAssociation
+   [\#567](https://github.com/matrix-org/matrix-js-sdk/pull/567)
+ * Expose more functionality of pushprocessor
+   [\#565](https://github.com/matrix-org/matrix-js-sdk/pull/565)
+ * Function for working out notif trigger permission
+   [\#566](https://github.com/matrix-org/matrix-js-sdk/pull/566)
+ * keep track of event ID and timestamp of decrypted messages
+   [\#555](https://github.com/matrix-org/matrix-js-sdk/pull/555)
+ * Fix notifEvent computation
+   [\#564](https://github.com/matrix-org/matrix-js-sdk/pull/564)
+ * Fix power level of sentinel members
+   [\#563](https://github.com/matrix-org/matrix-js-sdk/pull/563)
+ * don't try to decrypt a redacted message (fixes vector-im/riot-web#3744)
+   [\#554](https://github.com/matrix-org/matrix-js-sdk/pull/554)
+ * Support room notifs
+   [\#562](https://github.com/matrix-org/matrix-js-sdk/pull/562)
+ * Fix the glob-to-regex code
+   [\#558](https://github.com/matrix-org/matrix-js-sdk/pull/558)
+
+Changes in [0.8.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5) (2017-10-16)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.5-rc.1...v0.8.5)
 
--   Make unknown pushrule conditions not match
-    [\#559](https://github.com/matrix-org/matrix-js-sdk/pull/559)
-
-# Changes in [0.8.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5-rc.1) (2017-10-13)
+ * Make unknown pushrule conditions not match
+   [\#559](https://github.com/matrix-org/matrix-js-sdk/pull/559)
 
+Changes in [0.8.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.5-rc.1) (2017-10-13)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.4...v0.8.5-rc.1)
 
--   Implement wrapper API for removing a room from a group
-    [\#553](https://github.com/matrix-org/matrix-js-sdk/pull/553)
--   Fix typo which resulted in stuck key download requests
-    [\#552](https://github.com/matrix-org/matrix-js-sdk/pull/552)
--   Store group when it's created
-    [\#549](https://github.com/matrix-org/matrix-js-sdk/pull/549)
--   Luke/groups remove rooms users from summary
-    [\#548](https://github.com/matrix-org/matrix-js-sdk/pull/548)
--   Clean on prepublish
-    [\#546](https://github.com/matrix-org/matrix-js-sdk/pull/546)
--   Implement wrapper APIs for adding rooms to group summary
-    [\#545](https://github.com/matrix-org/matrix-js-sdk/pull/545)
-
-# Changes in [0.8.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.4) (2017-09-21)
-
+ * Implement wrapper API for removing a room from a group
+   [\#553](https://github.com/matrix-org/matrix-js-sdk/pull/553)
+ * Fix typo which resulted in stuck key download requests
+   [\#552](https://github.com/matrix-org/matrix-js-sdk/pull/552)
+ * Store group when it's created
+   [\#549](https://github.com/matrix-org/matrix-js-sdk/pull/549)
+ * Luke/groups remove rooms users from summary
+   [\#548](https://github.com/matrix-org/matrix-js-sdk/pull/548)
+ * Clean on prepublish
+   [\#546](https://github.com/matrix-org/matrix-js-sdk/pull/546)
+ * Implement wrapper APIs for adding rooms to group summary
+   [\#545](https://github.com/matrix-org/matrix-js-sdk/pull/545)
+
+Changes in [0.8.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.4) (2017-09-21)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.3...v0.8.4)
 
--   Fix build issue
-
-# Changes in [0.8.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3) (2017-09-20)
+ * Fix build issue
 
+Changes in [0.8.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3) (2017-09-20)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.3-rc.1...v0.8.3)
 
--   No changes
-
-# Changes in [0.8.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3-rc.1) (2017-09-19)
+ * No changes
 
+Changes in [0.8.3-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.3-rc.1) (2017-09-19)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.2...v0.8.3-rc.1)
 
--   consume trailing slash when creating Matrix Client in HS and IS urls
-    [\#526](https://github.com/matrix-org/matrix-js-sdk/pull/526)
--   Add ignore users API
-    [\#539](https://github.com/matrix-org/matrix-js-sdk/pull/539)
--   Upgrade to jsdoc 3.5.5
-    [\#540](https://github.com/matrix-org/matrix-js-sdk/pull/540)
--   Make re-emitting events much more memory efficient
-    [\#538](https://github.com/matrix-org/matrix-js-sdk/pull/538)
--   Only re-emit events from Event objects if needed
-    [\#536](https://github.com/matrix-org/matrix-js-sdk/pull/536)
--   Handle 'left' users in the deviceList mananagement
-    [\#535](https://github.com/matrix-org/matrix-js-sdk/pull/535)
--   Factor out devicelist integration tests to a separate file
-    [\#534](https://github.com/matrix-org/matrix-js-sdk/pull/534)
--   Refactor sync.\_sync as an async function
-    [\#533](https://github.com/matrix-org/matrix-js-sdk/pull/533)
--   Add es6 to eslint environments
-    [\#532](https://github.com/matrix-org/matrix-js-sdk/pull/532)
-
-# Changes in [0.8.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.2) (2017-08-24)
-
+ * consume trailing slash when creating Matrix Client in HS and IS urls
+   [\#526](https://github.com/matrix-org/matrix-js-sdk/pull/526)
+ * Add ignore users API
+   [\#539](https://github.com/matrix-org/matrix-js-sdk/pull/539)
+ * Upgrade to jsdoc 3.5.5
+   [\#540](https://github.com/matrix-org/matrix-js-sdk/pull/540)
+ * Make re-emitting events much more memory efficient
+   [\#538](https://github.com/matrix-org/matrix-js-sdk/pull/538)
+ * Only re-emit events from Event objects if needed
+   [\#536](https://github.com/matrix-org/matrix-js-sdk/pull/536)
+ * Handle 'left' users in the deviceList mananagement
+   [\#535](https://github.com/matrix-org/matrix-js-sdk/pull/535)
+ * Factor out devicelist integration tests to a separate file
+   [\#534](https://github.com/matrix-org/matrix-js-sdk/pull/534)
+ * Refactor sync._sync as an async function
+   [\#533](https://github.com/matrix-org/matrix-js-sdk/pull/533)
+ * Add es6 to eslint environments
+   [\#532](https://github.com/matrix-org/matrix-js-sdk/pull/532)
+
+Changes in [0.8.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.2) (2017-08-24)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.1...v0.8.2)
 
--   Handle m.call.\* events which are decrypted asynchronously
-    [\#530](https://github.com/matrix-org/matrix-js-sdk/pull/530)
--   Re-emit events from, er, Event objects
-    [\#529](https://github.com/matrix-org/matrix-js-sdk/pull/529)
-
-# Changes in [0.8.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1) (2017-08-23)
+ * Handle m.call.* events which are decrypted asynchronously
+   [\#530](https://github.com/matrix-org/matrix-js-sdk/pull/530)
+ * Re-emit events from, er, Event objects
+   [\#529](https://github.com/matrix-org/matrix-js-sdk/pull/529)
 
+Changes in [0.8.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1) (2017-08-23)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.1-rc.1...v0.8.1)
 
--   [No changes]
-
-# Changes in [0.8.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1-rc.1) (2017-08-22)
+ * [No changes]
 
+Changes in [0.8.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.1-rc.1) (2017-08-22)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.8.0...v0.8.1-rc.1)
 
--   Fix error handling in interactive-auth
-    [\#527](https://github.com/matrix-org/matrix-js-sdk/pull/527)
--   Make lots of OlmDevice asynchronous
-    [\#524](https://github.com/matrix-org/matrix-js-sdk/pull/524)
--   Make crypto.decryptMessage return decryption results
-    [\#523](https://github.com/matrix-org/matrix-js-sdk/pull/523)
-
-# Changes in [0.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.0) (2017-08-15)
+ * Fix error handling in interactive-auth
+   [\#527](https://github.com/matrix-org/matrix-js-sdk/pull/527)
+ * Make lots of OlmDevice asynchronous
+   [\#524](https://github.com/matrix-org/matrix-js-sdk/pull/524)
+ * Make crypto.decryptMessage return decryption results
+   [\#523](https://github.com/matrix-org/matrix-js-sdk/pull/523)
 
+Changes in [0.8.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.8.0) (2017-08-15)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.13...v0.8.0)
 
-## BREAKING CHANGE
+BREAKING CHANGE
+---------------
 
 In order to support a move to a more scalable storage backend, we need to make
 a number of the APIs related end-to-end encryption asynchronous.
@@ -3820,1198 +3787,1190 @@ applications which support end-to-end encryption:
 
 2. The following APIs have been changed to return promises:
 
-    - `MatrixClient.getStoredDevicesForUser`
-    - `MatrixClient.getStoredDevice`
-    - `MatrixClient.setDeviceVerified`
-    - `MatrixClient.setDeviceBlocked`
-    - `MatrixClient.setDeviceKnown`
-    - `MatrixClient.getEventSenderDeviceInfo`
-    - `MatrixClient.isEventSenderVerified`
-    - `MatrixClient.importRoomKeys`
+   * `MatrixClient.getStoredDevicesForUser`
+   * `MatrixClient.getStoredDevice`
+   * `MatrixClient.setDeviceVerified`
+   * `MatrixClient.setDeviceBlocked`
+   * `MatrixClient.setDeviceKnown`
+   * `MatrixClient.getEventSenderDeviceInfo`
+   * `MatrixClient.isEventSenderVerified`
+   * `MatrixClient.importRoomKeys`
+
+   Applications using the results of any of the above methods will need to be
+   updated to wait for the result of the promise.
 
-    Applications using the results of any of the above methods will need to be
-    updated to wait for the result of the promise.
 
 3. `MatrixClient.listDeviceKeys` has been removed altogether. It's been
    deprecated for some time. Applications using it should instead be changed to
    use `MatrixClient.getStoredDevices`, which is similar but returns its results
    in a slightly different format.
 
--   Make bits of `olmlib` asynchronous
-    [\#521](https://github.com/matrix-org/matrix-js-sdk/pull/521)
--   Make some of DeviceList asynchronous
-    [\#520](https://github.com/matrix-org/matrix-js-sdk/pull/520)
--   Make methods in crypto/algorithms async
-    [\#519](https://github.com/matrix-org/matrix-js-sdk/pull/519)
--   Avoid sending unencrypted messages in e2e room
-    [\#518](https://github.com/matrix-org/matrix-js-sdk/pull/518)
--   Make tests wait for syncs to happen
-    [\#517](https://github.com/matrix-org/matrix-js-sdk/pull/517)
--   Make a load of methods in the 'Crypto' module asynchronous
-    [\#510](https://github.com/matrix-org/matrix-js-sdk/pull/510)
--   Set `rawDisplayName` to `userId` if membership has `displayname=null`
-    [\#515](https://github.com/matrix-org/matrix-js-sdk/pull/515)
--   Refactor handling of crypto events for async
-    [\#508](https://github.com/matrix-org/matrix-js-sdk/pull/508)
--   Let event decryption be asynchronous
-    [\#509](https://github.com/matrix-org/matrix-js-sdk/pull/509)
--   Transform `async` functions to bluebird promises
-    [\#511](https://github.com/matrix-org/matrix-js-sdk/pull/511)
--   Add more group APIs
-    [\#512](https://github.com/matrix-org/matrix-js-sdk/pull/512)
--   Retrying test: wait for localEchoUpdated event
-    [\#507](https://github.com/matrix-org/matrix-js-sdk/pull/507)
--   Fix member events breaking on timeline reset, 2
-    [\#504](https://github.com/matrix-org/matrix-js-sdk/pull/504)
--   Make bits of the js-sdk api asynchronous
-    [\#503](https://github.com/matrix-org/matrix-js-sdk/pull/503)
--   Yet more js-sdk test deflakification
-    [\#499](https://github.com/matrix-org/matrix-js-sdk/pull/499)
--   Fix racy 'matrixclient retrying' test
-    [\#497](https://github.com/matrix-org/matrix-js-sdk/pull/497)
--   Fix spamming of key-share-requests
-    [\#495](https://github.com/matrix-org/matrix-js-sdk/pull/495)
--   Add progress handler to `uploadContent`
-    [\#500](https://github.com/matrix-org/matrix-js-sdk/pull/500)
--   Switch matrix-js-sdk to bluebird
-    [\#490](https://github.com/matrix-org/matrix-js-sdk/pull/490)
--   Fix some more flakey tests
-    [\#492](https://github.com/matrix-org/matrix-js-sdk/pull/492)
--   make the npm test script windows-friendly
-    [\#489](https://github.com/matrix-org/matrix-js-sdk/pull/489)
--   Fix a bunch of races in the tests
-    [\#488](https://github.com/matrix-org/matrix-js-sdk/pull/488)
--   Fix early return in MatrixClient.setGuestAccess
-    [\#487](https://github.com/matrix-org/matrix-js-sdk/pull/487)
--   Remove testUtils.failTest
-    [\#486](https://github.com/matrix-org/matrix-js-sdk/pull/486)
--   Add test:watch script
-    [\#485](https://github.com/matrix-org/matrix-js-sdk/pull/485)
--   Make it possible to use async/await
-    [\#484](https://github.com/matrix-org/matrix-js-sdk/pull/484)
--   Remove m.new_device support
-    [\#483](https://github.com/matrix-org/matrix-js-sdk/pull/483)
--   Use access-token in header
-    [\#478](https://github.com/matrix-org/matrix-js-sdk/pull/478)
--   Sanity-check response from /thirdparty/protocols
-    [\#482](https://github.com/matrix-org/matrix-js-sdk/pull/482)
--   Avoid parsing plain-text errors as JSON
-    [\#479](https://github.com/matrix-org/matrix-js-sdk/pull/479)
--   Use external mock-request
-    [\#481](https://github.com/matrix-org/matrix-js-sdk/pull/481)
--   Fix some races in the tests
-    [\#480](https://github.com/matrix-org/matrix-js-sdk/pull/480)
--   Fall back to MemoryCryptoStore if indexeddb fails
-    [\#475](https://github.com/matrix-org/matrix-js-sdk/pull/475)
--   Fix load failure in firefox when indexedDB is disabled
-    [\#474](https://github.com/matrix-org/matrix-js-sdk/pull/474)
--   Fix a race in a test
-    [\#471](https://github.com/matrix-org/matrix-js-sdk/pull/471)
--   Avoid throwing an unhandled error when the indexeddb is deleted
-    [\#470](https://github.com/matrix-org/matrix-js-sdk/pull/470)
--   fix jsdoc
-    [\#469](https://github.com/matrix-org/matrix-js-sdk/pull/469)
--   Handle m.forwarded_room_key events
-    [\#468](https://github.com/matrix-org/matrix-js-sdk/pull/468)
--   Improve error reporting from indexeddbstore.clearDatabase
-    [\#466](https://github.com/matrix-org/matrix-js-sdk/pull/466)
--   Implement sharing of megolm keys
-    [\#454](https://github.com/matrix-org/matrix-js-sdk/pull/454)
--   Process received room key requests
-    [\#449](https://github.com/matrix-org/matrix-js-sdk/pull/449)
--   Send m.room_key_request events when we fail to decrypt an event
-    [\#448](https://github.com/matrix-org/matrix-js-sdk/pull/448)
-
-# Changes in [0.7.13](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.13) (2017-06-22)
 
+ * Make bits of `olmlib` asynchronous
+   [\#521](https://github.com/matrix-org/matrix-js-sdk/pull/521)
+ * Make some of DeviceList asynchronous
+   [\#520](https://github.com/matrix-org/matrix-js-sdk/pull/520)
+ * Make methods in crypto/algorithms async
+   [\#519](https://github.com/matrix-org/matrix-js-sdk/pull/519)
+ * Avoid sending unencrypted messages in e2e room
+   [\#518](https://github.com/matrix-org/matrix-js-sdk/pull/518)
+ * Make tests wait for syncs to happen
+   [\#517](https://github.com/matrix-org/matrix-js-sdk/pull/517)
+ * Make a load of methods in the 'Crypto' module asynchronous
+   [\#510](https://github.com/matrix-org/matrix-js-sdk/pull/510)
+ * Set `rawDisplayName` to `userId` if membership has `displayname=null`
+   [\#515](https://github.com/matrix-org/matrix-js-sdk/pull/515)
+ * Refactor handling of crypto events for async
+   [\#508](https://github.com/matrix-org/matrix-js-sdk/pull/508)
+ * Let event decryption be asynchronous
+   [\#509](https://github.com/matrix-org/matrix-js-sdk/pull/509)
+ * Transform `async` functions to bluebird promises
+   [\#511](https://github.com/matrix-org/matrix-js-sdk/pull/511)
+ * Add more group APIs
+   [\#512](https://github.com/matrix-org/matrix-js-sdk/pull/512)
+ * Retrying test: wait for localEchoUpdated event
+   [\#507](https://github.com/matrix-org/matrix-js-sdk/pull/507)
+ * Fix member events breaking on timeline reset, 2
+   [\#504](https://github.com/matrix-org/matrix-js-sdk/pull/504)
+ * Make bits of the js-sdk api asynchronous
+   [\#503](https://github.com/matrix-org/matrix-js-sdk/pull/503)
+ * Yet more js-sdk test deflakification
+   [\#499](https://github.com/matrix-org/matrix-js-sdk/pull/499)
+ * Fix racy 'matrixclient retrying' test
+   [\#497](https://github.com/matrix-org/matrix-js-sdk/pull/497)
+ * Fix spamming of key-share-requests
+   [\#495](https://github.com/matrix-org/matrix-js-sdk/pull/495)
+ * Add progress handler to `uploadContent`
+   [\#500](https://github.com/matrix-org/matrix-js-sdk/pull/500)
+ * Switch matrix-js-sdk to bluebird
+   [\#490](https://github.com/matrix-org/matrix-js-sdk/pull/490)
+ * Fix some more flakey tests
+   [\#492](https://github.com/matrix-org/matrix-js-sdk/pull/492)
+ * make the npm test script windows-friendly
+   [\#489](https://github.com/matrix-org/matrix-js-sdk/pull/489)
+ * Fix a bunch of races in the tests
+   [\#488](https://github.com/matrix-org/matrix-js-sdk/pull/488)
+ * Fix early return in MatrixClient.setGuestAccess
+   [\#487](https://github.com/matrix-org/matrix-js-sdk/pull/487)
+ * Remove testUtils.failTest
+   [\#486](https://github.com/matrix-org/matrix-js-sdk/pull/486)
+ * Add test:watch script
+   [\#485](https://github.com/matrix-org/matrix-js-sdk/pull/485)
+ * Make it possible to use async/await
+   [\#484](https://github.com/matrix-org/matrix-js-sdk/pull/484)
+ * Remove m.new_device support
+   [\#483](https://github.com/matrix-org/matrix-js-sdk/pull/483)
+ * Use access-token in header
+   [\#478](https://github.com/matrix-org/matrix-js-sdk/pull/478)
+ * Sanity-check response from /thirdparty/protocols
+   [\#482](https://github.com/matrix-org/matrix-js-sdk/pull/482)
+ * Avoid parsing plain-text errors as JSON
+   [\#479](https://github.com/matrix-org/matrix-js-sdk/pull/479)
+ * Use external mock-request
+   [\#481](https://github.com/matrix-org/matrix-js-sdk/pull/481)
+ * Fix some races in the tests
+   [\#480](https://github.com/matrix-org/matrix-js-sdk/pull/480)
+ * Fall back to MemoryCryptoStore if indexeddb fails
+   [\#475](https://github.com/matrix-org/matrix-js-sdk/pull/475)
+ * Fix load failure in firefox when indexedDB is disabled
+   [\#474](https://github.com/matrix-org/matrix-js-sdk/pull/474)
+ * Fix a race in a test
+   [\#471](https://github.com/matrix-org/matrix-js-sdk/pull/471)
+ * Avoid throwing an unhandled error when the indexeddb is deleted
+   [\#470](https://github.com/matrix-org/matrix-js-sdk/pull/470)
+ * fix jsdoc
+   [\#469](https://github.com/matrix-org/matrix-js-sdk/pull/469)
+ * Handle m.forwarded_room_key events
+   [\#468](https://github.com/matrix-org/matrix-js-sdk/pull/468)
+ * Improve error reporting from indexeddbstore.clearDatabase
+   [\#466](https://github.com/matrix-org/matrix-js-sdk/pull/466)
+ * Implement sharing of megolm keys
+   [\#454](https://github.com/matrix-org/matrix-js-sdk/pull/454)
+ * Process received room key requests
+   [\#449](https://github.com/matrix-org/matrix-js-sdk/pull/449)
+ * Send m.room_key_request events when we fail to decrypt an event
+   [\#448](https://github.com/matrix-org/matrix-js-sdk/pull/448)
+
+Changes in [0.7.13](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.13) (2017-06-22)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.12...v0.7.13)
 
--   Fix failure on Tor browser
-    [\#473](https://github.com/matrix-org/matrix-js-sdk/pull/473)
--   Fix issues with firefox private browsing
-    [\#472](https://github.com/matrix-org/matrix-js-sdk/pull/472)
-
-# Changes in [0.7.12](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12) (2017-06-19)
+ * Fix failure on Tor browser
+   [\#473](https://github.com/matrix-org/matrix-js-sdk/pull/473)
+ * Fix issues with firefox private browsing
+   [\#472](https://github.com/matrix-org/matrix-js-sdk/pull/472)
 
+Changes in [0.7.12](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12) (2017-06-19)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.12-rc.1...v0.7.12)
 
--   No changes
+ * No changes
 
-# Changes in [0.7.12-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12-rc.1) (2017-06-15)
 
+Changes in [0.7.12-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.12-rc.1) (2017-06-15)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.11...v0.7.12-rc.1)
 
--   allow setting iceTransportPolicy to relay through forceTURN option
-    [\#462](https://github.com/matrix-org/matrix-js-sdk/pull/462)
-
-# Changes in [0.7.11](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11) (2017-06-12)
+ * allow setting iceTransportPolicy to relay through forceTURN option
+   [\#462](https://github.com/matrix-org/matrix-js-sdk/pull/462)
 
+Changes in [0.7.11](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11) (2017-06-12)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.11-rc.1...v0.7.11)
 
--   Add a bunch of logging around sending messages
-    [\#460](https://github.com/matrix-org/matrix-js-sdk/pull/460)
-
-# Changes in [0.7.11-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11-rc.1) (2017-06-09)
+ * Add a bunch of logging around sending messages
+   [\#460](https://github.com/matrix-org/matrix-js-sdk/pull/460)
 
+Changes in [0.7.11-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.11-rc.1) (2017-06-09)
+============================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.10...v0.7.11-rc.1)
 
--   Make TimelineWindow.load resolve quicker if we have the events
-    [\#458](https://github.com/matrix-org/matrix-js-sdk/pull/458)
--   Stop peeking when a matrix client is stopped
-    [\#451](https://github.com/matrix-org/matrix-js-sdk/pull/451)
--   Update README: Clarify how to install libolm
-    [\#450](https://github.com/matrix-org/matrix-js-sdk/pull/450)
-
-# Changes in [0.7.10](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.10) (2017-06-02)
+ * Make TimelineWindow.load resolve quicker if we have the events
+   [\#458](https://github.com/matrix-org/matrix-js-sdk/pull/458)
+ * Stop peeking when a matrix client is stopped
+   [\#451](https://github.com/matrix-org/matrix-js-sdk/pull/451)
+ * Update README: Clarify how to install libolm
+   [\#450](https://github.com/matrix-org/matrix-js-sdk/pull/450)
 
+Changes in [0.7.10](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.10) (2017-06-02)
+==================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.9...v0.7.10)
 
--   BREAKING CHANGE: The SDK no longer `require`s `olm` - instead it expects
-    libolm to be provided as an `Olm` global. This will only affect
-    applications which use end-to-end encryption. See the
-    [README](README.md#end-to-end-encryption-support) for details.
-
--   indexeddb-crypto-store: fix db deletion
-    [\#447](https://github.com/matrix-org/matrix-js-sdk/pull/447)
--   Load Olm from the global rather than requiring it.
-    [\#446](https://github.com/matrix-org/matrix-js-sdk/pull/446)
+ * BREAKING CHANGE: The SDK no longer ``require``s ``olm`` - instead it expects
+   libolm to be provided as an ``Olm`` global. This will only affect
+   applications which use end-to-end encryption. See the
+   [README](README.md#end-to-end-encryption-support) for details.
 
-# Changes in [0.7.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.9) (2017-06-01)
+ * indexeddb-crypto-store: fix db deletion
+   [\#447](https://github.com/matrix-org/matrix-js-sdk/pull/447)
+ * Load Olm from the global rather than requiring it.
+   [\#446](https://github.com/matrix-org/matrix-js-sdk/pull/446)
 
+Changes in [0.7.9](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.9) (2017-06-01)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.8...v0.7.9)
 
--   Initial framework for indexeddb-backed crypto store
-    [\#445](https://github.com/matrix-org/matrix-js-sdk/pull/445)
--   Factor out reEmit to a common module
-    [\#444](https://github.com/matrix-org/matrix-js-sdk/pull/444)
--   crypto/algorithms/base.js: Convert to es6
-    [\#443](https://github.com/matrix-org/matrix-js-sdk/pull/443)
--   maySendRedactionForEvent for userId
-    [\#435](https://github.com/matrix-org/matrix-js-sdk/pull/435)
--   MatrixClient: add getUserId()
-    [\#441](https://github.com/matrix-org/matrix-js-sdk/pull/441)
--   Run jsdoc on a custom babeling of the source
-    [\#442](https://github.com/matrix-org/matrix-js-sdk/pull/442)
--   Add in a public api getStoredDevice allowing clients to get a specific
-    device
-    [\#439](https://github.com/matrix-org/matrix-js-sdk/pull/439)
-
-# Changes in [0.7.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8) (2017-05-22)
-
+ * Initial framework for indexeddb-backed crypto store
+   [\#445](https://github.com/matrix-org/matrix-js-sdk/pull/445)
+ * Factor out reEmit to a common module
+   [\#444](https://github.com/matrix-org/matrix-js-sdk/pull/444)
+ * crypto/algorithms/base.js: Convert to es6
+   [\#443](https://github.com/matrix-org/matrix-js-sdk/pull/443)
+ * maySendRedactionForEvent for userId
+   [\#435](https://github.com/matrix-org/matrix-js-sdk/pull/435)
+ * MatrixClient: add getUserId()
+   [\#441](https://github.com/matrix-org/matrix-js-sdk/pull/441)
+ * Run jsdoc on a custom babeling of the source
+   [\#442](https://github.com/matrix-org/matrix-js-sdk/pull/442)
+ * Add in a public api getStoredDevice allowing clients to get a specific
+   device
+   [\#439](https://github.com/matrix-org/matrix-js-sdk/pull/439)
+
+Changes in [0.7.8](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8) (2017-05-22)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.8-rc.1...v0.7.8)
 
--   No changes
+ * No changes
 
-# Changes in [0.7.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8-rc.1) (2017-05-19)
 
+Changes in [0.7.8-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.8-rc.1) (2017-05-19)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.7...v0.7.8-rc.1)
 
--   Attempt to rework the release-tarball-signing stuff
-    [\#438](https://github.com/matrix-org/matrix-js-sdk/pull/438)
--   ability to specify webrtc audio/video inputs for the lib to request
-    [\#427](https://github.com/matrix-org/matrix-js-sdk/pull/427)
--   make screen sharing call FF friendly :D
-    [\#434](https://github.com/matrix-org/matrix-js-sdk/pull/434)
--   Fix race in device list updates
-    [\#431](https://github.com/matrix-org/matrix-js-sdk/pull/431)
--   WebRTC: Support recvonly for video for those without a webcam
-    [\#424](https://github.com/matrix-org/matrix-js-sdk/pull/424)
--   Update istanbul to remove minimatch DoS Warning
-    [\#422](https://github.com/matrix-org/matrix-js-sdk/pull/422)
--   webrtc/call: Make it much less likely that callIds collide locally
-    [\#423](https://github.com/matrix-org/matrix-js-sdk/pull/423)
--   Automatically complete dummy auth
-    [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
--   Don't leave the gh-pages branch checked out
-    [\#418](https://github.com/matrix-org/matrix-js-sdk/pull/418)
-
-# Changes in [0.7.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7) (2017-04-25)
-
+ * Attempt to rework the release-tarball-signing stuff
+   [\#438](https://github.com/matrix-org/matrix-js-sdk/pull/438)
+ * ability to specify webrtc audio/video inputs for the lib to request
+   [\#427](https://github.com/matrix-org/matrix-js-sdk/pull/427)
+ * make screen sharing call FF friendly :D
+   [\#434](https://github.com/matrix-org/matrix-js-sdk/pull/434)
+ * Fix race in device list updates
+   [\#431](https://github.com/matrix-org/matrix-js-sdk/pull/431)
+ * WebRTC: Support recvonly for video for those without a webcam
+   [\#424](https://github.com/matrix-org/matrix-js-sdk/pull/424)
+ * Update istanbul to remove minimatch DoS Warning
+   [\#422](https://github.com/matrix-org/matrix-js-sdk/pull/422)
+ * webrtc/call: Make it much less likely that callIds collide locally
+   [\#423](https://github.com/matrix-org/matrix-js-sdk/pull/423)
+ * Automatically complete dummy auth
+   [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
+ * Don't leave the gh-pages branch checked out
+   [\#418](https://github.com/matrix-org/matrix-js-sdk/pull/418)
+
+Changes in [0.7.7](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7) (2017-04-25)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.7-rc.1...v0.7.7)
 
--   No changes
+ * No changes
 
-# Changes in [0.7.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7-rc.1) (2017-04-21)
 
+Changes in [0.7.7-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.7-rc.1) (2017-04-21)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.6...v0.7.7-rc.1)
 
--   Automatically complete dummy auth
-    [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
+ * Automatically complete dummy auth
+   [\#420](https://github.com/matrix-org/matrix-js-sdk/pull/420)
 
-# Changes in [0.7.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6) (2017-04-12)
 
+Changes in [0.7.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6) (2017-04-12)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.6-rc.2...v0.7.6)
 
--   No changes
-
-# Changes in [0.7.6-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.2) (2017-04-10)
+ * No changes
 
+Changes in [0.7.6-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.2) (2017-04-10)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.6-rc.1...v0.7.6-rc.2)
 
--   Add feature detection for webworkers
-    [\#416](https://github.com/matrix-org/matrix-js-sdk/pull/416)
--   Fix release script
-    [\#415](https://github.com/matrix-org/matrix-js-sdk/pull/415)
-
-# Changes in [0.7.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.1) (2017-04-07)
+ * Add feature detection for webworkers
+   [\#416](https://github.com/matrix-org/matrix-js-sdk/pull/416)
+ * Fix release script
+   [\#415](https://github.com/matrix-org/matrix-js-sdk/pull/415)
 
+Changes in [0.7.6-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.6-rc.1) (2017-04-07)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5...v0.7.6-rc.1)
 
--   Make indexeddb save after the first sync
-    [\#414](https://github.com/matrix-org/matrix-js-sdk/pull/414)
--   Make indexeddb startup faster
-    [\#413](https://github.com/matrix-org/matrix-js-sdk/pull/413)
--   Add ability to do indexeddb sync work in webworker
-    [\#412](https://github.com/matrix-org/matrix-js-sdk/pull/412)
--   Move more functionality to the indexeddb backend
-    [\#409](https://github.com/matrix-org/matrix-js-sdk/pull/409)
--   Indicate syncState ERROR after many failed /syncs
-    [\#410](https://github.com/matrix-org/matrix-js-sdk/pull/410)
--   Further reorganising of indexeddb sync code
-    [\#407](https://github.com/matrix-org/matrix-js-sdk/pull/407)
--   Change interface of IndexedDBStore: hide internals
-    [\#406](https://github.com/matrix-org/matrix-js-sdk/pull/406)
--   Don't be SYNCING until updating from the server
-    [\#405](https://github.com/matrix-org/matrix-js-sdk/pull/405)
--   Don't log the entire /sync response
-    [\#403](https://github.com/matrix-org/matrix-js-sdk/pull/403)
--   webrtc/call: Assign MediaStream to video element srcObject
-    [\#402](https://github.com/matrix-org/matrix-js-sdk/pull/402)
--   Fix undefined reference in http-api
-    [\#400](https://github.com/matrix-org/matrix-js-sdk/pull/400)
--   Add copyright header to event-timeline.js
-    [\#382](https://github.com/matrix-org/matrix-js-sdk/pull/382)
--   client: fix docs for user-scoped account_data events
-    [\#397](https://github.com/matrix-org/matrix-js-sdk/pull/397)
--   Add a CONTRIBUTING for js-sdk
-    [\#399](https://github.com/matrix-org/matrix-js-sdk/pull/399)
--   Fix leaking room state objects on limited sync responses
-    [\#395](https://github.com/matrix-org/matrix-js-sdk/pull/395)
--   Extend 'ignoreFailure' to be 'background'
-    [\#396](https://github.com/matrix-org/matrix-js-sdk/pull/396)
--   Add x_show_msisdn parameter to register calls
-    [\#388](https://github.com/matrix-org/matrix-js-sdk/pull/388)
--   Update event redaction to keep sender and origin_server_ts
-    [\#394](https://github.com/matrix-org/matrix-js-sdk/pull/394)
--   Handle 'limited' timeline responses in the SyncAccumulator
-    [\#393](https://github.com/matrix-org/matrix-js-sdk/pull/393)
--   Give a better error message if the HS doesn't support msisdn registeration
-    [\#391](https://github.com/matrix-org/matrix-js-sdk/pull/391)
--   Add getEmailSid
-    [\#383](https://github.com/matrix-org/matrix-js-sdk/pull/383)
--   Add m.login.email.identity support to UI auth
-    [\#380](https://github.com/matrix-org/matrix-js-sdk/pull/380)
--   src/client.js: Fix incorrect roomId reference in VoIP glare code
-    [\#381](https://github.com/matrix-org/matrix-js-sdk/pull/381)
--   add .editorconfig
-    [\#379](https://github.com/matrix-org/matrix-js-sdk/pull/379)
--   Store account data in the same way as room data
-    [\#377](https://github.com/matrix-org/matrix-js-sdk/pull/377)
--   Upload one-time keys on /sync rather than a timer
-    [\#376](https://github.com/matrix-org/matrix-js-sdk/pull/376)
--   Increase the WRITE_DELAY on database syncing
-    [\#374](https://github.com/matrix-org/matrix-js-sdk/pull/374)
--   Make deleteAllData() return a Promise
-    [\#373](https://github.com/matrix-org/matrix-js-sdk/pull/373)
--   Don't include banned users in the room name
-    [\#372](https://github.com/matrix-org/matrix-js-sdk/pull/372)
--   Support IndexedDB as a backing store
-    [\#363](https://github.com/matrix-org/matrix-js-sdk/pull/363)
--   Poll /sync with a short timeout while catching up
-    [\#370](https://github.com/matrix-org/matrix-js-sdk/pull/370)
--   Make test coverage work again
-    [\#368](https://github.com/matrix-org/matrix-js-sdk/pull/368)
--   Add docs to event
-    [\#367](https://github.com/matrix-org/matrix-js-sdk/pull/367)
--   Keep the device-sync token more up-to-date
-    [\#366](https://github.com/matrix-org/matrix-js-sdk/pull/366)
--   Fix race conditions in device list download
-    [\#365](https://github.com/matrix-org/matrix-js-sdk/pull/365)
--   Fix the unban method
-    [\#364](https://github.com/matrix-org/matrix-js-sdk/pull/364)
--   Spread out device verification work
-    [\#362](https://github.com/matrix-org/matrix-js-sdk/pull/362)
--   Clean up/improve e2e logging
-    [\#361](https://github.com/matrix-org/matrix-js-sdk/pull/361)
--   Fix decryption of events whose key arrives later
-    [\#360](https://github.com/matrix-org/matrix-js-sdk/pull/360)
--   Invalidate device lists when encryption is enabled in a room
-    [\#359](https://github.com/matrix-org/matrix-js-sdk/pull/359)
--   Switch from jasmine to mocha + expect + lolex
-    [\#358](https://github.com/matrix-org/matrix-js-sdk/pull/358)
--   Install source-map-support in each test
-    [\#356](https://github.com/matrix-org/matrix-js-sdk/pull/356)
--   searchMessageText: avoid setting keys=undefined
-    [\#357](https://github.com/matrix-org/matrix-js-sdk/pull/357)
--   realtime-callbacks: pass `global` as `this`
-    [\#355](https://github.com/matrix-org/matrix-js-sdk/pull/355)
--   Make the tests work without olm
-    [\#354](https://github.com/matrix-org/matrix-js-sdk/pull/354)
--   Tests: Factor out TestClient and use it in crypto tests
-    [\#353](https://github.com/matrix-org/matrix-js-sdk/pull/353)
--   Fix some lint
-    [\#352](https://github.com/matrix-org/matrix-js-sdk/pull/352)
--   Make a sig for source tarballs when releasing
-    [\#351](https://github.com/matrix-org/matrix-js-sdk/pull/351)
--   When doing a pre-release, don't bother merging to master and develop.
-    [\#350](https://github.com/matrix-org/matrix-js-sdk/pull/350)
-
-# Changes in [0.7.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5) (2017-02-04)
-
+ * Make indexeddb save after the first sync
+   [\#414](https://github.com/matrix-org/matrix-js-sdk/pull/414)
+ * Make indexeddb startup faster
+   [\#413](https://github.com/matrix-org/matrix-js-sdk/pull/413)
+ * Add ability to do indexeddb sync work in webworker
+   [\#412](https://github.com/matrix-org/matrix-js-sdk/pull/412)
+ * Move more functionality to the indexeddb backend
+   [\#409](https://github.com/matrix-org/matrix-js-sdk/pull/409)
+ * Indicate syncState ERROR after many failed /syncs
+   [\#410](https://github.com/matrix-org/matrix-js-sdk/pull/410)
+ * Further reorganising of indexeddb sync code
+   [\#407](https://github.com/matrix-org/matrix-js-sdk/pull/407)
+ * Change interface of IndexedDBStore: hide internals
+   [\#406](https://github.com/matrix-org/matrix-js-sdk/pull/406)
+ * Don't be SYNCING until updating from the server
+   [\#405](https://github.com/matrix-org/matrix-js-sdk/pull/405)
+ * Don't log the entire /sync response
+   [\#403](https://github.com/matrix-org/matrix-js-sdk/pull/403)
+ * webrtc/call: Assign MediaStream to video element srcObject
+   [\#402](https://github.com/matrix-org/matrix-js-sdk/pull/402)
+ * Fix undefined reference in http-api
+   [\#400](https://github.com/matrix-org/matrix-js-sdk/pull/400)
+ * Add copyright header to event-timeline.js
+   [\#382](https://github.com/matrix-org/matrix-js-sdk/pull/382)
+ * client: fix docs for user-scoped account_data events
+   [\#397](https://github.com/matrix-org/matrix-js-sdk/pull/397)
+ * Add a CONTRIBUTING for js-sdk
+   [\#399](https://github.com/matrix-org/matrix-js-sdk/pull/399)
+ * Fix leaking room state objects on limited sync responses
+   [\#395](https://github.com/matrix-org/matrix-js-sdk/pull/395)
+ * Extend 'ignoreFailure' to be 'background'
+   [\#396](https://github.com/matrix-org/matrix-js-sdk/pull/396)
+ * Add x_show_msisdn parameter to register calls
+   [\#388](https://github.com/matrix-org/matrix-js-sdk/pull/388)
+ * Update event redaction to keep sender and origin_server_ts
+   [\#394](https://github.com/matrix-org/matrix-js-sdk/pull/394)
+ * Handle 'limited' timeline responses in the SyncAccumulator
+   [\#393](https://github.com/matrix-org/matrix-js-sdk/pull/393)
+ * Give a better error message if the HS doesn't support msisdn registeration
+   [\#391](https://github.com/matrix-org/matrix-js-sdk/pull/391)
+ * Add getEmailSid
+   [\#383](https://github.com/matrix-org/matrix-js-sdk/pull/383)
+ * Add m.login.email.identity support to UI auth
+   [\#380](https://github.com/matrix-org/matrix-js-sdk/pull/380)
+ * src/client.js: Fix incorrect roomId reference in VoIP glare code
+   [\#381](https://github.com/matrix-org/matrix-js-sdk/pull/381)
+ * add .editorconfig
+   [\#379](https://github.com/matrix-org/matrix-js-sdk/pull/379)
+ * Store account data in the same way as room data
+   [\#377](https://github.com/matrix-org/matrix-js-sdk/pull/377)
+ * Upload one-time keys on /sync rather than a timer
+   [\#376](https://github.com/matrix-org/matrix-js-sdk/pull/376)
+ * Increase the WRITE_DELAY on database syncing
+   [\#374](https://github.com/matrix-org/matrix-js-sdk/pull/374)
+ * Make deleteAllData() return a Promise
+   [\#373](https://github.com/matrix-org/matrix-js-sdk/pull/373)
+ * Don't include banned users in the room name
+   [\#372](https://github.com/matrix-org/matrix-js-sdk/pull/372)
+ * Support IndexedDB as a backing store
+   [\#363](https://github.com/matrix-org/matrix-js-sdk/pull/363)
+ * Poll /sync with a short timeout while catching up
+   [\#370](https://github.com/matrix-org/matrix-js-sdk/pull/370)
+ * Make test coverage work again
+   [\#368](https://github.com/matrix-org/matrix-js-sdk/pull/368)
+ * Add docs to event
+   [\#367](https://github.com/matrix-org/matrix-js-sdk/pull/367)
+ * Keep the device-sync token more up-to-date
+   [\#366](https://github.com/matrix-org/matrix-js-sdk/pull/366)
+ * Fix race conditions in device list download
+   [\#365](https://github.com/matrix-org/matrix-js-sdk/pull/365)
+ * Fix the unban method
+   [\#364](https://github.com/matrix-org/matrix-js-sdk/pull/364)
+ * Spread out device verification work
+   [\#362](https://github.com/matrix-org/matrix-js-sdk/pull/362)
+ * Clean up/improve e2e logging
+   [\#361](https://github.com/matrix-org/matrix-js-sdk/pull/361)
+ * Fix decryption of events whose key arrives later
+   [\#360](https://github.com/matrix-org/matrix-js-sdk/pull/360)
+ * Invalidate device lists when encryption is enabled in a room
+   [\#359](https://github.com/matrix-org/matrix-js-sdk/pull/359)
+ * Switch from jasmine to mocha + expect + lolex
+   [\#358](https://github.com/matrix-org/matrix-js-sdk/pull/358)
+ * Install source-map-support in each test
+   [\#356](https://github.com/matrix-org/matrix-js-sdk/pull/356)
+ * searchMessageText: avoid setting keys=undefined
+   [\#357](https://github.com/matrix-org/matrix-js-sdk/pull/357)
+ * realtime-callbacks: pass `global` as `this`
+   [\#355](https://github.com/matrix-org/matrix-js-sdk/pull/355)
+ * Make the tests work without olm
+   [\#354](https://github.com/matrix-org/matrix-js-sdk/pull/354)
+ * Tests: Factor out TestClient and use it in crypto tests
+   [\#353](https://github.com/matrix-org/matrix-js-sdk/pull/353)
+ * Fix some lint
+   [\#352](https://github.com/matrix-org/matrix-js-sdk/pull/352)
+ * Make a sig for source tarballs when releasing
+   [\#351](https://github.com/matrix-org/matrix-js-sdk/pull/351)
+ * When doing a pre-release, don't bother merging to master and develop.
+   [\#350](https://github.com/matrix-org/matrix-js-sdk/pull/350)
+
+Changes in [0.7.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5) (2017-02-04)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5-rc.3...v0.7.5)
 
 No changes from 0.7.5-rc.3
 
-# Changes in [0.7.5-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.3) (2017-02-03)
-
+Changes in [0.7.5-rc.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.3) (2017-02-03)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5-rc.2...v0.7.5-rc.3)
 
--   Include DeviceInfo in deviceVerificationChanged events
-    [a3cc8eb](https://github.com/matrix-org/matrix-js-sdk/commit/a3cc8eb1f6d165576a342596f638316721cb26b6)
--   Fix device list update
-    [5fd7410](https://github.com/matrix-org/matrix-js-sdk/commit/5fd74109ffc56b73deb40c2604d84c38b8032c40)
+ * Include DeviceInfo in deviceVerificationChanged events
+   [a3cc8eb](https://github.com/matrix-org/matrix-js-sdk/commit/a3cc8eb1f6d165576a342596f638316721cb26b6)
+ * Fix device list update
+   [5fd7410](https://github.com/matrix-org/matrix-js-sdk/commit/5fd74109ffc56b73deb40c2604d84c38b8032c40)
 
-# Changes in [0.7.5-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.2) (2017-02-03)
 
+Changes in [0.7.5-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.2) (2017-02-03)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.5-rc.1...v0.7.5-rc.2)
 
--   Use the device change notifications interface
-    [\#348](https://github.com/matrix-org/matrix-js-sdk/pull/348)
--   Rewrite the device key query logic
-    [\#347](https://github.com/matrix-org/matrix-js-sdk/pull/347)
-
-# Changes in [0.7.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.1) (2017-02-03)
+ * Use the device change notifications interface
+   [\#348](https://github.com/matrix-org/matrix-js-sdk/pull/348)
+ * Rewrite the device key query logic
+   [\#347](https://github.com/matrix-org/matrix-js-sdk/pull/347)
 
+Changes in [0.7.5-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.5-rc.1) (2017-02-03)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.4...v0.7.5-rc.1)
 
--   Support for blacklisting unverified devices, both per-room and globally
-    [\#336](https://github.com/matrix-org/matrix-js-sdk/pull/336)
--   track errors when events can't be sent
-    [\#349](https://github.com/matrix-org/matrix-js-sdk/pull/349)
--   Factor out device list management
-    [\#346](https://github.com/matrix-org/matrix-js-sdk/pull/346)
--   Support for warning users when unknown devices show up
-    [\#335](https://github.com/matrix-org/matrix-js-sdk/pull/335)
--   Enable sourcemaps in browserified distro
-    [\#345](https://github.com/matrix-org/matrix-js-sdk/pull/345)
--   Record all e2e room settings in localstorage
-    [\#344](https://github.com/matrix-org/matrix-js-sdk/pull/344)
--   Make Olm work with browserified js-sdk
-    [\#340](https://github.com/matrix-org/matrix-js-sdk/pull/340)
--   Make browserify a dev dependency
-    [\#339](https://github.com/matrix-org/matrix-js-sdk/pull/339)
--   Allow single line brace-style
-    [\#338](https://github.com/matrix-org/matrix-js-sdk/pull/338)
--   Turn on comma-dangle for function calls
-    [\#333](https://github.com/matrix-org/matrix-js-sdk/pull/333)
--   Add prefer-const
-    [\#331](https://github.com/matrix-org/matrix-js-sdk/pull/331)
--   Support for importing and exporting megolm sessions
-    [\#326](https://github.com/matrix-org/matrix-js-sdk/pull/326)
--   Fix linting on all tests
-    [\#329](https://github.com/matrix-org/matrix-js-sdk/pull/329)
--   Fix ESLint warnings and errors
-    [\#325](https://github.com/matrix-org/matrix-js-sdk/pull/325)
--   BREAKING CHANGE: Remove WebStorageStore
-    [\#324](https://github.com/matrix-org/matrix-js-sdk/pull/324)
-
-# Changes in [0.7.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4) (2017-01-16)
-
+ * Support for blacklisting unverified devices, both per-room and globally
+   [\#336](https://github.com/matrix-org/matrix-js-sdk/pull/336)
+ * track errors when events can't be sent
+   [\#349](https://github.com/matrix-org/matrix-js-sdk/pull/349)
+ * Factor out device list management
+   [\#346](https://github.com/matrix-org/matrix-js-sdk/pull/346)
+ * Support for warning users when unknown devices show up
+   [\#335](https://github.com/matrix-org/matrix-js-sdk/pull/335)
+ * Enable sourcemaps in browserified distro
+   [\#345](https://github.com/matrix-org/matrix-js-sdk/pull/345)
+ * Record all e2e room settings in localstorage
+   [\#344](https://github.com/matrix-org/matrix-js-sdk/pull/344)
+ * Make Olm work with browserified js-sdk
+   [\#340](https://github.com/matrix-org/matrix-js-sdk/pull/340)
+ * Make browserify a dev dependency
+   [\#339](https://github.com/matrix-org/matrix-js-sdk/pull/339)
+ * Allow single line brace-style
+   [\#338](https://github.com/matrix-org/matrix-js-sdk/pull/338)
+ * Turn on comma-dangle for function calls
+   [\#333](https://github.com/matrix-org/matrix-js-sdk/pull/333)
+ * Add prefer-const
+   [\#331](https://github.com/matrix-org/matrix-js-sdk/pull/331)
+ * Support for importing and exporting megolm sessions
+   [\#326](https://github.com/matrix-org/matrix-js-sdk/pull/326)
+ * Fix linting on all tests
+   [\#329](https://github.com/matrix-org/matrix-js-sdk/pull/329)
+ * Fix ESLint warnings and errors
+   [\#325](https://github.com/matrix-org/matrix-js-sdk/pull/325)
+ * BREAKING CHANGE: Remove WebStorageStore
+   [\#324](https://github.com/matrix-org/matrix-js-sdk/pull/324)
+
+Changes in [0.7.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4) (2017-01-16)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.4-rc.1...v0.7.4)
 
--   Fix non-conference calling
-
-# Changes in [0.7.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4-rc.1) (2017-01-13)
+ * Fix non-conference calling
 
+Changes in [0.7.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.4-rc.1) (2017-01-13)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.3...v0.7.4-rc.1)
 
--   Remove babel-polyfill
-    [\#321](https://github.com/matrix-org/matrix-js-sdk/pull/321)
--   Update build process for ES6
-    [\#320](https://github.com/matrix-org/matrix-js-sdk/pull/320)
--   'babel' is not a babel package anymore
-    [\#319](https://github.com/matrix-org/matrix-js-sdk/pull/319)
--   Add Babel for ES6 support
-    [\#318](https://github.com/matrix-org/matrix-js-sdk/pull/318)
--   Move screen sharing check/error
-    [\#317](https://github.com/matrix-org/matrix-js-sdk/pull/317)
--   release.sh: Bail early if there are uncommitted changes
-    [\#316](https://github.com/matrix-org/matrix-js-sdk/pull/316)
-
-# Changes in [0.7.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.3) (2017-01-04)
-
+ * Remove babel-polyfill
+   [\#321](https://github.com/matrix-org/matrix-js-sdk/pull/321)
+ * Update build process for ES6
+   [\#320](https://github.com/matrix-org/matrix-js-sdk/pull/320)
+ * 'babel' is not a babel package anymore
+   [\#319](https://github.com/matrix-org/matrix-js-sdk/pull/319)
+ * Add Babel for ES6 support
+   [\#318](https://github.com/matrix-org/matrix-js-sdk/pull/318)
+ * Move screen sharing check/error
+   [\#317](https://github.com/matrix-org/matrix-js-sdk/pull/317)
+ * release.sh: Bail early if there are uncommitted changes
+   [\#316](https://github.com/matrix-org/matrix-js-sdk/pull/316)
+
+Changes in [0.7.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.3) (2017-01-04)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.2...v0.7.3)
 
--   User presence list feature
-    [\#310](https://github.com/matrix-org/matrix-js-sdk/pull/310)
--   Allow clients the ability to set a default local timeout
-    [\#313](https://github.com/matrix-org/matrix-js-sdk/pull/313)
--   Add API to delete threepid
-    [\#312](https://github.com/matrix-org/matrix-js-sdk/pull/312)
-
-# Changes in [0.7.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.2) (2016-12-15)
+ * User presence list feature
+   [\#310](https://github.com/matrix-org/matrix-js-sdk/pull/310)
+ * Allow clients the ability to set a default local timeout
+   [\#313](https://github.com/matrix-org/matrix-js-sdk/pull/313)
+ * Add API to delete threepid
+   [\#312](https://github.com/matrix-org/matrix-js-sdk/pull/312)
 
+Changes in [0.7.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.2) (2016-12-15)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.1...v0.7.2)
 
--   Bump to Olm 2.0
-    [\#309](https://github.com/matrix-org/matrix-js-sdk/pull/309)
--   Sanity check payload length before encrypting
-    [\#307](https://github.com/matrix-org/matrix-js-sdk/pull/307)
--   Remove dead \_sendPingToDevice function
-    [\#308](https://github.com/matrix-org/matrix-js-sdk/pull/308)
--   Add setRoomDirectoryVisibilityAppService
-    [\#306](https://github.com/matrix-org/matrix-js-sdk/pull/306)
--   Update release script to do signed releases
-    [\#305](https://github.com/matrix-org/matrix-js-sdk/pull/305)
--   e2e: Wait for pending device lists
-    [\#304](https://github.com/matrix-org/matrix-js-sdk/pull/304)
--   Start a new megolm session when devices are blacklisted
-    [\#303](https://github.com/matrix-org/matrix-js-sdk/pull/303)
--   E2E: Download our own devicelist on startup
-    [\#302](https://github.com/matrix-org/matrix-js-sdk/pull/302)
-
-# Changes in [0.7.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1) (2016-12-09)
-
+ * Bump to Olm 2.0
+   [\#309](https://github.com/matrix-org/matrix-js-sdk/pull/309)
+ * Sanity check payload length before encrypting
+   [\#307](https://github.com/matrix-org/matrix-js-sdk/pull/307)
+ * Remove dead _sendPingToDevice function
+   [\#308](https://github.com/matrix-org/matrix-js-sdk/pull/308)
+ * Add setRoomDirectoryVisibilityAppService
+   [\#306](https://github.com/matrix-org/matrix-js-sdk/pull/306)
+ * Update release script to do signed releases
+   [\#305](https://github.com/matrix-org/matrix-js-sdk/pull/305)
+ * e2e: Wait for pending device lists
+   [\#304](https://github.com/matrix-org/matrix-js-sdk/pull/304)
+ * Start a new megolm session when devices are blacklisted
+   [\#303](https://github.com/matrix-org/matrix-js-sdk/pull/303)
+ * E2E: Download our own devicelist on startup
+   [\#302](https://github.com/matrix-org/matrix-js-sdk/pull/302)
+
+Changes in [0.7.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1) (2016-12-09)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.1-rc.1...v0.7.1)
 
 No changes
 
-# Changes in [0.7.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1-rc.1) (2016-12-05)
 
+Changes in [0.7.1-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.1-rc.1) (2016-12-05)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.7.0...v0.7.1-rc.1)
 
--   Avoid NPE when no sessionStore is given
-    [\#300](https://github.com/matrix-org/matrix-js-sdk/pull/300)
--   Improve decryption error messages
-    [\#299](https://github.com/matrix-org/matrix-js-sdk/pull/299)
--   Revert "Use native Array.isArray when available."
-    [\#283](https://github.com/matrix-org/matrix-js-sdk/pull/283)
--   Use native Array.isArray when available.
-    [\#282](https://github.com/matrix-org/matrix-js-sdk/pull/282)
-
-# Changes in [0.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.0) (2016-11-18)
-
+ * Avoid NPE when no sessionStore is given
+   [\#300](https://github.com/matrix-org/matrix-js-sdk/pull/300)
+ * Improve decryption error messages
+   [\#299](https://github.com/matrix-org/matrix-js-sdk/pull/299)
+ * Revert "Use native Array.isArray when available."
+   [\#283](https://github.com/matrix-org/matrix-js-sdk/pull/283)
+ * Use native Array.isArray when available.
+   [\#282](https://github.com/matrix-org/matrix-js-sdk/pull/282)
+
+Changes in [0.7.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.7.0) (2016-11-18)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.4...v0.7.0)
 
--   Avoid a packetstorm of device queries on startup
-    [\#297](https://github.com/matrix-org/matrix-js-sdk/pull/297)
--   E2E: Check devices to share keys with on each send
-    [\#295](https://github.com/matrix-org/matrix-js-sdk/pull/295)
--   Apply unknown-keyshare mitigations
-    [\#296](https://github.com/matrix-org/matrix-js-sdk/pull/296)
--   distinguish unknown users from deviceless users
-    [\#294](https://github.com/matrix-org/matrix-js-sdk/pull/294)
--   Allow starting client with initialSyncLimit = 0
-    [\#293](https://github.com/matrix-org/matrix-js-sdk/pull/293)
--   Make timeline-window \_unpaginate public and rename to unpaginate
-    [\#289](https://github.com/matrix-org/matrix-js-sdk/pull/289)
--   Send a STOPPED sync updated after call to stopClient
-    [\#286](https://github.com/matrix-org/matrix-js-sdk/pull/286)
--   Fix bug in verifying megolm event senders
-    [\#292](https://github.com/matrix-org/matrix-js-sdk/pull/292)
--   Handle decryption of events after they arrive
-    [\#288](https://github.com/matrix-org/matrix-js-sdk/pull/288)
--   Fix examples.
-    [\#287](https://github.com/matrix-org/matrix-js-sdk/pull/287)
--   Add a travis.yml
-    [\#278](https://github.com/matrix-org/matrix-js-sdk/pull/278)
--   Encrypt all events, including 'm.call.\*'
-    [\#277](https://github.com/matrix-org/matrix-js-sdk/pull/277)
--   Ignore reshares of known megolm sessions
-    [\#276](https://github.com/matrix-org/matrix-js-sdk/pull/276)
--   Log to the console on unknown session
-    [\#274](https://github.com/matrix-org/matrix-js-sdk/pull/274)
--   Make it easier for SDK users to wrap prevailing the 'request' function
-    [\#273](https://github.com/matrix-org/matrix-js-sdk/pull/273)
-
-# Changes in [0.6.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4) (2016-11-04)
-
+ * Avoid a packetstorm of device queries on startup
+   [\#297](https://github.com/matrix-org/matrix-js-sdk/pull/297)
+ * E2E: Check devices to share keys with on each send
+   [\#295](https://github.com/matrix-org/matrix-js-sdk/pull/295)
+ * Apply unknown-keyshare mitigations
+   [\#296](https://github.com/matrix-org/matrix-js-sdk/pull/296)
+ * distinguish unknown users from deviceless users
+   [\#294](https://github.com/matrix-org/matrix-js-sdk/pull/294)
+ * Allow starting client with initialSyncLimit = 0
+   [\#293](https://github.com/matrix-org/matrix-js-sdk/pull/293)
+ * Make timeline-window _unpaginate public and rename to unpaginate
+   [\#289](https://github.com/matrix-org/matrix-js-sdk/pull/289)
+ * Send a STOPPED sync updated after call to stopClient
+   [\#286](https://github.com/matrix-org/matrix-js-sdk/pull/286)
+ * Fix bug in verifying megolm event senders
+   [\#292](https://github.com/matrix-org/matrix-js-sdk/pull/292)
+ * Handle decryption of events after they arrive
+   [\#288](https://github.com/matrix-org/matrix-js-sdk/pull/288)
+ * Fix examples.
+   [\#287](https://github.com/matrix-org/matrix-js-sdk/pull/287)
+ * Add a travis.yml
+   [\#278](https://github.com/matrix-org/matrix-js-sdk/pull/278)
+ * Encrypt all events, including 'm.call.*'
+   [\#277](https://github.com/matrix-org/matrix-js-sdk/pull/277)
+ * Ignore reshares of known megolm sessions
+   [\#276](https://github.com/matrix-org/matrix-js-sdk/pull/276)
+ * Log to the console on unknown session
+   [\#274](https://github.com/matrix-org/matrix-js-sdk/pull/274)
+ * Make it easier for SDK users to wrap prevailing the 'request' function
+   [\#273](https://github.com/matrix-org/matrix-js-sdk/pull/273)
+
+Changes in [0.6.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4) (2016-11-04)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.4-rc.2...v0.6.4)
 
--   Change release script to pass version by environment variable
+ * Change release script to pass version by environment variable
 
-# Changes in [0.6.4-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.2) (2016-11-02)
 
+Changes in [0.6.4-rc.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.2) (2016-11-02)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.4-rc.1...v0.6.4-rc.2)
 
--   Add getRoomTags method to client
-    [\#236](https://github.com/matrix-org/matrix-js-sdk/pull/236)
-
-# Changes in [0.6.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.1) (2016-11-02)
+ * Add getRoomTags method to client
+   [\#236](https://github.com/matrix-org/matrix-js-sdk/pull/236)
 
+Changes in [0.6.4-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.4-rc.1) (2016-11-02)
+==========================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.3...v0.6.4-rc.1)
 
-## Breaking Changes
-
--   Bundled version of the JS SDK are no longer versioned along with
-    source files in the dist/ directory. As of this release, they
-    will be included in the release tarball, but not the source
-    repository.
-
-## Other Changes
-
--   More fixes to the release script
-    [\#272](https://github.com/matrix-org/matrix-js-sdk/pull/272)
--   Update the release process to use github releases
-    [\#271](https://github.com/matrix-org/matrix-js-sdk/pull/271)
--   Don't package the world when we release
-    [\#270](https://github.com/matrix-org/matrix-js-sdk/pull/270)
--   Add ability to set a filter prior to the first /sync
-    [\#269](https://github.com/matrix-org/matrix-js-sdk/pull/269)
--   Sign one-time keys, and verify their signatures
-    [\#243](https://github.com/matrix-org/matrix-js-sdk/pull/243)
--   Check for duplicate message indexes for group messages
-    [\#241](https://github.com/matrix-org/matrix-js-sdk/pull/241)
--   Rotate megolm sessions
-    [\#240](https://github.com/matrix-org/matrix-js-sdk/pull/240)
--   Check recipient and sender in Olm messages
-    [\#239](https://github.com/matrix-org/matrix-js-sdk/pull/239)
--   Consistency checks for E2E device downloads
-    [\#237](https://github.com/matrix-org/matrix-js-sdk/pull/237)
--   Support User-Interactive auth for delete device
-    [\#235](https://github.com/matrix-org/matrix-js-sdk/pull/235)
--   Utility to help with interactive auth
-    [\#234](https://github.com/matrix-org/matrix-js-sdk/pull/234)
--   Fix sync breaking when an invalid filterId is in localStorage
-    [\#228](https://github.com/matrix-org/matrix-js-sdk/pull/228)
-
-# Changes in [0.6.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.3) (2016-10-12)
-
+Breaking Changes
+----------------
+ * Bundled version of the JS SDK are no longer versioned along with
+   source files in the dist/ directory. As of this release, they
+   will be included in the release tarball, but not the source
+   repository.
+
+Other Changes
+-------------
+ * More fixes to the release script
+   [\#272](https://github.com/matrix-org/matrix-js-sdk/pull/272)
+ * Update the release process to use github releases
+   [\#271](https://github.com/matrix-org/matrix-js-sdk/pull/271)
+ * Don't package the world when we release
+   [\#270](https://github.com/matrix-org/matrix-js-sdk/pull/270)
+ * Add ability to set a filter prior to the first /sync
+   [\#269](https://github.com/matrix-org/matrix-js-sdk/pull/269)
+ * Sign one-time keys, and verify their signatures
+   [\#243](https://github.com/matrix-org/matrix-js-sdk/pull/243)
+ * Check for duplicate message indexes for group messages
+   [\#241](https://github.com/matrix-org/matrix-js-sdk/pull/241)
+ * Rotate megolm sessions
+   [\#240](https://github.com/matrix-org/matrix-js-sdk/pull/240)
+ * Check recipient and sender in Olm messages
+   [\#239](https://github.com/matrix-org/matrix-js-sdk/pull/239)
+ * Consistency checks for E2E device downloads
+   [\#237](https://github.com/matrix-org/matrix-js-sdk/pull/237)
+ * Support User-Interactive auth for delete device
+   [\#235](https://github.com/matrix-org/matrix-js-sdk/pull/235)
+ * Utility to help with interactive auth
+   [\#234](https://github.com/matrix-org/matrix-js-sdk/pull/234)
+ * Fix sync breaking when an invalid filterId is in localStorage
+   [\#228](https://github.com/matrix-org/matrix-js-sdk/pull/228)
+
+Changes in [0.6.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.3) (2016-10-12)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.2...v0.6.3)
 
-## Breaking Changes
-
--   Add a 'RECONNECTING' state to the sync states. This is an additional state
-    between 'SYNCING' and 'ERROR', so most clients should not notice.
-
-## Other Changes
-
--   Fix params getting replaced on register calls
-    [\#233](https://github.com/matrix-org/matrix-js-sdk/pull/233)
--   Fix potential 30s delay on reconnect
-    [\#232](https://github.com/matrix-org/matrix-js-sdk/pull/232)
--   uploadContent: Attempt some consistency between browser and node
-    [\#230](https://github.com/matrix-org/matrix-js-sdk/pull/230)
--   Fix error handling on uploadContent
-    [\#229](https://github.com/matrix-org/matrix-js-sdk/pull/229)
--   Fix uploadContent for node.js
-    [\#226](https://github.com/matrix-org/matrix-js-sdk/pull/226)
--   Don't emit ERROR until a keepalive poke fails
-    [\#223](https://github.com/matrix-org/matrix-js-sdk/pull/223)
--   Function to get the fallback url for interactive auth
-    [\#224](https://github.com/matrix-org/matrix-js-sdk/pull/224)
--   Revert "Handle the first /sync failure differently."
-    [\#222](https://github.com/matrix-org/matrix-js-sdk/pull/222)
-
-# Changes in [0.6.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.2) (2016-10-05)
-
+Breaking Changes
+----------------
+ * Add a 'RECONNECTING' state to the sync states. This is an additional state
+   between 'SYNCING' and 'ERROR', so most clients should not notice.
+
+Other Changes
+----------------
+ * Fix params getting replaced on register calls
+   [\#233](https://github.com/matrix-org/matrix-js-sdk/pull/233)
+ * Fix potential 30s delay on reconnect
+   [\#232](https://github.com/matrix-org/matrix-js-sdk/pull/232)
+ * uploadContent: Attempt some consistency between browser and node
+   [\#230](https://github.com/matrix-org/matrix-js-sdk/pull/230)
+ * Fix error handling on uploadContent
+   [\#229](https://github.com/matrix-org/matrix-js-sdk/pull/229)
+ * Fix uploadContent for node.js
+   [\#226](https://github.com/matrix-org/matrix-js-sdk/pull/226)
+ * Don't emit ERROR until a keepalive poke fails
+   [\#223](https://github.com/matrix-org/matrix-js-sdk/pull/223)
+ * Function to get the fallback url for interactive auth
+   [\#224](https://github.com/matrix-org/matrix-js-sdk/pull/224)
+ * Revert "Handle the first /sync failure differently."
+   [\#222](https://github.com/matrix-org/matrix-js-sdk/pull/222)
+
+Changes in [0.6.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.2) (2016-10-05)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.1...v0.6.2)
 
--   Check dependencies aren't on develop in release.sh
-    [\#221](https://github.com/matrix-org/matrix-js-sdk/pull/221)
--   Fix checkTurnServers leak on logout
-    [\#220](https://github.com/matrix-org/matrix-js-sdk/pull/220)
--   Fix leak of file upload objects
-    [\#219](https://github.com/matrix-org/matrix-js-sdk/pull/219)
--   crypto: remove duplicate code
-    [\#218](https://github.com/matrix-org/matrix-js-sdk/pull/218)
--   Add API for 3rd party location lookup
-    [\#217](https://github.com/matrix-org/matrix-js-sdk/pull/217)
--   Handle the first /sync failure differently.
-    [\#216](https://github.com/matrix-org/matrix-js-sdk/pull/216)
-
-# Changes in [0.6.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.1) (2016-09-21)
-
+ * Check dependencies aren't on develop in release.sh
+   [\#221](https://github.com/matrix-org/matrix-js-sdk/pull/221)
+ * Fix checkTurnServers leak on logout
+   [\#220](https://github.com/matrix-org/matrix-js-sdk/pull/220)
+ * Fix leak of file upload objects
+   [\#219](https://github.com/matrix-org/matrix-js-sdk/pull/219)
+ * crypto: remove duplicate code
+   [\#218](https://github.com/matrix-org/matrix-js-sdk/pull/218)
+ * Add API for 3rd party location lookup
+   [\#217](https://github.com/matrix-org/matrix-js-sdk/pull/217)
+ * Handle the first /sync failure differently.
+   [\#216](https://github.com/matrix-org/matrix-js-sdk/pull/216)
+
+Changes in [0.6.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.1) (2016-09-21)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.6.0...v0.6.1)
 
--   Fix the ed25519 key checking
-    [\#215](https://github.com/matrix-org/matrix-js-sdk/pull/215)
--   Add MatrixClient.getEventSenderDeviceInfo()
-    [\#214](https://github.com/matrix-org/matrix-js-sdk/pull/214)
-
-# Changes in [0.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.0) (2016-09-21)
+ * Fix the ed25519 key checking
+   [\#215](https://github.com/matrix-org/matrix-js-sdk/pull/215)
+ * Add MatrixClient.getEventSenderDeviceInfo()
+   [\#214](https://github.com/matrix-org/matrix-js-sdk/pull/214)
 
+Changes in [0.6.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.6.0) (2016-09-21)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.6...v0.6.0)
 
--   Pull user device list on join
-    [\#212](https://github.com/matrix-org/matrix-js-sdk/pull/212)
--   Fix sending of oh_hais on bad sessions
-    [\#213](https://github.com/matrix-org/matrix-js-sdk/pull/213)
--   Support /publicRooms pagination
-    [\#211](https://github.com/matrix-org/matrix-js-sdk/pull/211)
--   Update the olm library version to 1.3.0
-    [\#205](https://github.com/matrix-org/matrix-js-sdk/pull/205)
--   Comment what the logic in uploadKeys does
-    [\#209](https://github.com/matrix-org/matrix-js-sdk/pull/209)
--   Include keysProved and keysClaimed in the local echo for events we send.
-    [\#210](https://github.com/matrix-org/matrix-js-sdk/pull/210)
--   Check if we need to upload new one-time keys every 10 minutes
-    [\#208](https://github.com/matrix-org/matrix-js-sdk/pull/208)
--   Reset oneTimeKey to null on each loop iteration.
-    [\#207](https://github.com/matrix-org/matrix-js-sdk/pull/207)
--   Add getKeysProved and getKeysClaimed methods to MatrixEvent.
-    [\#206](https://github.com/matrix-org/matrix-js-sdk/pull/206)
--   Send a 'm.new_device' when we get a message for an unknown group session
-    [\#204](https://github.com/matrix-org/matrix-js-sdk/pull/204)
--   Introduce EventTimelineSet, filtered timelines and global notif timeline.
-    [\#196](https://github.com/matrix-org/matrix-js-sdk/pull/196)
--   Wrap the crypto event handlers in try/catch blocks
-    [\#203](https://github.com/matrix-org/matrix-js-sdk/pull/203)
--   Show warnings on to-device decryption fail
-    [\#202](https://github.com/matrix-org/matrix-js-sdk/pull/202)
--   s/Displayname/DisplayName/
-    [\#201](https://github.com/matrix-org/matrix-js-sdk/pull/201)
--   OH HAI
-    [\#200](https://github.com/matrix-org/matrix-js-sdk/pull/200)
--   Share the current ratchet with new members
-    [\#199](https://github.com/matrix-org/matrix-js-sdk/pull/199)
--   Move crypto bits into a subdirectory
-    [\#198](https://github.com/matrix-org/matrix-js-sdk/pull/198)
--   Refactor event handling in Crypto
-    [\#197](https://github.com/matrix-org/matrix-js-sdk/pull/197)
--   Don't create Olm sessions proactively
-    [\#195](https://github.com/matrix-org/matrix-js-sdk/pull/195)
--   Use to-device events for key sharing
-    [\#194](https://github.com/matrix-org/matrix-js-sdk/pull/194)
--   README: callbacks deprecated
-    [\#193](https://github.com/matrix-org/matrix-js-sdk/pull/193)
--   Fix sender verification for megolm messages
-    [\#192](https://github.com/matrix-org/matrix-js-sdk/pull/192)
--   Use `ciphertext` instead of `body` in megolm events
-    [\#191](https://github.com/matrix-org/matrix-js-sdk/pull/191)
--   Add debug methods to get the state of OlmSessions
-    [\#189](https://github.com/matrix-org/matrix-js-sdk/pull/189)
--   MatrixClient.getStoredDevicesForUser
-    [\#190](https://github.com/matrix-org/matrix-js-sdk/pull/190)
--   Olm-related cleanups
-    [\#188](https://github.com/matrix-org/matrix-js-sdk/pull/188)
--   Update to fixed olmlib
-    [\#187](https://github.com/matrix-org/matrix-js-sdk/pull/187)
--   always play audio out of the remoteAudioElement if it exists.
-    [\#186](https://github.com/matrix-org/matrix-js-sdk/pull/186)
--   Fix exceptions where HTMLMediaElement loads and plays race
-    [\#185](https://github.com/matrix-org/matrix-js-sdk/pull/185)
--   Reset megolm session when people join/leave the room
-    [\#183](https://github.com/matrix-org/matrix-js-sdk/pull/183)
--   Fix exceptions when dealing with redactions
-    [\#184](https://github.com/matrix-org/matrix-js-sdk/pull/184)
-
-# Changes in [0.5.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.6) (2016-08-28)
-
+ * Pull user device list on join
+   [\#212](https://github.com/matrix-org/matrix-js-sdk/pull/212)
+ * Fix sending of oh_hais on bad sessions
+   [\#213](https://github.com/matrix-org/matrix-js-sdk/pull/213)
+ * Support /publicRooms pagination
+   [\#211](https://github.com/matrix-org/matrix-js-sdk/pull/211)
+ * Update the olm library version to 1.3.0
+   [\#205](https://github.com/matrix-org/matrix-js-sdk/pull/205)
+ * Comment what the logic in uploadKeys does
+   [\#209](https://github.com/matrix-org/matrix-js-sdk/pull/209)
+ * Include keysProved and keysClaimed in the local echo for events we send.
+   [\#210](https://github.com/matrix-org/matrix-js-sdk/pull/210)
+ * Check if we need to upload new one-time keys every 10 minutes
+   [\#208](https://github.com/matrix-org/matrix-js-sdk/pull/208)
+ * Reset oneTimeKey to null on each loop iteration.
+   [\#207](https://github.com/matrix-org/matrix-js-sdk/pull/207)
+ * Add getKeysProved and getKeysClaimed methods to MatrixEvent.
+   [\#206](https://github.com/matrix-org/matrix-js-sdk/pull/206)
+ * Send a 'm.new_device' when we get a message for an unknown group session
+   [\#204](https://github.com/matrix-org/matrix-js-sdk/pull/204)
+ * Introduce EventTimelineSet, filtered timelines and global notif timeline.
+   [\#196](https://github.com/matrix-org/matrix-js-sdk/pull/196)
+ * Wrap the crypto event handlers in try/catch blocks
+   [\#203](https://github.com/matrix-org/matrix-js-sdk/pull/203)
+ * Show warnings on to-device decryption fail
+   [\#202](https://github.com/matrix-org/matrix-js-sdk/pull/202)
+ * s/Displayname/DisplayName/
+   [\#201](https://github.com/matrix-org/matrix-js-sdk/pull/201)
+ * OH HAI
+   [\#200](https://github.com/matrix-org/matrix-js-sdk/pull/200)
+ * Share the current ratchet with new members
+   [\#199](https://github.com/matrix-org/matrix-js-sdk/pull/199)
+ * Move crypto bits into a subdirectory
+   [\#198](https://github.com/matrix-org/matrix-js-sdk/pull/198)
+ * Refactor event handling in Crypto
+   [\#197](https://github.com/matrix-org/matrix-js-sdk/pull/197)
+ * Don't create Olm sessions proactively
+   [\#195](https://github.com/matrix-org/matrix-js-sdk/pull/195)
+ * Use to-device events for key sharing
+   [\#194](https://github.com/matrix-org/matrix-js-sdk/pull/194)
+ * README: callbacks deprecated
+   [\#193](https://github.com/matrix-org/matrix-js-sdk/pull/193)
+ * Fix sender verification for megolm messages
+   [\#192](https://github.com/matrix-org/matrix-js-sdk/pull/192)
+ * Use `ciphertext` instead of `body` in megolm events
+   [\#191](https://github.com/matrix-org/matrix-js-sdk/pull/191)
+ * Add debug methods to get the state of OlmSessions
+   [\#189](https://github.com/matrix-org/matrix-js-sdk/pull/189)
+ * MatrixClient.getStoredDevicesForUser
+   [\#190](https://github.com/matrix-org/matrix-js-sdk/pull/190)
+ * Olm-related cleanups
+   [\#188](https://github.com/matrix-org/matrix-js-sdk/pull/188)
+ * Update to fixed olmlib
+   [\#187](https://github.com/matrix-org/matrix-js-sdk/pull/187)
+ * always play audio out of the remoteAudioElement if it exists.
+   [\#186](https://github.com/matrix-org/matrix-js-sdk/pull/186)
+ * Fix exceptions where HTMLMediaElement loads and plays race
+   [\#185](https://github.com/matrix-org/matrix-js-sdk/pull/185)
+ * Reset megolm session when people join/leave the room
+   [\#183](https://github.com/matrix-org/matrix-js-sdk/pull/183)
+ * Fix exceptions when dealing with redactions
+   [\#184](https://github.com/matrix-org/matrix-js-sdk/pull/184)
+
+Changes in [0.5.6](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.6) (2016-08-28)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.5...v0.5.6)
 
--   Put all of the megolm keys in one room message
-    [\#182](https://github.com/matrix-org/matrix-js-sdk/pull/182)
--   Reinstate device blocking for simple Olm
-    [\#181](https://github.com/matrix-org/matrix-js-sdk/pull/181)
--   support for unpacking megolm keys
-    [\#180](https://github.com/matrix-org/matrix-js-sdk/pull/180)
--   Send out megolm keys when we start a megolm session
-    [\#179](https://github.com/matrix-org/matrix-js-sdk/pull/179)
--   Change the result structure for ensureOlmSessionsForUsers
-    [\#178](https://github.com/matrix-org/matrix-js-sdk/pull/178)
--   Factor out a function for doing olm encryption
-    [\#177](https://github.com/matrix-org/matrix-js-sdk/pull/177)
--   Move DeviceInfo and DeviceVerification to separate module
-    [\#175](https://github.com/matrix-org/matrix-js-sdk/pull/175)
--   Make encryption asynchronous
-    [\#176](https://github.com/matrix-org/matrix-js-sdk/pull/176)
--   Added ability to set and get status_msg for presence.
-    [\#167](https://github.com/matrix-org/matrix-js-sdk/pull/167)
--   Megolm: don't dereference nullable object
-    [\#174](https://github.com/matrix-org/matrix-js-sdk/pull/174)
--   Implement megolm encryption/decryption
-    [\#173](https://github.com/matrix-org/matrix-js-sdk/pull/173)
--   Update our push rules when they come down stream
-    [\#170](https://github.com/matrix-org/matrix-js-sdk/pull/170)
--   Factor Olm encryption/decryption out to new classes
-    [\#172](https://github.com/matrix-org/matrix-js-sdk/pull/172)
--   Make DeviceInfo more useful, and refactor crypto methods to use it
-    [\#171](https://github.com/matrix-org/matrix-js-sdk/pull/171)
--   Move login and register methods into base-apis
-    [\#169](https://github.com/matrix-org/matrix-js-sdk/pull/169)
--   Remove defaultDeviceDisplayName from MatrixClient options
-    [\#168](https://github.com/matrix-org/matrix-js-sdk/pull/168)
-
-# Changes in [0.5.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.5) (2016-08-11)
-
+ * Put all of the megolm keys in one room message
+   [\#182](https://github.com/matrix-org/matrix-js-sdk/pull/182)
+ * Reinstate device blocking for simple Olm
+   [\#181](https://github.com/matrix-org/matrix-js-sdk/pull/181)
+ * support for unpacking megolm keys
+   [\#180](https://github.com/matrix-org/matrix-js-sdk/pull/180)
+ * Send out megolm keys when we start a megolm session
+   [\#179](https://github.com/matrix-org/matrix-js-sdk/pull/179)
+ * Change the result structure for ensureOlmSessionsForUsers
+   [\#178](https://github.com/matrix-org/matrix-js-sdk/pull/178)
+ * Factor out a function for doing olm encryption
+   [\#177](https://github.com/matrix-org/matrix-js-sdk/pull/177)
+ * Move DeviceInfo and DeviceVerification to separate module
+   [\#175](https://github.com/matrix-org/matrix-js-sdk/pull/175)
+ * Make encryption asynchronous
+   [\#176](https://github.com/matrix-org/matrix-js-sdk/pull/176)
+ * Added ability to set and get status_msg for presence.
+   [\#167](https://github.com/matrix-org/matrix-js-sdk/pull/167)
+ * Megolm: don't dereference nullable object
+   [\#174](https://github.com/matrix-org/matrix-js-sdk/pull/174)
+ * Implement megolm encryption/decryption
+   [\#173](https://github.com/matrix-org/matrix-js-sdk/pull/173)
+ * Update our push rules when they come down stream
+   [\#170](https://github.com/matrix-org/matrix-js-sdk/pull/170)
+ * Factor Olm encryption/decryption out to new classes
+   [\#172](https://github.com/matrix-org/matrix-js-sdk/pull/172)
+ * Make DeviceInfo more useful, and refactor crypto methods to use it
+   [\#171](https://github.com/matrix-org/matrix-js-sdk/pull/171)
+ * Move login and register methods into base-apis
+   [\#169](https://github.com/matrix-org/matrix-js-sdk/pull/169)
+ * Remove defaultDeviceDisplayName from MatrixClient options
+   [\#168](https://github.com/matrix-org/matrix-js-sdk/pull/168)
+
+Changes in [0.5.5](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.5) (2016-08-11)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.4...v0.5.5)
 
--   Add room.getAliases() and room.getCanonicalAlias
--   Add API calls `/register/email/requestToken`, `/account/password/email/requestToken` and `/account/3pid/email/requestToken`
--   Add `User.currentlyActive` and `User.lastPresenceTs` events for changes in fields on the User object
--   Add `logout` and `deactivateAccount`
-
--   Make sure we actually stop the sync loop on logout
-    [\#166](https://github.com/matrix-org/matrix-js-sdk/pull/166)
--   Zero is a valid power level
-    [\#164](https://github.com/matrix-org/matrix-js-sdk/pull/164)
--   Verify e2e keys on download
-    [\#163](https://github.com/matrix-org/matrix-js-sdk/pull/163)
--   Factor crypto stuff out of MatrixClient
-    [\#162](https://github.com/matrix-org/matrix-js-sdk/pull/162)
--   Refactor device key upload
-    [\#161](https://github.com/matrix-org/matrix-js-sdk/pull/161)
--   Wrappers for devices API
-    [\#158](https://github.com/matrix-org/matrix-js-sdk/pull/158)
--   Add deactivate account function
-    [\#160](https://github.com/matrix-org/matrix-js-sdk/pull/160)
--   client.listDeviceKeys: Expose device display name
-    [\#159](https://github.com/matrix-org/matrix-js-sdk/pull/159)
--   Add `logout`
-    [\#157](https://github.com/matrix-org/matrix-js-sdk/pull/157)
--   Fix email registration
-    [\#156](https://github.com/matrix-org/matrix-js-sdk/pull/156)
--   Factor out MatrixClient methods to MatrixBaseApis
-    [\#155](https://github.com/matrix-org/matrix-js-sdk/pull/155)
--   Fix some broken tests
-    [\#154](https://github.com/matrix-org/matrix-js-sdk/pull/154)
--   make jenkins fail the build if the tests fail
-    [\#153](https://github.com/matrix-org/matrix-js-sdk/pull/153)
--   deviceId-related fixes
-    [\#152](https://github.com/matrix-org/matrix-js-sdk/pull/152)
--   /login, /register: Add device_id and initial_device_display_name
-    [\#151](https://github.com/matrix-org/matrix-js-sdk/pull/151)
--   Support global account_data
-    [\#150](https://github.com/matrix-org/matrix-js-sdk/pull/150)
--   Add more events to User
-    [\#149](https://github.com/matrix-org/matrix-js-sdk/pull/149)
--   Add API calls for other requestToken endpoints
-    [\#148](https://github.com/matrix-org/matrix-js-sdk/pull/148)
--   Add register-specific request token endpoint
-    [\#147](https://github.com/matrix-org/matrix-js-sdk/pull/147)
--   Set a valid SPDX license identifier in package.json
-    [\#139](https://github.com/matrix-org/matrix-js-sdk/pull/139)
--   Configure encryption on m.room.encryption events
-    [\#145](https://github.com/matrix-org/matrix-js-sdk/pull/145)
--   Implement device blocking
-    [\#146](https://github.com/matrix-org/matrix-js-sdk/pull/146)
--   Clearer doc for setRoomDirectoryVisibility
-    [\#144](https://github.com/matrix-org/matrix-js-sdk/pull/144)
--   crypto: use memberlist to derive recipient list
-    [\#143](https://github.com/matrix-org/matrix-js-sdk/pull/143)
--   Support for marking devices as unverified
-    [\#142](https://github.com/matrix-org/matrix-js-sdk/pull/142)
--   Add Olm as an optionalDependency
-    [\#141](https://github.com/matrix-org/matrix-js-sdk/pull/141)
--   Add room.getAliases() and room.getCanonicalAlias()
-    [\#140](https://github.com/matrix-org/matrix-js-sdk/pull/140)
--   Change how MatrixEvent manages encrypted events
-    [\#138](https://github.com/matrix-org/matrix-js-sdk/pull/138)
--   Catch exceptions when encrypting events
-    [\#137](https://github.com/matrix-org/matrix-js-sdk/pull/137)
--   Support for marking devices as verified
-    [\#136](https://github.com/matrix-org/matrix-js-sdk/pull/136)
--   Various matrix-client refactorings and fixes
-    [\#134](https://github.com/matrix-org/matrix-js-sdk/pull/134)
-
-# Changes in [0.5.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.4) (2016-06-02)
-
+ * Add room.getAliases() and room.getCanonicalAlias
+ * Add API calls `/register/email/requestToken`, `/account/password/email/requestToken` and `/account/3pid/email/requestToken`
+ * Add `User.currentlyActive` and `User.lastPresenceTs` events for changes in fields on the User object
+ * Add `logout` and `deactivateAccount`
+
+ * Make sure we actually stop the sync loop on logout
+   [\#166](https://github.com/matrix-org/matrix-js-sdk/pull/166)
+ * Zero is a valid power level
+   [\#164](https://github.com/matrix-org/matrix-js-sdk/pull/164)
+ * Verify e2e keys on download
+   [\#163](https://github.com/matrix-org/matrix-js-sdk/pull/163)
+ * Factor crypto stuff out of MatrixClient
+   [\#162](https://github.com/matrix-org/matrix-js-sdk/pull/162)
+ * Refactor device key upload
+   [\#161](https://github.com/matrix-org/matrix-js-sdk/pull/161)
+ * Wrappers for devices API
+   [\#158](https://github.com/matrix-org/matrix-js-sdk/pull/158)
+ * Add deactivate account function
+   [\#160](https://github.com/matrix-org/matrix-js-sdk/pull/160)
+ * client.listDeviceKeys: Expose device display name
+   [\#159](https://github.com/matrix-org/matrix-js-sdk/pull/159)
+ * Add `logout`
+   [\#157](https://github.com/matrix-org/matrix-js-sdk/pull/157)
+ * Fix email registration
+   [\#156](https://github.com/matrix-org/matrix-js-sdk/pull/156)
+ * Factor out MatrixClient methods to MatrixBaseApis
+   [\#155](https://github.com/matrix-org/matrix-js-sdk/pull/155)
+ * Fix some broken tests
+   [\#154](https://github.com/matrix-org/matrix-js-sdk/pull/154)
+ * make jenkins fail the build if the tests fail
+   [\#153](https://github.com/matrix-org/matrix-js-sdk/pull/153)
+ * deviceId-related fixes
+   [\#152](https://github.com/matrix-org/matrix-js-sdk/pull/152)
+ * /login, /register: Add device_id and initial_device_display_name
+   [\#151](https://github.com/matrix-org/matrix-js-sdk/pull/151)
+ * Support global account_data
+   [\#150](https://github.com/matrix-org/matrix-js-sdk/pull/150)
+ * Add more events to User
+   [\#149](https://github.com/matrix-org/matrix-js-sdk/pull/149)
+ * Add API calls for other requestToken endpoints
+   [\#148](https://github.com/matrix-org/matrix-js-sdk/pull/148)
+ * Add register-specific request token endpoint
+   [\#147](https://github.com/matrix-org/matrix-js-sdk/pull/147)
+ * Set a valid SPDX license identifier in package.json
+   [\#139](https://github.com/matrix-org/matrix-js-sdk/pull/139)
+ * Configure encryption on m.room.encryption events
+   [\#145](https://github.com/matrix-org/matrix-js-sdk/pull/145)
+ * Implement device blocking
+   [\#146](https://github.com/matrix-org/matrix-js-sdk/pull/146)
+ * Clearer doc for setRoomDirectoryVisibility
+   [\#144](https://github.com/matrix-org/matrix-js-sdk/pull/144)
+ * crypto: use memberlist to derive recipient list
+   [\#143](https://github.com/matrix-org/matrix-js-sdk/pull/143)
+ * Support for marking devices as unverified
+   [\#142](https://github.com/matrix-org/matrix-js-sdk/pull/142)
+ * Add Olm as an optionalDependency
+   [\#141](https://github.com/matrix-org/matrix-js-sdk/pull/141)
+ * Add room.getAliases() and room.getCanonicalAlias()
+   [\#140](https://github.com/matrix-org/matrix-js-sdk/pull/140)
+ * Change how MatrixEvent manages encrypted events
+   [\#138](https://github.com/matrix-org/matrix-js-sdk/pull/138)
+ * Catch exceptions when encrypting events
+   [\#137](https://github.com/matrix-org/matrix-js-sdk/pull/137)
+ * Support for marking devices as verified
+   [\#136](https://github.com/matrix-org/matrix-js-sdk/pull/136)
+ * Various matrix-client refactorings and fixes
+   [\#134](https://github.com/matrix-org/matrix-js-sdk/pull/134)
+
+Changes in [0.5.4](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.4) (2016-06-02)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.3...v0.5.4)
 
--   Correct fix for https://github.com/vector-im/vector-web/issues/1039
--   Make release.sh work on OSX
+ * Correct fix for https://github.com/vector-im/vector-web/issues/1039
+ * Make release.sh work on OSX
 
-# Changes in [0.5.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.3) (2016-06-02)
 
+Changes in [0.5.3](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.3) (2016-06-02)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.2...v0.5.3)
 
--   Add support for the openid interface
-    [\#133](https://github.com/matrix-org/matrix-js-sdk/pull/133)
--   Bugfix for HTTP upload content when running on node
-    [\#129](https://github.com/matrix-org/matrix-js-sdk/pull/129)
--   Ignore missing profile (displayname and avatar_url) fields on
-    presence events, rather than overwriting existing valid profile
-    data from membership events or elsewhere.
-    Fixes https://github.com/vector-im/vector-web/issues/1039
-
-# Changes in [0.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.2) (2016-04-19)
-
+ * Add support for the openid interface
+   [\#133](https://github.com/matrix-org/matrix-js-sdk/pull/133)
+ * Bugfix for HTTP upload content when running on node
+   [\#129](https://github.com/matrix-org/matrix-js-sdk/pull/129)
+ * Ignore missing profile (displayname and avatar_url) fields on
+   presence events, rather than overwriting existing valid profile
+   data from membership events or elsewhere.
+   Fixes https://github.com/vector-im/vector-web/issues/1039
+
+Changes in [0.5.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.2) (2016-04-19)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.1...v0.5.2)
 
--   Track the absolute time that presence events are received, so that the
-    relative lastActiveAgo value is meaningful.
-    [\#128](https://github.com/matrix-org/matrix-js-sdk/pull/128)
--   Refactor the addition of events to rooms
-    [\#127](https://github.com/matrix-org/matrix-js-sdk/pull/127)
--   Clean up test shutdown
-    [\#126](https://github.com/matrix-org/matrix-js-sdk/pull/126)
--   Add methods to get (and set) pushers
-    [\#125](https://github.com/matrix-org/matrix-js-sdk/pull/125)
--   URL previewing support
-    [\#122](https://github.com/matrix-org/matrix-js-sdk/pull/122)
--   Avoid paginating forever in private rooms
-    [\#124](https://github.com/matrix-org/matrix-js-sdk/pull/124)
--   Fix a bug where we recreated sync filters
-    [\#123](https://github.com/matrix-org/matrix-js-sdk/pull/123)
--   Implement HTTP timeouts in realtime
-    [\#121](https://github.com/matrix-org/matrix-js-sdk/pull/121)
-
-# Changes in [0.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.1) (2016-03-30)
-
+ * Track the absolute time that presence events are received, so that the
+   relative lastActiveAgo value is meaningful.
+   [\#128](https://github.com/matrix-org/matrix-js-sdk/pull/128)
+ * Refactor the addition of events to rooms
+   [\#127](https://github.com/matrix-org/matrix-js-sdk/pull/127)
+ * Clean up test shutdown
+   [\#126](https://github.com/matrix-org/matrix-js-sdk/pull/126)
+ * Add methods to get (and set) pushers
+   [\#125](https://github.com/matrix-org/matrix-js-sdk/pull/125)
+ * URL previewing support
+   [\#122](https://github.com/matrix-org/matrix-js-sdk/pull/122)
+ * Avoid paginating forever in private rooms
+   [\#124](https://github.com/matrix-org/matrix-js-sdk/pull/124)
+ * Fix a bug where we recreated sync filters
+   [\#123](https://github.com/matrix-org/matrix-js-sdk/pull/123)
+ * Implement HTTP timeouts in realtime
+   [\#121](https://github.com/matrix-org/matrix-js-sdk/pull/121)
+
+Changes in [0.5.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.1) (2016-03-30)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.5.0...v0.5.1)
 
--   Only count joined members for the member count in notifications.
-    [\#119](https://github.com/matrix-org/matrix-js-sdk/pull/119)
--   Add maySendEvent to match maySendStateEvent
-    [\#118](https://github.com/matrix-org/matrix-js-sdk/pull/118)
-
-# Changes in [0.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.0) (2016-03-22)
+ * Only count joined members for the member count in notifications.
+   [\#119](https://github.com/matrix-org/matrix-js-sdk/pull/119)
+ * Add maySendEvent to match maySendStateEvent
+   [\#118](https://github.com/matrix-org/matrix-js-sdk/pull/118)
 
+Changes in [0.5.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.5.0) (2016-03-22)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.4.2...v0.5.0)
 
 **BREAKING CHANGES**:
-
--   `opts.pendingEventOrdering`==`end` is no longer supported in the arguments to
-    `MatrixClient.startClient()`. Instead we provide a `detached` option, which
-    puts pending events into a completely separate list in the Room, accessible
-    via `Room.getPendingEvents()`.
-    [\#111](https://github.com/matrix-org/matrix-js-sdk/pull/111)
+ * `opts.pendingEventOrdering`==`end` is no longer supported in the arguments to
+   `MatrixClient.startClient()`. Instead we provide a `detached` option, which
+   puts pending events into a completely separate list in the Room, accessible
+   via `Room.getPendingEvents()`.
+   [\#111](https://github.com/matrix-org/matrix-js-sdk/pull/111)
 
 Other improvements:
-
--   Log the stack when we get a sync error
-    [\#109](https://github.com/matrix-org/matrix-js-sdk/pull/109)
--   Refactor transmitted-messages code
-    [\#110](https://github.com/matrix-org/matrix-js-sdk/pull/110)
--   Add a method to the js sdk to look up 3pids on the ID server.
-    [\#113](https://github.com/matrix-org/matrix-js-sdk/pull/113)
--   Support for cancelling pending events
-    [\#112](https://github.com/matrix-org/matrix-js-sdk/pull/112)
--   API to stop peeking
-    [\#114](https://github.com/matrix-org/matrix-js-sdk/pull/114)
--   update store user metadata based on membership events rather than presence
-    [\#116](https://github.com/matrix-org/matrix-js-sdk/pull/116)
--   Include a counter in generated transaction IDs
-    [\#115](https://github.com/matrix-org/matrix-js-sdk/pull/115)
--   get/setRoomVisibility API
-    [\#117](https://github.com/matrix-org/matrix-js-sdk/pull/117)
-
-# Changes in [0.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.4.2) (2016-03-17)
-
+ * Log the stack when we get a sync error
+   [\#109](https://github.com/matrix-org/matrix-js-sdk/pull/109)
+ * Refactor transmitted-messages code
+   [\#110](https://github.com/matrix-org/matrix-js-sdk/pull/110)
+ * Add a method to the js sdk to look up 3pids on the ID server.
+   [\#113](https://github.com/matrix-org/matrix-js-sdk/pull/113)
+ * Support for cancelling pending events
+   [\#112](https://github.com/matrix-org/matrix-js-sdk/pull/112)
+ * API to stop peeking
+   [\#114](https://github.com/matrix-org/matrix-js-sdk/pull/114)
+ * update store user metadata based on membership events rather than presence
+   [\#116](https://github.com/matrix-org/matrix-js-sdk/pull/116)
+ * Include a counter in generated transaction IDs
+   [\#115](https://github.com/matrix-org/matrix-js-sdk/pull/115)
+ * get/setRoomVisibility API
+   [\#117](https://github.com/matrix-org/matrix-js-sdk/pull/117)
+
+Changes in [0.4.2](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v0.4.2) (2016-03-17)
+================================================================================================
 [Full Changelog](https://github.com/matrix-org/matrix-js-sdk/compare/v0.4.1...v0.4.2)
 
--   Try again if a pagination request gives us no new messages
-    [\#98](https://github.com/matrix-org/matrix-js-sdk/pull/98)
--   Add a delay before we start polling the connectivity check endpoint
-    [\#99](https://github.com/matrix-org/matrix-js-sdk/pull/99)
--   Clean up a codepath that was only used for crypto messages
-    [\#101](https://github.com/matrix-org/matrix-js-sdk/pull/101)
--   Add maySendStateEvent method, ported from react-sdk (but fixed).
-    [\#94](https://github.com/matrix-org/matrix-js-sdk/pull/94)
--   Add Session.logged_out event
-    [\#100](https://github.com/matrix-org/matrix-js-sdk/pull/100)
--   make presence work when peeking.
-    [\#103](https://github.com/matrix-org/matrix-js-sdk/pull/103)
--   Add RoomState.mayClientSendStateEvent()
-    [\#104](https://github.com/matrix-org/matrix-js-sdk/pull/104)
--   Fix displaynames for member join events
-    [\#108](https://github.com/matrix-org/matrix-js-sdk/pull/108)
-
-# Changes in 0.4.1
+ * Try again if a pagination request gives us no new messages
+   [\#98](https://github.com/matrix-org/matrix-js-sdk/pull/98)
+ * Add a delay before we start polling the connectivity check endpoint
+   [\#99](https://github.com/matrix-org/matrix-js-sdk/pull/99)
+ * Clean up a codepath that was only used for crypto messages
+   [\#101](https://github.com/matrix-org/matrix-js-sdk/pull/101)
+ * Add maySendStateEvent method, ported from react-sdk (but fixed).
+   [\#94](https://github.com/matrix-org/matrix-js-sdk/pull/94)
+ * Add Session.logged_out event
+   [\#100](https://github.com/matrix-org/matrix-js-sdk/pull/100)
+ * make presence work when peeking.
+   [\#103](https://github.com/matrix-org/matrix-js-sdk/pull/103)
+ * Add RoomState.mayClientSendStateEvent()
+   [\#104](https://github.com/matrix-org/matrix-js-sdk/pull/104)
+ * Fix displaynames for member join events
+   [\#108](https://github.com/matrix-org/matrix-js-sdk/pull/108)
+
+Changes in 0.4.1
+================
 
 Improvements:
-
--   Check that `/sync` filters are correct before reusing them, and recreate
-    them if not (https://github.com/matrix-org/matrix-js-sdk/pull/85).
--   Fire a `Room.timelineReset` event when a room's timeline is reset by a gappy
-    `/sync` (https://github.com/matrix-org/matrix-js-sdk/pull/87,
-    https://github.com/matrix-org/matrix-js-sdk/pull/93).
--   Make `TimelineWindow.load()` faster in the simple case of loading the live
-    timeline (https://github.com/matrix-org/matrix-js-sdk/pull/88).
--   Update room-name calculation code to use the name of the sender of the
-    invite when invited to a room
-    (https://github.com/matrix-org/matrix-js-sdk/pull/89).
--   Don't reset the timeline when we join a room after peeking into it
-    (https://github.com/matrix-org/matrix-js-sdk/pull/91).
--   Fire `Room.localEchoUpdated` events as local echoes progress through their
-    transmission process (https://github.com/matrix-org/matrix-js-sdk/pull/95,
-    https://github.com/matrix-org/matrix-js-sdk/pull/97).
--   Avoid getting stuck in a pagination loop when the server sends us only
-    messages we've already seen
-    (https://github.com/matrix-org/matrix-js-sdk/pull/96).
+ * Check that `/sync` filters are correct before reusing them, and recreate
+   them if not (https://github.com/matrix-org/matrix-js-sdk/pull/85).
+ * Fire a `Room.timelineReset` event when a room's timeline is reset by a gappy
+   `/sync` (https://github.com/matrix-org/matrix-js-sdk/pull/87,
+   https://github.com/matrix-org/matrix-js-sdk/pull/93).
+ * Make `TimelineWindow.load()` faster in the simple case of loading the live
+   timeline (https://github.com/matrix-org/matrix-js-sdk/pull/88).
+ * Update room-name calculation code to use the name of the sender of the
+   invite when invited to a room
+   (https://github.com/matrix-org/matrix-js-sdk/pull/89).
+ * Don't reset the timeline when we join a room after peeking into it
+   (https://github.com/matrix-org/matrix-js-sdk/pull/91).
+ * Fire `Room.localEchoUpdated` events as local echoes progress through their
+   transmission process (https://github.com/matrix-org/matrix-js-sdk/pull/95,
+   https://github.com/matrix-org/matrix-js-sdk/pull/97).
+ * Avoid getting stuck in a pagination loop when the server sends us only
+   messages we've already seen
+   (https://github.com/matrix-org/matrix-js-sdk/pull/96).
 
 New methods:
+ * Add `MatrixClient.setPushRuleActions` to set the actions for a push
+   notification rule (https://github.com/matrix-org/matrix-js-sdk/pull/90)
+ * Add `RoomState.maySendStateEvent` which determines if a given user has
+   permission to send a state event
+   (https://github.com/matrix-org/matrix-js-sdk/pull/94)
 
--   Add `MatrixClient.setPushRuleActions` to set the actions for a push
-    notification rule (https://github.com/matrix-org/matrix-js-sdk/pull/90)
--   Add `RoomState.maySendStateEvent` which determines if a given user has
-    permission to send a state event
-    (https://github.com/matrix-org/matrix-js-sdk/pull/94)
-
-# Changes in 0.4.0
+Changes in 0.4.0
+================
 
 **BREAKING CHANGES**:
-
--   `RoomMember.getAvatarUrl()` and `MatrixClient.mxcUrlToHttp()` now return the
+ * `RoomMember.getAvatarUrl()` and `MatrixClient.mxcUrlToHttp()` now return the
     empty string when given anything other than an mxc:// URL. This ensures that
     clients never inadvertantly reference content directly, leaking information
     to third party servers. The `allowDirectLinks` option is provided if the client
     wants to allow such links.
--   Add a 'bindEmail' option to register()
+ * Add a 'bindEmail' option to register()
 
 Improvements:
+ * Support third party invites
+ * More appropriate naming for third party invite rooms
+ * Poll the 'versions' endpoint to re-establish connectivity
+ * Catch exceptions when syncing
+ * Room tag support
+ * Generate implicit read receipts
+ * Support CAS login
+ * Guest access support
+ * Never return non-mxc URLs by default
+ * Ability to cancel file uploads
+ * Use the Matrix C/S API v2 with r0 prefix
+ * Account data support
+ * Support non-contiguous event timelines
+ * Support new unread counts
+ * Local echo for read-receipts
 
--   Support third party invites
--   More appropriate naming for third party invite rooms
--   Poll the 'versions' endpoint to re-establish connectivity
--   Catch exceptions when syncing
--   Room tag support
--   Generate implicit read receipts
--   Support CAS login
--   Guest access support
--   Never return non-mxc URLs by default
--   Ability to cancel file uploads
--   Use the Matrix C/S API v2 with r0 prefix
--   Account data support
--   Support non-contiguous event timelines
--   Support new unread counts
--   Local echo for read-receipts
 
 New methods:
-
--   Add method to fetch URLs not on the home or identity server
--   Method to get the last receipt for a user
--   Method to get all known users
--   Method to delete an alias
-
-# Changes in 0.3.0
-
--   `MatrixClient.getAvatarUrlForMember` has been removed and replaced with
-    `RoomMember.getAvatarUrl`. Arguments remain the same except the homeserver
-    URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
-
-    ```javascript
-    // before
-    var url = client.getAvatarUrlForMember(member, width, height, resize, allowDefault);
-    // after
-    var url = member.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault);
-    ```
-
--   `MatrixClient.getAvatarUrlForRoom` has been removed and replaced with
-    `Room.getAvatarUrl`. Arguments remain the same except the homeserver
-    URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
-
-    ```javascript
-    // before
-    var url = client.getAvatarUrlForRoom(room, width, height, resize, allowDefault);
-    // after
-    var url = room.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault);
-    ```
-
--   `s/Room.getMembersWithMemership/Room.getMembersWithMem`b`ership/g`
+ * Add method to fetch URLs not on the home or identity server
+ * Method to get the last receipt for a user
+ * Method to get all known users
+ * Method to delete an alias
+
+
+Changes in 0.3.0
+================
+
+ * `MatrixClient.getAvatarUrlForMember` has been removed and replaced with
+   `RoomMember.getAvatarUrl`. Arguments remain the same except the homeserver
+   URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
+
+   ```javascript
+   // before
+   var url = client.getAvatarUrlForMember(member, width, height, resize, allowDefault)
+   // after
+   var url = member.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault)
+   ```
+ * `MatrixClient.getAvatarUrlForRoom` has been removed and replaced with
+   `Room.getAvatarUrl`. Arguments remain the same except the homeserver
+   URL must now be supplied from `MatrixClient.getHomeserverUrl()`.
+
+   ```javascript
+   // before
+   var url = client.getAvatarUrlForRoom(room, width, height, resize, allowDefault)
+   // after
+   var url = room.getAvatarUrl(client.getHomeserverUrl(), width, height, resize, allowDefault)
+   ```
+
+ * `s/Room.getMembersWithMemership/Room.getMembersWithMem`b`ership/g`
 
 New methods:
-
--   Added support for sending receipts via
-    `MatrixClient.sendReceipt(event, receiptType, callback)` and
-    `MatrixClient.sendReadReceipt(event, callback)`.
--   Added support for receiving receipts via
-    `Room.getReceiptsForEvent(event)` and `Room.getUsersReadUpTo(event)`. Receipts
-    can be directly added to a `Room` using `Room.addReceipt(event)` though the
-    `MatrixClient` does this for you.
--   Added support for muting local video and audio via the new methods
-    `MatrixCall.setMicrophoneMuted()`, `MatrixCall.isMicrophoneMuted(muted)`,
-    `MatrixCall.isLocalVideoMuted()` and `Matrix.setLocalVideoMuted(muted)`.
--   Added **experimental** support for screen-sharing in Chrome via
-    `MatrixCall.placeScreenSharingCall(remoteVideoElement, localVideoElement)`.
--   Added ability to perform server-side searches using
-    `MatrixClient.searchMessageText(opts)` and `MatrixClient.search(opts)`.
+ * Added support for sending receipts via
+   `MatrixClient.sendReceipt(event, receiptType, callback)` and
+   `MatrixClient.sendReadReceipt(event, callback)`.
+ * Added support for receiving receipts via
+   `Room.getReceiptsForEvent(event)` and `Room.getUsersReadUpTo(event)`. Receipts
+   can be directly added to a `Room` using `Room.addReceipt(event)` though the
+   `MatrixClient` does this for you.
+ * Added support for muting local video and audio via the new methods
+   `MatrixCall.setMicrophoneMuted()`, `MatrixCall.isMicrophoneMuted(muted)`,
+   `MatrixCall.isLocalVideoMuted()` and `Matrix.setLocalVideoMuted(muted)`.
+ * Added **experimental** support for screen-sharing in Chrome via
+   `MatrixCall.placeScreenSharingCall(remoteVideoElement, localVideoElement)`.
+ * Added ability to perform server-side searches using
+   `MatrixClient.searchMessageText(opts)` and `MatrixClient.search(opts)`.
 
 Improvements:
-
--   Improve the performance of initial sync processing from `O(n^2)` to `O(n)`.
--   `Room.name` will now take into account `m.room.canonical_alias` events.
--   `MatrixClient.startClient` now takes an Object `opts` rather than a Number in
-    a backwards-compatible way. This `opts` allows syncing configuration options
-    to be specified including `includeArchivedRooms` and `resolveInvitesToProfiles`.
--   `Room` objects which represent room invitations will now have state populated
-    from `invite_room_state` if it is included in the `m.room.member` event.
--   `Room.getAvatarUrl` will now take into account `m.room.avatar` events.
-
-# Changes in 0.2.2
+ * Improve the performance of initial sync processing from `O(n^2)` to `O(n)`.
+ * `Room.name` will now take into account `m.room.canonical_alias` events.
+ * `MatrixClient.startClient` now takes an Object `opts` rather than a Number in
+   a backwards-compatible way. This `opts` allows syncing configuration options
+   to be specified including `includeArchivedRooms` and `resolveInvitesToProfiles`.
+ * `Room` objects which represent room invitations will now have state populated
+   from `invite_room_state` if it is included in the `m.room.member` event.
+ * `Room.getAvatarUrl` will now take into account `m.room.avatar` events.
+
+Changes in 0.2.2
+================
 
 Bug fixes:
-
--   Null pointer fixes for VoIP calling and push notification processing.
--   Set the `Content-Type` to `application/octet-stream` in the event that the
-    file object has no `type`.
+ * Null pointer fixes for VoIP calling and push notification processing.
+ * Set the `Content-Type` to `application/octet-stream` in the event that the
+   file object has no `type`.
 
 New methods:
-
--   Added `MatrixClient.getCasServer()` which calls through to the HTTP endpoint
-    `/login/cas`.
--   Added `MatrixClient.loginWithCas(ticket, service)` which logs in with the
-    type `m.login.cas`.
--   Added `MatrixClient.getHomeserverUrl()` which returns the URL passed in the
-    constructor.
--   Added `MatrixClient.getIdentityServerUrl()` which returns the URL passed in
-    the constructor.
--   Added `getLastModifiedTime()` to `RoomMember`, `RoomState` and `User` objects.
-    This makes it easier to see if the object in question has changed, which can
-    be used to improve performance by only rendering when these objects change.
-
-# Changes in 0.2.1
+ * Added `MatrixClient.getCasServer()` which calls through to the HTTP endpoint
+   `/login/cas`.
+ * Added `MatrixClient.loginWithCas(ticket, service)` which logs in with the
+   type `m.login.cas`.
+ * Added `MatrixClient.getHomeserverUrl()` which returns the URL passed in the
+   constructor.
+ * Added `MatrixClient.getIdentityServerUrl()` which returns the URL passed in
+   the constructor.
+ * Added `getLastModifiedTime()` to `RoomMember`, `RoomState` and `User` objects.
+   This makes it easier to see if the object in question has changed, which can
+   be used to improve performance by only rendering when these objects change.
+
+Changes in 0.2.1
+================
 
 **BREAKING CHANGES**
-
--   `MatrixClient.joinRoom` has changed from `(roomIdOrAlias, callback)` to
-    `(roomIdOrAlias, opts, callback)`.
+ * `MatrixClient.joinRoom` has changed from `(roomIdOrAlias, callback)` to
+   `(roomIdOrAlias, opts, callback)`.
 
 Bug fixes:
-
--   The `Content-Type` of file uploads is now explicitly set, without relying
-    on the browser to do it for us.
+ * The `Content-Type` of file uploads is now explicitly set, without relying
+   on the browser to do it for us.
 
 Improvements:
-
--   The `MatrixScheduler.RETRY_BACKOFF_RATELIMIT` function will not retry when
-    the response is a 400,401,403.
--   The text returned from a room invite now includes who the invite was from.
--   There is now a try/catch block around the `request` function which will
-    reject/errback appropriately if an exception is thrown synchronously in it.
+ * The `MatrixScheduler.RETRY_BACKOFF_RATELIMIT` function will not retry when
+   the response is a 400,401,403.
+ * The text returned from a room invite now includes who the invite was from.
+ * There is now a try/catch block around the `request` function which will
+   reject/errback appropriately if an exception is thrown synchronously in it.
 
 New methods:
-
--   `MatrixClient.createAlias(alias, roomId)`
--   `MatrixClient.getRoomIdForAlias(alias)`
--   `MatrixClient.sendNotice(roomId, body, txnId, callback)`
--   `MatrixClient.sendHtmlNotice(roomId, body, htmlBody, callback)`
+ * `MatrixClient.createAlias(alias, roomId)`
+ * `MatrixClient.getRoomIdForAlias(alias)`
+ * `MatrixClient.sendNotice(roomId, body, txnId, callback)`
+ * `MatrixClient.sendHtmlNotice(roomId, body, htmlBody, callback)`
 
 Modified methods:
+ * `MatrixClient.joinRoom(roomIdOrAlias, opts)` where `opts` can include a
+   `syncRoom: true|false` flag to control whether a room initial sync is
+   performed after joining the room.
+ * `MatrixClient.getAvatarUrlForMember` has a new last arg `allowDefault` which
+   returns the default identicon URL if `true`.
+ * `MatrixClient.getAvatarUrlForRoom` has a new last arg `allowDefault` which
+   is passed through to the default identicon generation for
+   `getAvatarUrlForMember`.
 
--   `MatrixClient.joinRoom(roomIdOrAlias, opts)` where `opts` can include a
-    `syncRoom: true|false` flag to control whether a room initial sync is
-    performed after joining the room.
--   `MatrixClient.getAvatarUrlForMember` has a new last arg `allowDefault` which
-    returns the default identicon URL if `true`.
--   `MatrixClient.getAvatarUrlForRoom` has a new last arg `allowDefault` which
-    is passed through to the default identicon generation for
-    `getAvatarUrlForMember`.
 
-# Changes in 0.2.0
+Changes in 0.2.0
+================
 
 **BREAKING CHANGES**:
-
--   `MatrixClient.setPowerLevel` now expects a `MatrixEvent` and not an `Object`
-    for the `event` parameter.
+ * `MatrixClient.setPowerLevel` now expects a `MatrixEvent` and not an `Object`
+   for the `event` parameter.
 
 New features:
-
--   Added `EventStatus.QUEUED` which is set on an event when it is waiting to be
-    sent by the scheduler and there are other events in front.
--   Added support for processing push rules on an event. This can be obtained by
-    calling `MatrixClient.getPushActionsForEvent(event)`.
--   Added WebRTC support. Outbound calls can be made via
-    `call = global.createNewMatrixCall(MatrixClient, roomId)` followed by
-    `call.placeVoiceCall()` or `call.placeVideoCall(remoteEle, localEle)`.
-    Inbound calls will be received via the event `"Call.incoming"` which provides
-    a call object which can be followed with `call.answer()` or `call.hangup()`.
--   Added the ability to upload files to the media repository.
--   Added the ability to change the client's password.
--   Added the ability to register with an email via an identity server.
--   Handle presence events by updating the associated `User` object.
--   Handle redaction events.
--   Added infrastructure for supporting End-to-End encryption. E2E is _NOT_
-    available in this version.
+ * Added `EventStatus.QUEUED` which is set on an event when it is waiting to be
+   sent by the scheduler and there are other events in front.
+ * Added support for processing push rules on an event. This can be obtained by
+   calling `MatrixClient.getPushActionsForEvent(event)`.
+ * Added WebRTC support. Outbound calls can be made via
+   `call = global.createNewMatrixCall(MatrixClient, roomId)` followed by
+   `call.placeVoiceCall()` or `call.placeVideoCall(remoteEle, localEle)`.
+   Inbound calls will be received via the event `"Call.incoming"` which provides
+   a call object which can be followed with `call.answer()` or `call.hangup()`.
+ * Added the ability to upload files to the media repository.
+ * Added the ability to change the client's password.
+ * Added the ability to register with an email via an identity server.
+ * Handle presence events by updating the associated `User` object.
+ * Handle redaction events.
+ * Added infrastructure for supporting End-to-End encryption. E2E is *NOT*
+   available in this version.
 
 New methods:
-
--   `MatrixClient.getUser(userId)`
--   `MatrixClient.getPushActionsForEvent(event)`
--   `MatrixClient.setPassword(auth, newPassword)`
--   `MatrixClient.loginWithSAML2(relayState, callback)`
--   `MatrixClient.getAvatarUrlForMember(member, w, h, method)`
--   `MatrixClient.mxcUrlToHttp(url, w, h, method)`
--   `MatrixClient.getAvatarUrlForRoom(room, w, h, method)`
--   `MatrixClient.uploadContent(file, callback)`
--   `Room.getMembersWithMembership(membership)`
--   `MatrixScheduler.getQueueForEvent(event)`
--   `MatrixScheduler.removeEventFromQueue(event)`
--   `$DATA_STORE.setSyncToken(token)`
--   `$DATA_STORE.getSyncToken()`
-
-Crypto infrastructure (crypto is _NOT_ available in this version):
-
--   `global.CRYPTO_ENABLED`
--   `MatrixClient.isCryptoEnabled()`
--   `MatrixClient.uploadKeys(maxKeys)`
--   `MatrixClient.downloadKeys(userIds, forceDownload)`
--   `MatrixClient.listDeviceKeys(userId)`
--   `MatrixClient.setRoomEncryption(roomId, config)`
--   `MatrixClient.isRoomEncrypted(roomId)`
+ * `MatrixClient.getUser(userId)`
+ * `MatrixClient.getPushActionsForEvent(event)`
+ * `MatrixClient.setPassword(auth, newPassword)`
+ * `MatrixClient.loginWithSAML2(relayState, callback)`
+ * `MatrixClient.getAvatarUrlForMember(member, w, h, method)`
+ * `MatrixClient.mxcUrlToHttp(url, w, h, method)`
+ * `MatrixClient.getAvatarUrlForRoom(room, w, h, method)`
+ * `MatrixClient.uploadContent(file, callback)`
+ * `Room.getMembersWithMembership(membership)`
+ * `MatrixScheduler.getQueueForEvent(event)`
+ * `MatrixScheduler.removeEventFromQueue(event)`
+ * `$DATA_STORE.setSyncToken(token)`
+ * `$DATA_STORE.getSyncToken()`
+
+Crypto infrastructure (crypto is *NOT* available in this version):
+ * `global.CRYPTO_ENABLED`
+ * `MatrixClient.isCryptoEnabled()`
+ * `MatrixClient.uploadKeys(maxKeys)`
+ * `MatrixClient.downloadKeys(userIds, forceDownload)`
+ * `MatrixClient.listDeviceKeys(userId)`
+ * `MatrixClient.setRoomEncryption(roomId, config)`
+ * `MatrixClient.isRoomEncrypted(roomId)`
 
 New classes:
-
--   `MatrixCall`
--   `WebStorageStore` - _WIP; unstable_
--   `WebStorageSessionStore` - _WIP; unstable_
+ * `MatrixCall`
+ * `WebStorageStore` - *WIP; unstable*
+ * `WebStorageSessionStore` - *WIP; unstable*
 
 Bug fixes:
-
--   Member name bugfix: Fixed an issue which prevented `RoomMember.name` being
-    disambiguated if there was exactly 1 other person with the same display name.
--   Member name bugfix: Disambiguate both clashing display names with user IDs in
-    the event of a clash.
--   Room state bugfix: Fixed a bug which incorrectly overwrote power levels
-    locally for a room.
--   Room name bugfix: Ignore users who have left the room when determining a room
-    name.
--   Events bugfix: Fixed a bug which prevented the `sender` and `target`
-    properties from being set.
-
-# Changes in 0.1.1
+ * Member name bugfix: Fixed an issue which prevented `RoomMember.name` being
+   disambiguated if there was exactly 1 other person with the same display name.
+ * Member name bugfix: Disambiguate both clashing display names with user IDs in
+   the event of a clash.
+ * Room state bugfix: Fixed a bug which incorrectly overwrote power levels
+   locally for a room.
+ * Room name bugfix: Ignore users who have left the room when determining a room
+   name.
+ * Events bugfix: Fixed a bug which prevented the `sender` and `target`
+   properties from being set.
+
+Changes in 0.1.1
+================
 
 **BREAKING CHANGES**:
-
--   `Room.calculateRoomName` is now private. Use `Room.recalculate` instead, and
-    access the calculated name via `Room.name`.
--   `new MatrixClient(...)` no longer creates a `MatrixInMemoryStore` if
-    `opts.store` is not specified. Instead, the `createClient` global function
-    creates it and passes it to the constructor. This change will not affect
-    users who have always used `createClient` to create a `MatrixClient`.
--   `"Room"` events will now be emitted when the Room has _finished_ being
-    populated with state rather than at the moment of creation. This will fire
-    when the SDK encounters a room it doesn't know about (just arrived from the
-    event stream; e.g. a room invite) and will also fire after syncing room
-    state (e.g. after calling joinRoom).
--   `MatrixClient.joinRoom` now returns a `Room` object when resolved, not an
-    object with a `room_id` property.
--   `MatrixClient.scrollback` now expects a `Room` arg instead of a `room_id`
-    and `from` token. Construct a `new Room(roomId)` if you want to continue
-    using this directly, then set the pagination token using
-    `room.oldState.paginationToken = from`. It now resolves to a `Room` object
-    instead of the raw HTTP response.
+ * `Room.calculateRoomName` is now private. Use `Room.recalculate` instead, and
+   access the calculated name via `Room.name`.
+ * `new MatrixClient(...)` no longer creates a `MatrixInMemoryStore` if
+   `opts.store` is not specified. Instead, the `createClient` global function
+   creates it and passes it to the constructor. This change will not affect
+   users who have always used `createClient` to create a `MatrixClient`.
+ * `"Room"` events will now be emitted when the Room has *finished* being
+   populated with state rather than at the moment of creation. This will fire
+   when the SDK encounters a room it doesn't know about (just arrived from the
+   event stream; e.g. a room invite) and will also fire after syncing room
+   state (e.g. after calling joinRoom).
+ * `MatrixClient.joinRoom` now returns a `Room` object when resolved, not an
+   object with a `room_id` property.
+ * `MatrixClient.scrollback` now expects a `Room` arg instead of a `room_id`
+   and `from` token. Construct a `new Room(roomId)` if you want to continue
+   using this directly, then set the pagination token using
+   `room.oldState.paginationToken = from`. It now resolves to a `Room` object
+   instead of the raw HTTP response.
 
 New properties:
-
--   `User.events`
--   `RoomMember.events`
+ * `User.events`
+ * `RoomMember.events`
 
 New methods:
-
--   `Room.hasMembershipState(userId, membership)`
--   `MatrixClient.resendEvent(event, room)`
+ * `Room.hasMembershipState(userId, membership)`
+ * `MatrixClient.resendEvent(event, room)`
 
 New features:
-
--   Local echo. When you send an event using the SDK it will immediately be
-    added to `Room.timeline` with the `event.status` of `EventStatus.SENDING`.
-    When the event is finally sent, this status will be removed.
--   Not sent status. When an event fails to send using the SDK, it will have the
-    `event.status` of `EventStatus.NOT_SENT`.
--   Retries. If events fail to send, they will be automatically retried.
--   Manual resending. Events which failed to send can be passed to
-    `MatrixClient.resendEvent(event, room)` to resend them.
--   Queueing. Messages sent in quick succession will be queued to preserve the
-    order in which they were submitted.
--   Room state is automatcally synchronised when joining a room (including if
-    another device joins a room).
--   Scrollback. You can request earlier events in a room using
-    `MatrixClient.scrollback(room, limit, callback)`.
+ * Local echo. When you send an event using the SDK it will immediately be
+   added to `Room.timeline` with the `event.status` of `EventStatus.SENDING`.
+   When the event is finally sent, this status will be removed.
+ * Not sent status. When an event fails to send using the SDK, it will have the
+   `event.status` of `EventStatus.NOT_SENT`.
+ * Retries. If events fail to send, they will be automatically retried.
+ * Manual resending. Events which failed to send can be passed to
+   `MatrixClient.resendEvent(event, room)` to resend them.
+ * Queueing. Messages sent in quick succession will be queued to preserve the
+   order in which they were submitted.
+ * Room state is automatcally synchronised when joining a room (including if
+   another device joins a room).
+ * Scrollback. You can request earlier events in a room using
+   `MatrixClient.scrollback(room, limit, callback)`.
 
 Bug fixes:
-
--   Fixed a bug which prevented the event stream from polling. Some devices will
-    black hole requests when they hibernate, meaning that the callbacks will
-    never fire. We now maintain a local timer to forcibly restart the request.
+ * Fixed a bug which prevented the event stream from polling. Some devices will
+   black hole requests when they hibernate, meaning that the callbacks will
+   never fire. We now maintain a local timer to forcibly restart the request.

From 7f1fe46c7cbf0ead171196179467377a58f70f1e Mon Sep 17 00:00:00 2001
From: RiotRobot <releases@riot.im>
Date: Wed, 14 Dec 2022 08:49:15 +0000
Subject: [PATCH 54/60] Prepare changelog for v23.0.0-rc.1

---
 CHANGELOG.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e5dd9237cf8..b5ce7162c42 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,32 @@
+Changes in [23.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v23.0.0-rc.1) (2022-12-14)
+============================================================================================================
+
+## 🚨 BREAKING CHANGES
+ * Process `m.room.encryption` events before emitting `RoomMember` events ([\#2914](https://github.com/matrix-org/matrix-js-sdk/pull/2914)). Fixes vector-im/element-web#23819.
+
+## ✨ Features
+ * Support MSC3391: Account data deletion ([\#2967](https://github.com/matrix-org/matrix-js-sdk/pull/2967)).
+ * Add a message ID on each to-device message ([\#2938](https://github.com/matrix-org/matrix-js-sdk/pull/2938)).
+ * Enable multiple users' power levels to be set at once ([\#2892](https://github.com/matrix-org/matrix-js-sdk/pull/2892)). Contributed by @GoodGuyMarco.
+ * Include pending events in thread summary and count again ([\#2922](https://github.com/matrix-org/matrix-js-sdk/pull/2922)). Fixes vector-im/element-web#23642.
+ * Make GroupCall work better with widgets ([\#2935](https://github.com/matrix-org/matrix-js-sdk/pull/2935)).
+ * Add method to get outgoing room key requests for a given event ([\#2930](https://github.com/matrix-org/matrix-js-sdk/pull/2930)).
+
+## 🐛 Bug Fixes
+ * Fix messages loaded during initial fetch ending up out of order ([\#2971](https://github.com/matrix-org/matrix-js-sdk/pull/2971)). Fixes vector-im/element-web#23972.
+ * Fix #23919: Root message for new thread loaded from network ([\#2965](https://github.com/matrix-org/matrix-js-sdk/pull/2965)). Fixes vector-im/element-web#23919.
+ * Fix #23916: Prevent edits of the last message in a thread getting lost ([\#2951](https://github.com/matrix-org/matrix-js-sdk/pull/2951)). Fixes vector-im/element-web#23916 and vector-im/element-web#23942.
+ * Fix infinite loop when restoring cached read receipts ([\#2963](https://github.com/matrix-org/matrix-js-sdk/pull/2963)). Fixes vector-im/element-web#23951.
+ * Don't swallow errors coming from the shareSession call ([\#2962](https://github.com/matrix-org/matrix-js-sdk/pull/2962)). Fixes vector-im/element-web#23792.
+ * Make sure that MegolmEncryption.setupPromise always resolves  ([\#2960](https://github.com/matrix-org/matrix-js-sdk/pull/2960)).
+ * Do not calculate highlight notifs for threads unknown to the room ([\#2957](https://github.com/matrix-org/matrix-js-sdk/pull/2957)).
+ * Cache read receipts for unknown threads ([\#2953](https://github.com/matrix-org/matrix-js-sdk/pull/2953)).
+ * bugfix: sliding sync initial room timelines shouldn't notify ([\#2933](https://github.com/matrix-org/matrix-js-sdk/pull/2933)).
+ * Redo key sharing after own device verification ([\#2921](https://github.com/matrix-org/matrix-js-sdk/pull/2921)). Fixes vector-im/element-web#23333.
+ * Move updated threads to the end of the thread list ([\#2923](https://github.com/matrix-org/matrix-js-sdk/pull/2923)). Fixes vector-im/element-web#23876.
+ * Fix highlight notifications increasing when total notification is zero ([\#2937](https://github.com/matrix-org/matrix-js-sdk/pull/2937)). Fixes vector-im/element-web#23885.
+ * Fix synthesizeReceipt ([\#2916](https://github.com/matrix-org/matrix-js-sdk/pull/2916)). Fixes vector-im/element-web#23827 vector-im/element-web#23754 and vector-im/element-web#23847.
+
 Changes in [22.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v22.0.0) (2022-12-06)
 ==================================================================================================
 

From 6cc8e4436ced7500979db7101e00f7af5d1c92e4 Mon Sep 17 00:00:00 2001
From: RiotRobot <releases@riot.im>
Date: Wed, 14 Dec 2022 08:49:15 +0000
Subject: [PATCH 55/60] v23.0.0-rc.1

---
 package.json | 285 ++++++++++++++++++++++++++-------------------------
 1 file changed, 143 insertions(+), 142 deletions(-)

diff --git a/package.json b/package.json
index 128de735ea3..dfaa7c23cb8 100644
--- a/package.json
+++ b/package.json
@@ -1,146 +1,147 @@
 {
-    "name": "matrix-js-sdk",
-    "version": "22.0.0",
-    "description": "Matrix Client-Server SDK for Javascript",
-    "engines": {
-        "node": ">=16.0.0"
-    },
-    "scripts": {
-        "prepublishOnly": "yarn build",
-        "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
-        "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
-        "clean": "rimraf lib dist",
-        "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
-        "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
-        "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
-        "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
-        "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
-        "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
-        "gendoc": "typedoc",
-        "lint": "yarn lint:types && yarn lint:js",
-        "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
-        "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
-        "lint:types": "tsc --noEmit",
-        "test": "jest",
-        "test:watch": "jest --watch",
-        "coverage": "yarn test --coverage"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/matrix-org/matrix-js-sdk"
-    },
-    "keywords": [
-        "matrix-org"
+  "name": "matrix-js-sdk",
+  "version": "23.0.0-rc.1",
+  "description": "Matrix Client-Server SDK for Javascript",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "prepublishOnly": "yarn build",
+    "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
+    "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
+    "clean": "rimraf lib dist",
+    "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
+    "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
+    "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
+    "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
+    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
+    "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
+    "gendoc": "typedoc",
+    "lint": "yarn lint:types && yarn lint:js",
+    "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
+    "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
+    "lint:types": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "coverage": "yarn test --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/matrix-org/matrix-js-sdk"
+  },
+  "keywords": [
+    "matrix-org"
+  ],
+  "main": "./lib/index.js",
+  "browser": "./lib/browser-index.ts",
+  "matrix_src_main": "./src/index.ts",
+  "matrix_src_browser": "./src/browser-index.ts",
+  "matrix_lib_main": "./lib/index.js",
+  "matrix_lib_typings": "./lib/index.d.ts",
+  "author": "matrix.org",
+  "license": "Apache-2.0",
+  "files": [
+    "dist",
+    "lib",
+    "src",
+    "git-revision.txt",
+    "CHANGELOG.md",
+    "CONTRIBUTING.rst",
+    "LICENSE",
+    "README.md",
+    "package.json",
+    "release.sh"
+  ],
+  "dependencies": {
+    "@babel/runtime": "^7.12.5",
+    "another-json": "^0.2.0",
+    "bs58": "^5.0.0",
+    "content-type": "^1.0.4",
+    "loglevel": "^1.7.1",
+    "matrix-events-sdk": "0.0.1",
+    "matrix-widget-api": "^1.0.0",
+    "p-retry": "4",
+    "qs": "^6.9.6",
+    "sdp-transform": "^2.14.1",
+    "unhomoglyph": "^1.0.6",
+    "uuid": "7"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.12.10",
+    "@babel/core": "^7.12.10",
+    "@babel/eslint-parser": "^7.12.10",
+    "@babel/eslint-plugin": "^7.12.10",
+    "@babel/plugin-proposal-class-properties": "^7.12.1",
+    "@babel/plugin-proposal-numeric-separator": "^7.12.7",
+    "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-runtime": "^7.12.10",
+    "@babel/preset-env": "^7.12.11",
+    "@babel/preset-typescript": "^7.12.7",
+    "@babel/register": "^7.12.10",
+    "@casualbot/jest-sonar-reporter": "^2.2.5",
+    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
+    "@types/bs58": "^4.0.1",
+    "@types/content-type": "^1.1.5",
+    "@types/domexception": "^4.0.0",
+    "@types/jest": "^29.0.0",
+    "@types/node": "18",
+    "@types/sdp-transform": "^2.4.5",
+    "@types/uuid": "7",
+    "@typescript-eslint/eslint-plugin": "^5.45.0",
+    "@typescript-eslint/parser": "^5.45.0",
+    "allchange": "^1.0.6",
+    "babel-jest": "^29.0.0",
+    "babelify": "^10.0.0",
+    "better-docs": "^2.4.0-beta.9",
+    "browserify": "^17.0.0",
+    "docdash": "^2.0.0",
+    "domexception": "^4.0.0",
+    "eslint": "8.28.0",
+    "eslint-config-google": "^0.14.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-import-resolver-typescript": "^3.5.1",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jsdoc": "^39.6.4",
+    "eslint-plugin-matrix-org": "^0.9.0",
+    "eslint-plugin-tsdoc": "^0.2.17",
+    "eslint-plugin-unicorn": "^45.0.0",
+    "exorcist": "^2.0.0",
+    "fake-indexeddb": "^4.0.0",
+    "jest": "^29.0.0",
+    "jest-environment-jsdom": "^29.0.0",
+    "jest-localstorage-mock": "^2.4.6",
+    "jest-mock": "^29.0.0",
+    "matrix-mock-request": "^2.5.0",
+    "prettier": "2.8.0",
+    "rimraf": "^3.0.2",
+    "terser": "^5.5.1",
+    "tsify": "^5.0.2",
+    "typedoc": "^0.23.20",
+    "typedoc-plugin-missing-exports": "^1.0.0",
+    "typescript": "^4.5.3"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "<rootDir>/spec/**/*.spec.{js,ts}"
     ],
-    "main": "./src/index.ts",
-    "browser": "./lib/browser-index.ts",
-    "matrix_src_main": "./src/index.ts",
-    "matrix_src_browser": "./src/browser-index.ts",
-    "matrix_lib_main": "./lib/index.js",
-    "matrix_lib_typings": "./lib/index.d.ts",
-    "author": "matrix.org",
-    "license": "Apache-2.0",
-    "files": [
-        "dist",
-        "lib",
-        "src",
-        "git-revision.txt",
-        "CHANGELOG.md",
-        "CONTRIBUTING.rst",
-        "LICENSE",
-        "README.md",
-        "package.json",
-        "release.sh"
+    "setupFilesAfterEnv": [
+      "<rootDir>/spec/setupTests.ts"
     ],
-    "dependencies": {
-        "@babel/runtime": "^7.12.5",
-        "another-json": "^0.2.0",
-        "bs58": "^5.0.0",
-        "content-type": "^1.0.4",
-        "loglevel": "^1.7.1",
-        "matrix-events-sdk": "0.0.1",
-        "matrix-widget-api": "^1.0.0",
-        "p-retry": "4",
-        "qs": "^6.9.6",
-        "sdp-transform": "^2.14.1",
-        "unhomoglyph": "^1.0.6",
-        "uuid": "7"
-    },
-    "devDependencies": {
-        "@babel/cli": "^7.12.10",
-        "@babel/core": "^7.12.10",
-        "@babel/eslint-parser": "^7.12.10",
-        "@babel/eslint-plugin": "^7.12.10",
-        "@babel/plugin-proposal-class-properties": "^7.12.1",
-        "@babel/plugin-proposal-numeric-separator": "^7.12.7",
-        "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
-        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-        "@babel/plugin-transform-runtime": "^7.12.10",
-        "@babel/preset-env": "^7.12.11",
-        "@babel/preset-typescript": "^7.12.7",
-        "@babel/register": "^7.12.10",
-        "@casualbot/jest-sonar-reporter": "^2.2.5",
-        "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
-        "@types/bs58": "^4.0.1",
-        "@types/content-type": "^1.1.5",
-        "@types/domexception": "^4.0.0",
-        "@types/jest": "^29.0.0",
-        "@types/node": "18",
-        "@types/sdp-transform": "^2.4.5",
-        "@types/uuid": "7",
-        "@typescript-eslint/eslint-plugin": "^5.45.0",
-        "@typescript-eslint/parser": "^5.45.0",
-        "allchange": "^1.0.6",
-        "babel-jest": "^29.0.0",
-        "babelify": "^10.0.0",
-        "better-docs": "^2.4.0-beta.9",
-        "browserify": "^17.0.0",
-        "docdash": "^2.0.0",
-        "domexception": "^4.0.0",
-        "eslint": "8.28.0",
-        "eslint-config-google": "^0.14.0",
-        "eslint-config-prettier": "^8.5.0",
-        "eslint-import-resolver-typescript": "^3.5.1",
-        "eslint-plugin-import": "^2.26.0",
-        "eslint-plugin-jsdoc": "^39.6.4",
-        "eslint-plugin-matrix-org": "^0.9.0",
-        "eslint-plugin-tsdoc": "^0.2.17",
-        "eslint-plugin-unicorn": "^45.0.0",
-        "exorcist": "^2.0.0",
-        "fake-indexeddb": "^4.0.0",
-        "jest": "^29.0.0",
-        "jest-environment-jsdom": "^29.0.0",
-        "jest-localstorage-mock": "^2.4.6",
-        "jest-mock": "^29.0.0",
-        "matrix-mock-request": "^2.5.0",
-        "prettier": "2.8.0",
-        "rimraf": "^3.0.2",
-        "terser": "^5.5.1",
-        "tsify": "^5.0.2",
-        "typedoc": "^0.23.20",
-        "typedoc-plugin-missing-exports": "^1.0.0",
-        "typescript": "^4.5.3"
-    },
-    "jest": {
-        "testEnvironment": "node",
-        "testMatch": [
-            "<rootDir>/spec/**/*.spec.{js,ts}"
-        ],
-        "setupFilesAfterEnv": [
-            "<rootDir>/spec/setupTests.ts"
-        ],
-        "collectCoverageFrom": [
-            "<rootDir>/src/**/*.{js,ts}"
-        ],
-        "coverageReporters": [
-            "text-summary",
-            "lcov"
-        ],
-        "testResultsProcessor": "@casualbot/jest-sonar-reporter"
-    },
-    "@casualbot/jest-sonar-reporter": {
-        "outputDirectory": "coverage",
-        "outputName": "jest-sonar-report.xml",
-        "relativePaths": true
-    }
+    "collectCoverageFrom": [
+      "<rootDir>/src/**/*.{js,ts}"
+    ],
+    "coverageReporters": [
+      "text-summary",
+      "lcov"
+    ],
+    "testResultsProcessor": "@casualbot/jest-sonar-reporter"
+  },
+  "@casualbot/jest-sonar-reporter": {
+    "outputDirectory": "coverage",
+    "outputName": "jest-sonar-report.xml",
+    "relativePaths": true
+  },
+  "typings": "./lib/index.d.ts"
 }

From b31712f2ffb30f8ea2027649cd33b49c79e38d81 Mon Sep 17 00:00:00 2001
From: ElementRobot <releases@riot.im>
Date: Tue, 20 Dec 2022 17:27:18 +0000
Subject: [PATCH 56/60] [Backport staging] Threads are missing from the
 timeline (#2997)

(cherry picked from commit 4f86eee2504661e90edce06fe2d57d13f6fd741f)

Co-authored-by: Janne Mareike Koschinski <jannemk@element.io>
---
 .../matrix-client-event-timeline.spec.ts      | 55 +++++++++++++++++++
 src/client.ts                                 |  2 +-
 2 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/spec/integ/matrix-client-event-timeline.spec.ts b/spec/integ/matrix-client-event-timeline.spec.ts
index b02955511e9..9d71f060b48 100644
--- a/spec/integ/matrix-client-event-timeline.spec.ts
+++ b/spec/integ/matrix-client-event-timeline.spec.ts
@@ -1016,6 +1016,61 @@ describe("MatrixClient event timelines", function () {
                 httpBackend.flushAllExpected(),
             ]);
         });
+
+        it("should create threads for thread roots discovered", function () {
+            const room = client.getRoom(roomId)!;
+            const timelineSet = room.getTimelineSets()[0];
+
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/context/" + encodeURIComponent(EVENTS[0].event_id!))
+                .respond(200, function () {
+                    return {
+                        start: "start_token0",
+                        events_before: [],
+                        event: EVENTS[0],
+                        events_after: [],
+                        end: "end_token0",
+                        state: [],
+                    };
+                });
+
+            httpBackend
+                .when("GET", "/rooms/!foo%3Abar/messages")
+                .check(function (req) {
+                    const params = req.queryParams!;
+                    expect(params.dir).toEqual("b");
+                    expect(params.from).toEqual("start_token0");
+                    expect(params.limit).toEqual("30");
+                })
+                .respond(200, function () {
+                    return {
+                        chunk: [EVENTS[1], EVENTS[2], THREAD_ROOT],
+                        end: "start_token1",
+                    };
+                });
+
+            let tl: EventTimeline;
+            return Promise.all([
+                client
+                    .getEventTimeline(timelineSet, EVENTS[0].event_id!)
+                    .then(function (tl0) {
+                        tl = tl0!;
+                        return client.paginateEventTimeline(tl, { backwards: true });
+                    })
+                    .then(function (success) {
+                        expect(success).toBeTruthy();
+                        expect(tl!.getEvents().length).toEqual(4);
+                        expect(tl!.getEvents()[0].event).toEqual(THREAD_ROOT);
+                        expect(tl!.getEvents()[1].event).toEqual(EVENTS[2]);
+                        expect(tl!.getEvents()[2].event).toEqual(EVENTS[1]);
+                        expect(tl!.getEvents()[3].event).toEqual(EVENTS[0]);
+                        expect(room.getThreads().map((it) => it.id)).toEqual([THREAD_ROOT.event_id!]);
+                        expect(tl!.getPaginationToken(EventTimeline.BACKWARDS)).toEqual("start_token1");
+                        expect(tl!.getPaginationToken(EventTimeline.FORWARDS)).toEqual("end_token0");
+                    }),
+                httpBackend.flushAllExpected(),
+            ]);
+        });
     });
 
     describe("paginateEventTimeline for thread list timeline", function () {
diff --git a/src/client.ts b/src/client.ts
index 83c4ac2cd12..a4aa9ded27c 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -5951,7 +5951,7 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
                     this.processBeaconEvents(room, timelineEvents);
                     this.processThreadRoots(
                         room,
-                        timelineEvents.filter((it) => it.isRelation(THREAD_RELATION_TYPE.name)),
+                        timelineEvents.filter((it) => it.getServerAggregatedRelation(THREAD_RELATION_TYPE.name)),
                         false,
                     );
 

From fdd1428e1962c231d3153ab8f3d48ce68af626bf Mon Sep 17 00:00:00 2001
From: ElementRobot <releases@riot.im>
Date: Wed, 21 Dec 2022 09:37:40 +0000
Subject: [PATCH 57/60] [Backport staging] Fix release scripts to not fight
 with prettier (#3000)

(cherry picked from commit ec2405ac99fd1734b3fd074c030656c14a8677ee)

Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>
---
 release.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/release.sh b/release.sh
index 92a593e180b..ae23183841b 100755
--- a/release.sh
+++ b/release.sh
@@ -184,7 +184,7 @@ for i in main typings
 do
     lib_value=$(jq -r ".matrix_lib_$i" package.json)
     if [ "$lib_value" != "null" ]; then
-        jq ".$i = .matrix_lib_$i" package.json > package.json.new && mv package.json.new package.json
+        jq ".$i = .matrix_lib_$i" package.json > package.json.new && mv package.json.new package.json && prettier --write package.json
     fi
 done
 

From 52ed04c82584263633626ddbe555e1ebd7f9ea3e Mon Sep 17 00:00:00 2001
From: RiotRobot <releases@riot.im>
Date: Wed, 21 Dec 2022 16:38:37 +0000
Subject: [PATCH 58/60] Fix release call to prettier

---
 release.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/release.sh b/release.sh
index ae23183841b..c5f798f400b 100755
--- a/release.sh
+++ b/release.sh
@@ -184,7 +184,7 @@ for i in main typings
 do
     lib_value=$(jq -r ".matrix_lib_$i" package.json)
     if [ "$lib_value" != "null" ]; then
-        jq ".$i = .matrix_lib_$i" package.json > package.json.new && mv package.json.new package.json && prettier --write package.json
+        jq ".$i = .matrix_lib_$i" package.json > package.json.new && mv package.json.new package.json && yarn prettier --write package.json
     fi
 done
 

From aab873fc58e25b2fd131ff7867c1877ae6e0ca79 Mon Sep 17 00:00:00 2001
From: RiotRobot <releases@riot.im>
Date: Wed, 21 Dec 2022 16:40:28 +0000
Subject: [PATCH 59/60] Prepare changelog for v23.0.0

---
 CHANGELOG.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b5ce7162c42..e05be659ebf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,9 @@
-Changes in [23.0.0-rc.1](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v23.0.0-rc.1) (2022-12-14)
-============================================================================================================
+Changes in [23.0.0](https://github.com/matrix-org/matrix-js-sdk/releases/tag/v23.0.0) (2022-12-21)
+==================================================================================================
 
 ## 🚨 BREAKING CHANGES
  * Process `m.room.encryption` events before emitting `RoomMember` events ([\#2914](https://github.com/matrix-org/matrix-js-sdk/pull/2914)). Fixes vector-im/element-web#23819.
+ * Don't expose `calls` on `GroupCall` ([\#2941](https://github.com/matrix-org/matrix-js-sdk/pull/2941)).
 
 ## ✨ Features
  * Support MSC3391: Account data deletion ([\#2967](https://github.com/matrix-org/matrix-js-sdk/pull/2967)).

From efc87d808446e19875c33287356fa20cbc81f4a3 Mon Sep 17 00:00:00 2001
From: RiotRobot <releases@riot.im>
Date: Wed, 21 Dec 2022 16:40:30 +0000
Subject: [PATCH 60/60] v23.0.0

---
 package.json | 286 +++++++++++++++++++++++++--------------------------
 1 file changed, 143 insertions(+), 143 deletions(-)

diff --git a/package.json b/package.json
index dfaa7c23cb8..68c7102840b 100644
--- a/package.json
+++ b/package.json
@@ -1,147 +1,147 @@
 {
-  "name": "matrix-js-sdk",
-  "version": "23.0.0-rc.1",
-  "description": "Matrix Client-Server SDK for Javascript",
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "scripts": {
-    "prepublishOnly": "yarn build",
-    "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
-    "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
-    "clean": "rimraf lib dist",
-    "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
-    "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
-    "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
-    "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
-    "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
-    "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
-    "gendoc": "typedoc",
-    "lint": "yarn lint:types && yarn lint:js",
-    "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
-    "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
-    "lint:types": "tsc --noEmit",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "coverage": "yarn test --coverage"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/matrix-org/matrix-js-sdk"
-  },
-  "keywords": [
-    "matrix-org"
-  ],
-  "main": "./lib/index.js",
-  "browser": "./lib/browser-index.ts",
-  "matrix_src_main": "./src/index.ts",
-  "matrix_src_browser": "./src/browser-index.ts",
-  "matrix_lib_main": "./lib/index.js",
-  "matrix_lib_typings": "./lib/index.d.ts",
-  "author": "matrix.org",
-  "license": "Apache-2.0",
-  "files": [
-    "dist",
-    "lib",
-    "src",
-    "git-revision.txt",
-    "CHANGELOG.md",
-    "CONTRIBUTING.rst",
-    "LICENSE",
-    "README.md",
-    "package.json",
-    "release.sh"
-  ],
-  "dependencies": {
-    "@babel/runtime": "^7.12.5",
-    "another-json": "^0.2.0",
-    "bs58": "^5.0.0",
-    "content-type": "^1.0.4",
-    "loglevel": "^1.7.1",
-    "matrix-events-sdk": "0.0.1",
-    "matrix-widget-api": "^1.0.0",
-    "p-retry": "4",
-    "qs": "^6.9.6",
-    "sdp-transform": "^2.14.1",
-    "unhomoglyph": "^1.0.6",
-    "uuid": "7"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.12.10",
-    "@babel/core": "^7.12.10",
-    "@babel/eslint-parser": "^7.12.10",
-    "@babel/eslint-plugin": "^7.12.10",
-    "@babel/plugin-proposal-class-properties": "^7.12.1",
-    "@babel/plugin-proposal-numeric-separator": "^7.12.7",
-    "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
-    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-transform-runtime": "^7.12.10",
-    "@babel/preset-env": "^7.12.11",
-    "@babel/preset-typescript": "^7.12.7",
-    "@babel/register": "^7.12.10",
-    "@casualbot/jest-sonar-reporter": "^2.2.5",
-    "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
-    "@types/bs58": "^4.0.1",
-    "@types/content-type": "^1.1.5",
-    "@types/domexception": "^4.0.0",
-    "@types/jest": "^29.0.0",
-    "@types/node": "18",
-    "@types/sdp-transform": "^2.4.5",
-    "@types/uuid": "7",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
-    "allchange": "^1.0.6",
-    "babel-jest": "^29.0.0",
-    "babelify": "^10.0.0",
-    "better-docs": "^2.4.0-beta.9",
-    "browserify": "^17.0.0",
-    "docdash": "^2.0.0",
-    "domexception": "^4.0.0",
-    "eslint": "8.28.0",
-    "eslint-config-google": "^0.14.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-import-resolver-typescript": "^3.5.1",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jsdoc": "^39.6.4",
-    "eslint-plugin-matrix-org": "^0.9.0",
-    "eslint-plugin-tsdoc": "^0.2.17",
-    "eslint-plugin-unicorn": "^45.0.0",
-    "exorcist": "^2.0.0",
-    "fake-indexeddb": "^4.0.0",
-    "jest": "^29.0.0",
-    "jest-environment-jsdom": "^29.0.0",
-    "jest-localstorage-mock": "^2.4.6",
-    "jest-mock": "^29.0.0",
-    "matrix-mock-request": "^2.5.0",
-    "prettier": "2.8.0",
-    "rimraf": "^3.0.2",
-    "terser": "^5.5.1",
-    "tsify": "^5.0.2",
-    "typedoc": "^0.23.20",
-    "typedoc-plugin-missing-exports": "^1.0.0",
-    "typescript": "^4.5.3"
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "testMatch": [
-      "<rootDir>/spec/**/*.spec.{js,ts}"
+    "name": "matrix-js-sdk",
+    "version": "23.0.0",
+    "description": "Matrix Client-Server SDK for Javascript",
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "scripts": {
+        "prepublishOnly": "yarn build",
+        "start": "echo THIS IS FOR LEGACY PURPOSES ONLY. && babel src -w -s -d lib --verbose --extensions \".ts,.js\"",
+        "dist": "echo 'This is for the release script so it can make assets (browser bundle).' && yarn build",
+        "clean": "rimraf lib dist",
+        "build": "yarn build:dev && yarn build:compile-browser && yarn build:minify-browser",
+        "build:dev": "yarn clean && git rev-parse HEAD > git-revision.txt && yarn build:compile && yarn build:types",
+        "build:types": "tsc -p tsconfig-build.json --emitDeclarationOnly",
+        "build:compile": "babel -d lib --verbose --extensions \".ts,.js\" src",
+        "build:compile-browser": "mkdirp dist && browserify -d src/browser-index.ts -p [ tsify -p ./tsconfig-build.json ] -t [ babelify --sourceMaps=inline --presets [ @babel/preset-env @babel/preset-typescript ] ] | exorcist dist/browser-matrix.js.map > dist/browser-matrix.js",
+        "build:minify-browser": "terser dist/browser-matrix.js --compress --mangle --source-map --output dist/browser-matrix.min.js",
+        "gendoc": "typedoc",
+        "lint": "yarn lint:types && yarn lint:js",
+        "lint:js": "eslint --max-warnings 0 src spec && prettier --check .",
+        "lint:js-fix": "prettier --loglevel=warn --write . && eslint --fix src spec",
+        "lint:types": "tsc --noEmit",
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "coverage": "yarn test --coverage"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/matrix-org/matrix-js-sdk"
+    },
+    "keywords": [
+        "matrix-org"
     ],
-    "setupFilesAfterEnv": [
-      "<rootDir>/spec/setupTests.ts"
+    "main": "./lib/index.js",
+    "browser": "./lib/browser-index.ts",
+    "matrix_src_main": "./src/index.ts",
+    "matrix_src_browser": "./src/browser-index.ts",
+    "matrix_lib_main": "./lib/index.js",
+    "matrix_lib_typings": "./lib/index.d.ts",
+    "author": "matrix.org",
+    "license": "Apache-2.0",
+    "files": [
+        "dist",
+        "lib",
+        "src",
+        "git-revision.txt",
+        "CHANGELOG.md",
+        "CONTRIBUTING.rst",
+        "LICENSE",
+        "README.md",
+        "package.json",
+        "release.sh"
     ],
-    "collectCoverageFrom": [
-      "<rootDir>/src/**/*.{js,ts}"
-    ],
-    "coverageReporters": [
-      "text-summary",
-      "lcov"
-    ],
-    "testResultsProcessor": "@casualbot/jest-sonar-reporter"
-  },
-  "@casualbot/jest-sonar-reporter": {
-    "outputDirectory": "coverage",
-    "outputName": "jest-sonar-report.xml",
-    "relativePaths": true
-  },
-  "typings": "./lib/index.d.ts"
+    "dependencies": {
+        "@babel/runtime": "^7.12.5",
+        "another-json": "^0.2.0",
+        "bs58": "^5.0.0",
+        "content-type": "^1.0.4",
+        "loglevel": "^1.7.1",
+        "matrix-events-sdk": "0.0.1",
+        "matrix-widget-api": "^1.0.0",
+        "p-retry": "4",
+        "qs": "^6.9.6",
+        "sdp-transform": "^2.14.1",
+        "unhomoglyph": "^1.0.6",
+        "uuid": "7"
+    },
+    "devDependencies": {
+        "@babel/cli": "^7.12.10",
+        "@babel/core": "^7.12.10",
+        "@babel/eslint-parser": "^7.12.10",
+        "@babel/eslint-plugin": "^7.12.10",
+        "@babel/plugin-proposal-class-properties": "^7.12.1",
+        "@babel/plugin-proposal-numeric-separator": "^7.12.7",
+        "@babel/plugin-proposal-object-rest-spread": "^7.12.1",
+        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+        "@babel/plugin-transform-runtime": "^7.12.10",
+        "@babel/preset-env": "^7.12.11",
+        "@babel/preset-typescript": "^7.12.7",
+        "@babel/register": "^7.12.10",
+        "@casualbot/jest-sonar-reporter": "^2.2.5",
+        "@matrix-org/olm": "https://gitlab.matrix.org/api/v4/projects/27/packages/npm/@matrix-org/olm/-/@matrix-org/olm-3.2.14.tgz",
+        "@types/bs58": "^4.0.1",
+        "@types/content-type": "^1.1.5",
+        "@types/domexception": "^4.0.0",
+        "@types/jest": "^29.0.0",
+        "@types/node": "18",
+        "@types/sdp-transform": "^2.4.5",
+        "@types/uuid": "7",
+        "@typescript-eslint/eslint-plugin": "^5.45.0",
+        "@typescript-eslint/parser": "^5.45.0",
+        "allchange": "^1.0.6",
+        "babel-jest": "^29.0.0",
+        "babelify": "^10.0.0",
+        "better-docs": "^2.4.0-beta.9",
+        "browserify": "^17.0.0",
+        "docdash": "^2.0.0",
+        "domexception": "^4.0.0",
+        "eslint": "8.28.0",
+        "eslint-config-google": "^0.14.0",
+        "eslint-config-prettier": "^8.5.0",
+        "eslint-import-resolver-typescript": "^3.5.1",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-jsdoc": "^39.6.4",
+        "eslint-plugin-matrix-org": "^0.9.0",
+        "eslint-plugin-tsdoc": "^0.2.17",
+        "eslint-plugin-unicorn": "^45.0.0",
+        "exorcist": "^2.0.0",
+        "fake-indexeddb": "^4.0.0",
+        "jest": "^29.0.0",
+        "jest-environment-jsdom": "^29.0.0",
+        "jest-localstorage-mock": "^2.4.6",
+        "jest-mock": "^29.0.0",
+        "matrix-mock-request": "^2.5.0",
+        "prettier": "2.8.0",
+        "rimraf": "^3.0.2",
+        "terser": "^5.5.1",
+        "tsify": "^5.0.2",
+        "typedoc": "^0.23.20",
+        "typedoc-plugin-missing-exports": "^1.0.0",
+        "typescript": "^4.5.3"
+    },
+    "jest": {
+        "testEnvironment": "node",
+        "testMatch": [
+            "<rootDir>/spec/**/*.spec.{js,ts}"
+        ],
+        "setupFilesAfterEnv": [
+            "<rootDir>/spec/setupTests.ts"
+        ],
+        "collectCoverageFrom": [
+            "<rootDir>/src/**/*.{js,ts}"
+        ],
+        "coverageReporters": [
+            "text-summary",
+            "lcov"
+        ],
+        "testResultsProcessor": "@casualbot/jest-sonar-reporter"
+    },
+    "@casualbot/jest-sonar-reporter": {
+        "outputDirectory": "coverage",
+        "outputName": "jest-sonar-report.xml",
+        "relativePaths": true
+    },
+    "typings": "./lib/index.d.ts"
 }